metal-rust-ffi 1.0.0

//! Generated safe Metal scalar enums and option sets.
//!
//! Regenerate with `python3 scripts/generate_value_types.py`.

#![allow(clippy::upper_case_acronyms)]
#![allow(dead_code)]
#![allow(non_upper_case_globals)]

impl super::PixelFormat {
    /// Metal value `MTL::PixelFormat::PixelFormatA1BGR5Unorm`.
    pub const PixelFormatA1BGR5Unorm: Self = Self(41);
    /// Metal value `MTL::PixelFormat::PixelFormatA8Unorm`.
    pub const PixelFormatA8Unorm: Self = Self(1);
    /// Metal value `MTL::PixelFormat::PixelFormatABGR4Unorm`.
    pub const PixelFormatABGR4Unorm: Self = Self(42);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x10_HDR`.
    pub const PixelFormatASTC_10x10_HDR: Self = Self(234);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x10_LDR`.
    pub const PixelFormatASTC_10x10_LDR: Self = Self(216);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x10_sRGB`.
    pub const PixelFormatASTC_10x10_sRGB: Self = Self(198);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x5_HDR`.
    pub const PixelFormatASTC_10x5_HDR: Self = Self(231);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x5_LDR`.
    pub const PixelFormatASTC_10x5_LDR: Self = Self(213);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x5_sRGB`.
    pub const PixelFormatASTC_10x5_sRGB: Self = Self(195);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x6_HDR`.
    pub const PixelFormatASTC_10x6_HDR: Self = Self(232);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x6_LDR`.
    pub const PixelFormatASTC_10x6_LDR: Self = Self(214);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x6_sRGB`.
    pub const PixelFormatASTC_10x6_sRGB: Self = Self(196);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x8_HDR`.
    pub const PixelFormatASTC_10x8_HDR: Self = Self(233);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x8_LDR`.
    pub const PixelFormatASTC_10x8_LDR: Self = Self(215);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_10x8_sRGB`.
    pub const PixelFormatASTC_10x8_sRGB: Self = Self(197);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x10_HDR`.
    pub const PixelFormatASTC_12x10_HDR: Self = Self(235);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x10_LDR`.
    pub const PixelFormatASTC_12x10_LDR: Self = Self(217);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x10_sRGB`.
    pub const PixelFormatASTC_12x10_sRGB: Self = Self(199);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x12_HDR`.
    pub const PixelFormatASTC_12x12_HDR: Self = Self(236);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x12_LDR`.
    pub const PixelFormatASTC_12x12_LDR: Self = Self(218);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_12x12_sRGB`.
    pub const PixelFormatASTC_12x12_sRGB: Self = Self(200);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_4x4_HDR`.
    pub const PixelFormatASTC_4x4_HDR: Self = Self(222);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_4x4_LDR`.
    pub const PixelFormatASTC_4x4_LDR: Self = Self(204);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_4x4_sRGB`.
    pub const PixelFormatASTC_4x4_sRGB: Self = Self(186);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x4_HDR`.
    pub const PixelFormatASTC_5x4_HDR: Self = Self(223);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x4_LDR`.
    pub const PixelFormatASTC_5x4_LDR: Self = Self(205);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x4_sRGB`.
    pub const PixelFormatASTC_5x4_sRGB: Self = Self(187);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x5_HDR`.
    pub const PixelFormatASTC_5x5_HDR: Self = Self(224);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x5_LDR`.
    pub const PixelFormatASTC_5x5_LDR: Self = Self(206);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_5x5_sRGB`.
    pub const PixelFormatASTC_5x5_sRGB: Self = Self(188);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x5_HDR`.
    pub const PixelFormatASTC_6x5_HDR: Self = Self(225);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x5_LDR`.
    pub const PixelFormatASTC_6x5_LDR: Self = Self(207);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x5_sRGB`.
    pub const PixelFormatASTC_6x5_sRGB: Self = Self(189);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x6_HDR`.
    pub const PixelFormatASTC_6x6_HDR: Self = Self(226);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x6_LDR`.
    pub const PixelFormatASTC_6x6_LDR: Self = Self(208);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_6x6_sRGB`.
    pub const PixelFormatASTC_6x6_sRGB: Self = Self(190);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x5_HDR`.
    pub const PixelFormatASTC_8x5_HDR: Self = Self(228);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x5_LDR`.
    pub const PixelFormatASTC_8x5_LDR: Self = Self(210);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x5_sRGB`.
    pub const PixelFormatASTC_8x5_sRGB: Self = Self(192);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x6_HDR`.
    pub const PixelFormatASTC_8x6_HDR: Self = Self(229);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x6_LDR`.
    pub const PixelFormatASTC_8x6_LDR: Self = Self(211);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x6_sRGB`.
    pub const PixelFormatASTC_8x6_sRGB: Self = Self(193);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x8_HDR`.
    pub const PixelFormatASTC_8x8_HDR: Self = Self(230);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x8_LDR`.
    pub const PixelFormatASTC_8x8_LDR: Self = Self(212);
    /// Metal value `MTL::PixelFormat::PixelFormatASTC_8x8_sRGB`.
    pub const PixelFormatASTC_8x8_sRGB: Self = Self(194);
    /// Metal value `MTL::PixelFormat::PixelFormatB5G6R5Unorm`.
    pub const PixelFormatB5G6R5Unorm: Self = Self(40);
    /// Metal value `MTL::PixelFormat::PixelFormatBC1_RGBA`.
    pub const PixelFormatBC1_RGBA: Self = Self(130);
    /// Metal value `MTL::PixelFormat::PixelFormatBC1_RGBA_sRGB`.
    pub const PixelFormatBC1_RGBA_sRGB: Self = Self(131);
    /// Metal value `MTL::PixelFormat::PixelFormatBC2_RGBA`.
    pub const PixelFormatBC2_RGBA: Self = Self(132);
    /// Metal value `MTL::PixelFormat::PixelFormatBC2_RGBA_sRGB`.
    pub const PixelFormatBC2_RGBA_sRGB: Self = Self(133);
    /// Metal value `MTL::PixelFormat::PixelFormatBC3_RGBA`.
    pub const PixelFormatBC3_RGBA: Self = Self(134);
    /// Metal value `MTL::PixelFormat::PixelFormatBC3_RGBA_sRGB`.
    pub const PixelFormatBC3_RGBA_sRGB: Self = Self(135);
    /// Metal value `MTL::PixelFormat::PixelFormatBC4_RSnorm`.
    pub const PixelFormatBC4_RSnorm: Self = Self(141);
    /// Metal value `MTL::PixelFormat::PixelFormatBC4_RUnorm`.
    pub const PixelFormatBC4_RUnorm: Self = Self(140);
    /// Metal value `MTL::PixelFormat::PixelFormatBC5_RGSnorm`.
    pub const PixelFormatBC5_RGSnorm: Self = Self(143);
    /// Metal value `MTL::PixelFormat::PixelFormatBC5_RGUnorm`.
    pub const PixelFormatBC5_RGUnorm: Self = Self(142);
    /// Metal value `MTL::PixelFormat::PixelFormatBC6H_RGBFloat`.
    pub const PixelFormatBC6H_RGBFloat: Self = Self(150);
    /// Metal value `MTL::PixelFormat::PixelFormatBC6H_RGBUfloat`.
    pub const PixelFormatBC6H_RGBUfloat: Self = Self(151);
    /// Metal value `MTL::PixelFormat::PixelFormatBC7_RGBAUnorm`.
    pub const PixelFormatBC7_RGBAUnorm: Self = Self(152);
    /// Metal value `MTL::PixelFormat::PixelFormatBC7_RGBAUnorm_sRGB`.
    pub const PixelFormatBC7_RGBAUnorm_sRGB: Self = Self(153);
    /// Metal value `MTL::PixelFormat::PixelFormatBGR10A2Unorm`.
    pub const PixelFormatBGR10A2Unorm: Self = Self(94);
    /// Metal value `MTL::PixelFormat::PixelFormatBGR10_XR`.
    pub const PixelFormatBGR10_XR: Self = Self(554);
    /// Metal value `MTL::PixelFormat::PixelFormatBGR10_XR_sRGB`.
    pub const PixelFormatBGR10_XR_sRGB: Self = Self(555);
    /// Metal value `MTL::PixelFormat::PixelFormatBGR5A1Unorm`.
    pub const PixelFormatBGR5A1Unorm: Self = Self(43);
    /// Metal value `MTL::PixelFormat::PixelFormatBGRA10_XR`.
    pub const PixelFormatBGRA10_XR: Self = Self(552);
    /// Metal value `MTL::PixelFormat::PixelFormatBGRA10_XR_sRGB`.
    pub const PixelFormatBGRA10_XR_sRGB: Self = Self(553);
    /// Metal value `MTL::PixelFormat::PixelFormatBGRA8Unorm`.
    pub const PixelFormatBGRA8Unorm: Self = Self(80);
    /// Metal value `MTL::PixelFormat::PixelFormatBGRA8Unorm_sRGB`.
    pub const PixelFormatBGRA8Unorm_sRGB: Self = Self(81);
    /// Metal value `MTL::PixelFormat::PixelFormatBGRG422`.
    pub const PixelFormatBGRG422: Self = Self(241);
    /// Metal value `MTL::PixelFormat::PixelFormatDepth16Unorm`.
    pub const PixelFormatDepth16Unorm: Self = Self(250);
    /// Metal value `MTL::PixelFormat::PixelFormatDepth24Unorm_Stencil8`.
    pub const PixelFormatDepth24Unorm_Stencil8: Self = Self(255);
    /// Metal value `MTL::PixelFormat::PixelFormatDepth32Float`.
    pub const PixelFormatDepth32Float: Self = Self(252);
    /// Metal value `MTL::PixelFormat::PixelFormatDepth32Float_Stencil8`.
    pub const PixelFormatDepth32Float_Stencil8: Self = Self(260);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_R11Snorm`.
    pub const PixelFormatEAC_R11Snorm: Self = Self(172);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_R11Unorm`.
    pub const PixelFormatEAC_R11Unorm: Self = Self(170);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_RG11Snorm`.
    pub const PixelFormatEAC_RG11Snorm: Self = Self(176);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_RG11Unorm`.
    pub const PixelFormatEAC_RG11Unorm: Self = Self(174);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_RGBA8`.
    pub const PixelFormatEAC_RGBA8: Self = Self(178);
    /// Metal value `MTL::PixelFormat::PixelFormatEAC_RGBA8_sRGB`.
    pub const PixelFormatEAC_RGBA8_sRGB: Self = Self(179);
    /// Metal value `MTL::PixelFormat::PixelFormatETC2_RGB8`.
    pub const PixelFormatETC2_RGB8: Self = Self(180);
    /// Metal value `MTL::PixelFormat::PixelFormatETC2_RGB8A1`.
    pub const PixelFormatETC2_RGB8A1: Self = Self(182);
    /// Metal value `MTL::PixelFormat::PixelFormatETC2_RGB8A1_sRGB`.
    pub const PixelFormatETC2_RGB8A1_sRGB: Self = Self(183);
    /// Metal value `MTL::PixelFormat::PixelFormatETC2_RGB8_sRGB`.
    pub const PixelFormatETC2_RGB8_sRGB: Self = Self(181);
    /// Metal value `MTL::PixelFormat::PixelFormatGBGR422`.
    pub const PixelFormatGBGR422: Self = Self(240);
    /// Metal value `MTL::PixelFormat::PixelFormatInvalid`.
    pub const PixelFormatInvalid: Self = Self(0);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGBA_2BPP`.
    pub const PixelFormatPVRTC_RGBA_2BPP: Self = Self(164);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGBA_2BPP_sRGB`.
    pub const PixelFormatPVRTC_RGBA_2BPP_sRGB: Self = Self(165);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGBA_4BPP`.
    pub const PixelFormatPVRTC_RGBA_4BPP: Self = Self(166);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGBA_4BPP_sRGB`.
    pub const PixelFormatPVRTC_RGBA_4BPP_sRGB: Self = Self(167);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGB_2BPP`.
    pub const PixelFormatPVRTC_RGB_2BPP: Self = Self(160);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGB_2BPP_sRGB`.
    pub const PixelFormatPVRTC_RGB_2BPP_sRGB: Self = Self(161);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGB_4BPP`.
    pub const PixelFormatPVRTC_RGB_4BPP: Self = Self(162);
    /// Metal value `MTL::PixelFormat::PixelFormatPVRTC_RGB_4BPP_sRGB`.
    pub const PixelFormatPVRTC_RGB_4BPP_sRGB: Self = Self(163);
    /// Metal value `MTL::PixelFormat::PixelFormatR16Float`.
    pub const PixelFormatR16Float: Self = Self(25);
    /// Metal value `MTL::PixelFormat::PixelFormatR16Sint`.
    pub const PixelFormatR16Sint: Self = Self(24);
    /// Metal value `MTL::PixelFormat::PixelFormatR16Snorm`.
    pub const PixelFormatR16Snorm: Self = Self(22);
    /// Metal value `MTL::PixelFormat::PixelFormatR16Uint`.
    pub const PixelFormatR16Uint: Self = Self(23);
    /// Metal value `MTL::PixelFormat::PixelFormatR16Unorm`.
    pub const PixelFormatR16Unorm: Self = Self(20);
    /// Metal value `MTL::PixelFormat::PixelFormatR32Float`.
    pub const PixelFormatR32Float: Self = Self(55);
    /// Metal value `MTL::PixelFormat::PixelFormatR32Sint`.
    pub const PixelFormatR32Sint: Self = Self(54);
    /// Metal value `MTL::PixelFormat::PixelFormatR32Uint`.
    pub const PixelFormatR32Uint: Self = Self(53);
    /// Metal value `MTL::PixelFormat::PixelFormatR8Sint`.
    pub const PixelFormatR8Sint: Self = Self(14);
    /// Metal value `MTL::PixelFormat::PixelFormatR8Snorm`.
    pub const PixelFormatR8Snorm: Self = Self(12);
    /// Metal value `MTL::PixelFormat::PixelFormatR8Uint`.
    pub const PixelFormatR8Uint: Self = Self(13);
    /// Metal value `MTL::PixelFormat::PixelFormatR8Unorm`.
    pub const PixelFormatR8Unorm: Self = Self(10);
    /// Metal value `MTL::PixelFormat::PixelFormatR8Unorm_sRGB`.
    pub const PixelFormatR8Unorm_sRGB: Self = Self(11);
    /// Metal value `MTL::PixelFormat::PixelFormatRG11B10Float`.
    pub const PixelFormatRG11B10Float: Self = Self(92);
    /// Metal value `MTL::PixelFormat::PixelFormatRG16Float`.
    pub const PixelFormatRG16Float: Self = Self(65);
    /// Metal value `MTL::PixelFormat::PixelFormatRG16Sint`.
    pub const PixelFormatRG16Sint: Self = Self(64);
    /// Metal value `MTL::PixelFormat::PixelFormatRG16Snorm`.
    pub const PixelFormatRG16Snorm: Self = Self(62);
    /// Metal value `MTL::PixelFormat::PixelFormatRG16Uint`.
    pub const PixelFormatRG16Uint: Self = Self(63);
    /// Metal value `MTL::PixelFormat::PixelFormatRG16Unorm`.
    pub const PixelFormatRG16Unorm: Self = Self(60);
    /// Metal value `MTL::PixelFormat::PixelFormatRG32Float`.
    pub const PixelFormatRG32Float: Self = Self(105);
    /// Metal value `MTL::PixelFormat::PixelFormatRG32Sint`.
    pub const PixelFormatRG32Sint: Self = Self(104);
    /// Metal value `MTL::PixelFormat::PixelFormatRG32Uint`.
    pub const PixelFormatRG32Uint: Self = Self(103);
    /// Metal value `MTL::PixelFormat::PixelFormatRG8Sint`.
    pub const PixelFormatRG8Sint: Self = Self(34);
    /// Metal value `MTL::PixelFormat::PixelFormatRG8Snorm`.
    pub const PixelFormatRG8Snorm: Self = Self(32);
    /// Metal value `MTL::PixelFormat::PixelFormatRG8Uint`.
    pub const PixelFormatRG8Uint: Self = Self(33);
    /// Metal value `MTL::PixelFormat::PixelFormatRG8Unorm`.
    pub const PixelFormatRG8Unorm: Self = Self(30);
    /// Metal value `MTL::PixelFormat::PixelFormatRG8Unorm_sRGB`.
    pub const PixelFormatRG8Unorm_sRGB: Self = Self(31);
    /// Metal value `MTL::PixelFormat::PixelFormatRGB10A2Uint`.
    pub const PixelFormatRGB10A2Uint: Self = Self(91);
    /// Metal value `MTL::PixelFormat::PixelFormatRGB10A2Unorm`.
    pub const PixelFormatRGB10A2Unorm: Self = Self(90);
    /// Metal value `MTL::PixelFormat::PixelFormatRGB9E5Float`.
    pub const PixelFormatRGB9E5Float: Self = Self(93);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA16Float`.
    pub const PixelFormatRGBA16Float: Self = Self(115);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA16Sint`.
    pub const PixelFormatRGBA16Sint: Self = Self(114);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA16Snorm`.
    pub const PixelFormatRGBA16Snorm: Self = Self(112);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA16Uint`.
    pub const PixelFormatRGBA16Uint: Self = Self(113);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA16Unorm`.
    pub const PixelFormatRGBA16Unorm: Self = Self(110);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA32Float`.
    pub const PixelFormatRGBA32Float: Self = Self(125);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA32Sint`.
    pub const PixelFormatRGBA32Sint: Self = Self(124);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA32Uint`.
    pub const PixelFormatRGBA32Uint: Self = Self(123);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA8Sint`.
    pub const PixelFormatRGBA8Sint: Self = Self(74);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA8Snorm`.
    pub const PixelFormatRGBA8Snorm: Self = Self(72);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA8Uint`.
    pub const PixelFormatRGBA8Uint: Self = Self(73);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA8Unorm`.
    pub const PixelFormatRGBA8Unorm: Self = Self(70);
    /// Metal value `MTL::PixelFormat::PixelFormatRGBA8Unorm_sRGB`.
    pub const PixelFormatRGBA8Unorm_sRGB: Self = Self(71);
    /// Metal value `MTL::PixelFormat::PixelFormatStencil8`.
    pub const PixelFormatStencil8: Self = Self(253);
    /// Metal value `MTL::PixelFormat::PixelFormatUnspecialized`.
    pub const PixelFormatUnspecialized: Self = Self(263);
    /// Metal value `MTL::PixelFormat::PixelFormatX24_Stencil8`.
    pub const PixelFormatX24_Stencil8: Self = Self(262);
    /// Metal value `MTL::PixelFormat::PixelFormatX32_Stencil8`.
    pub const PixelFormatX32_Stencil8: Self = Self(261);
}

impl super::ResourceOptions {
    /// Metal value `MTL::ResourceOptions::ResourceCPUCacheModeDefaultCache`.
    pub const ResourceCPUCacheModeDefaultCache: Self = Self(0);
    /// Metal value `MTL::ResourceOptions::ResourceCPUCacheModeWriteCombined`.
    pub const ResourceCPUCacheModeWriteCombined: Self = Self(1);
    /// Metal value `MTL::ResourceOptions::ResourceHazardTrackingModeDefault`.
    pub const ResourceHazardTrackingModeDefault: Self = Self(0);
    /// Metal value `MTL::ResourceOptions::ResourceHazardTrackingModeTracked`.
    pub const ResourceHazardTrackingModeTracked: Self = Self(512);
    /// Metal value `MTL::ResourceOptions::ResourceHazardTrackingModeUntracked`.
    pub const ResourceHazardTrackingModeUntracked: Self = Self(256);
    /// Metal value `MTL::ResourceOptions::ResourceStorageModeManaged`.
    pub const ResourceStorageModeManaged: Self = Self(16);
    /// Metal value `MTL::ResourceOptions::ResourceStorageModeMemoryless`.
    pub const ResourceStorageModeMemoryless: Self = Self(48);
    /// Metal value `MTL::ResourceOptions::ResourceStorageModePrivate`.
    pub const ResourceStorageModePrivate: Self = Self(32);
    /// Metal value `MTL::ResourceOptions::ResourceStorageModeShared`.
    pub const ResourceStorageModeShared: Self = Self(0);
}

impl super::TextureUsage {
    /// Metal value `MTL::TextureUsage::TextureUsagePixelFormatView`.
    pub const TextureUsagePixelFormatView: Self = Self(16);
    /// Metal value `MTL::TextureUsage::TextureUsageRenderTarget`.
    pub const TextureUsageRenderTarget: Self = Self(4);
    /// Metal value `MTL::TextureUsage::TextureUsageShaderAtomic`.
    pub const TextureUsageShaderAtomic: Self = Self(32);
    /// Metal value `MTL::TextureUsage::TextureUsageShaderRead`.
    pub const TextureUsageShaderRead: Self = Self(1);
    /// Metal value `MTL::TextureUsage::TextureUsageShaderWrite`.
    pub const TextureUsageShaderWrite: Self = Self(2);
    /// Metal value `MTL::TextureUsage::TextureUsageUnknown`.
    pub const TextureUsageUnknown: Self = Self(0);
}

/// Safe scalar wrapper for the Metal `MTL4::AlphaToCoverageState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AlphaToCoverageState(isize);

impl AlphaToCoverageState {
    /// Metal value `MTL4::AlphaToCoverageState::AlphaToCoverageStateDisabled`.
    pub const AlphaToCoverageStateDisabled: Self = Self(0);
    /// Metal value `MTL4::AlphaToCoverageState::AlphaToCoverageStateEnabled`.
    pub const AlphaToCoverageStateEnabled: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for AlphaToCoverageState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::AlphaToOneState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AlphaToOneState(isize);

impl AlphaToOneState {
    /// Metal value `MTL4::AlphaToOneState::AlphaToOneStateDisabled`.
    pub const AlphaToOneStateDisabled: Self = Self(0);
    /// Metal value `MTL4::AlphaToOneState::AlphaToOneStateEnabled`.
    pub const AlphaToOneStateEnabled: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for AlphaToOneState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::BinaryFunctionOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BinaryFunctionOptions(usize);

impl BinaryFunctionOptions {
    /// Metal value `MTL4::BinaryFunctionOptions::BinaryFunctionOptionNone`.
    pub const BinaryFunctionOptionNone: Self = Self(0);
    /// Metal value `MTL4::BinaryFunctionOptions::BinaryFunctionOptionPipelineIndependent`.
    pub const BinaryFunctionOptionPipelineIndependent: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 2;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for BinaryFunctionOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for BinaryFunctionOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL4::BlendState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BlendState(isize);

impl BlendState {
    /// Metal value `MTL4::BlendState::BlendStateDisabled`.
    pub const BlendStateDisabled: Self = Self(0);
    /// Metal value `MTL4::BlendState::BlendStateEnabled`.
    pub const BlendStateEnabled: Self = Self(1);
    /// Metal value `MTL4::BlendState::BlendStateUnspecialized`.
    pub const BlendStateUnspecialized: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for BlendState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::CommandQueueError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CommandQueueError(isize);

impl CommandQueueError {
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorAccessRevoked`.
    pub const CommandQueueErrorAccessRevoked: Self = Self(5);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorDeviceRemoved`.
    pub const CommandQueueErrorDeviceRemoved: Self = Self(4);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorInternal`.
    pub const CommandQueueErrorInternal: Self = Self(6);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorNone`.
    pub const CommandQueueErrorNone: Self = Self(0);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorNotPermitted`.
    pub const CommandQueueErrorNotPermitted: Self = Self(2);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorOutOfMemory`.
    pub const CommandQueueErrorOutOfMemory: Self = Self(3);
    /// Metal value `MTL4::CommandQueueError::CommandQueueErrorTimeout`.
    pub const CommandQueueErrorTimeout: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=6)
    }
}

impl std::convert::TryFrom<isize> for CommandQueueError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::CompilerTaskStatus` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CompilerTaskStatus(isize);

impl CompilerTaskStatus {
    /// Metal value `MTL4::CompilerTaskStatus::CompilerTaskStatusCompiling`.
    pub const CompilerTaskStatusCompiling: Self = Self(2);
    /// Metal value `MTL4::CompilerTaskStatus::CompilerTaskStatusFinished`.
    pub const CompilerTaskStatusFinished: Self = Self(3);
    /// Metal value `MTL4::CompilerTaskStatus::CompilerTaskStatusNone`.
    pub const CompilerTaskStatusNone: Self = Self(0);
    /// Metal value `MTL4::CompilerTaskStatus::CompilerTaskStatusScheduled`.
    pub const CompilerTaskStatusScheduled: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<isize> for CompilerTaskStatus {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::CounterHeapType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CounterHeapType(isize);

impl CounterHeapType {
    /// Metal value `MTL4::CounterHeapType::CounterHeapTypeInvalid`.
    pub const CounterHeapTypeInvalid: Self = Self(0);
    /// Metal value `MTL4::CounterHeapType::CounterHeapTypeTimestamp`.
    pub const CounterHeapTypeTimestamp: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for CounterHeapType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::IndirectCommandBufferSupportState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IndirectCommandBufferSupportState(isize);

impl IndirectCommandBufferSupportState {
    /// Metal value `MTL4::IndirectCommandBufferSupportState::IndirectCommandBufferSupportStateDisabled`.
    pub const IndirectCommandBufferSupportStateDisabled: Self = Self(0);
    /// Metal value `MTL4::IndirectCommandBufferSupportState::IndirectCommandBufferSupportStateEnabled`.
    pub const IndirectCommandBufferSupportStateEnabled: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for IndirectCommandBufferSupportState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::LogicalToPhysicalColorAttachmentMappingState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LogicalToPhysicalColorAttachmentMappingState(isize);

impl LogicalToPhysicalColorAttachmentMappingState {
    /// Metal value `MTL4::LogicalToPhysicalColorAttachmentMappingState::LogicalToPhysicalColorAttachmentMappingStateIdentity`.
    pub const LogicalToPhysicalColorAttachmentMappingStateIdentity: Self = Self(0);
    /// Metal value `MTL4::LogicalToPhysicalColorAttachmentMappingState::LogicalToPhysicalColorAttachmentMappingStateInherited`.
    pub const LogicalToPhysicalColorAttachmentMappingStateInherited: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for LogicalToPhysicalColorAttachmentMappingState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::PipelineDataSetSerializerConfiguration` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct PipelineDataSetSerializerConfiguration(usize);

impl PipelineDataSetSerializerConfiguration {
    /// Metal value `MTL4::PipelineDataSetSerializerConfiguration::PipelineDataSetSerializerConfigurationCaptureBinaries`.
    pub const PipelineDataSetSerializerConfigurationCaptureBinaries: Self = Self(2);
    /// Metal value `MTL4::PipelineDataSetSerializerConfiguration::PipelineDataSetSerializerConfigurationCaptureDescriptors`.
    pub const PipelineDataSetSerializerConfigurationCaptureDescriptors: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for PipelineDataSetSerializerConfiguration {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for PipelineDataSetSerializerConfiguration {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL4::RenderEncoderOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct RenderEncoderOptions(usize);

impl RenderEncoderOptions {
    /// Metal value `MTL4::RenderEncoderOptions::RenderEncoderOptionNone`.
    pub const RenderEncoderOptionNone: Self = Self(0);
    /// Metal value `MTL4::RenderEncoderOptions::RenderEncoderOptionResuming`.
    pub const RenderEncoderOptionResuming: Self = Self(2);
    /// Metal value `MTL4::RenderEncoderOptions::RenderEncoderOptionSuspending`.
    pub const RenderEncoderOptionSuspending: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for RenderEncoderOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for RenderEncoderOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL4::ShaderReflection` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ShaderReflection(usize);

impl ShaderReflection {
    /// Metal value `MTL4::ShaderReflection::ShaderReflectionBindingInfo`.
    pub const ShaderReflectionBindingInfo: Self = Self(1);
    /// Metal value `MTL4::ShaderReflection::ShaderReflectionBufferTypeInfo`.
    pub const ShaderReflectionBufferTypeInfo: Self = Self(2);
    /// Metal value `MTL4::ShaderReflection::ShaderReflectionNone`.
    pub const ShaderReflectionNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for ShaderReflection {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for ShaderReflection {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL4::TimestampGranularity` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TimestampGranularity(isize);

impl TimestampGranularity {
    /// Metal value `MTL4::TimestampGranularity::TimestampGranularityPrecise`.
    pub const TimestampGranularityPrecise: Self = Self(1);
    /// Metal value `MTL4::TimestampGranularity::TimestampGranularityRelaxed`.
    pub const TimestampGranularityRelaxed: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for TimestampGranularity {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL4::VisibilityOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VisibilityOptions(usize);

impl VisibilityOptions {
    /// Metal value `MTL4::VisibilityOptions::VisibilityOptionDevice`.
    pub const VisibilityOptionDevice: Self = Self(1);
    /// Metal value `MTL4::VisibilityOptions::VisibilityOptionNone`.
    pub const VisibilityOptionNone: Self = Self(0);
    /// Metal value `MTL4::VisibilityOptions::VisibilityOptionResourceAlias`.
    pub const VisibilityOptionResourceAlias: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for VisibilityOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for VisibilityOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::AccelerationStructureInstanceDescriptorType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AccelerationStructureInstanceDescriptorType(usize);

impl AccelerationStructureInstanceDescriptorType {
    /// Metal value `MTL::AccelerationStructureInstanceDescriptorType::AccelerationStructureInstanceDescriptorTypeDefault`.
    pub const AccelerationStructureInstanceDescriptorTypeDefault: Self = Self(0);
    /// Metal value `MTL::AccelerationStructureInstanceDescriptorType::AccelerationStructureInstanceDescriptorTypeIndirect`.
    pub const AccelerationStructureInstanceDescriptorTypeIndirect: Self = Self(3);
    /// Metal value `MTL::AccelerationStructureInstanceDescriptorType::AccelerationStructureInstanceDescriptorTypeIndirectMotion`.
    pub const AccelerationStructureInstanceDescriptorTypeIndirectMotion: Self = Self(4);
    /// Metal value `MTL::AccelerationStructureInstanceDescriptorType::AccelerationStructureInstanceDescriptorTypeMotion`.
    pub const AccelerationStructureInstanceDescriptorTypeMotion: Self = Self(2);
    /// Metal value `MTL::AccelerationStructureInstanceDescriptorType::AccelerationStructureInstanceDescriptorTypeUserID`.
    pub const AccelerationStructureInstanceDescriptorTypeUserID: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<usize> for AccelerationStructureInstanceDescriptorType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::AccelerationStructureInstanceOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AccelerationStructureInstanceOptions(u32);

impl AccelerationStructureInstanceOptions {
    /// Metal value `MTL::AccelerationStructureInstanceOptions::AccelerationStructureInstanceOptionDisableTriangleCulling`.
    pub const AccelerationStructureInstanceOptionDisableTriangleCulling: Self = Self(1);
    /// Metal value `MTL::AccelerationStructureInstanceOptions::AccelerationStructureInstanceOptionNonOpaque`.
    pub const AccelerationStructureInstanceOptionNonOpaque: Self = Self(8);
    /// Metal value `MTL::AccelerationStructureInstanceOptions::AccelerationStructureInstanceOptionNone`.
    pub const AccelerationStructureInstanceOptionNone: Self = Self(0);
    /// Metal value `MTL::AccelerationStructureInstanceOptions::AccelerationStructureInstanceOptionOpaque`.
    pub const AccelerationStructureInstanceOptionOpaque: Self = Self(4);
    /// Metal value `MTL::AccelerationStructureInstanceOptions::AccelerationStructureInstanceOptionTriangleFrontFacingWindingCounterClockwise`.
    pub const AccelerationStructureInstanceOptionTriangleFrontFacingWindingCounterClockwise: Self =
        Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: u32) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> u32 {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: u32 = 15;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: u32) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for AccelerationStructureInstanceOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for AccelerationStructureInstanceOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::AccelerationStructureRefitOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AccelerationStructureRefitOptions(usize);

impl AccelerationStructureRefitOptions {
    /// Metal value `MTL::AccelerationStructureRefitOptions::AccelerationStructureRefitOptionPerPrimitiveData`.
    pub const AccelerationStructureRefitOptionPerPrimitiveData: Self = Self(2);
    /// Metal value `MTL::AccelerationStructureRefitOptions::AccelerationStructureRefitOptionVertexData`.
    pub const AccelerationStructureRefitOptionVertexData: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for AccelerationStructureRefitOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for AccelerationStructureRefitOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::AccelerationStructureUsage` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AccelerationStructureUsage(usize);

impl AccelerationStructureUsage {
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsageExtendedLimits`.
    pub const AccelerationStructureUsageExtendedLimits: Self = Self(4);
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsageMinimizeMemory`.
    pub const AccelerationStructureUsageMinimizeMemory: Self = Self(32);
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsageNone`.
    pub const AccelerationStructureUsageNone: Self = Self(0);
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsagePreferFastBuild`.
    pub const AccelerationStructureUsagePreferFastBuild: Self = Self(2);
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsagePreferFastIntersection`.
    pub const AccelerationStructureUsagePreferFastIntersection: Self = Self(16);
    /// Metal value `MTL::AccelerationStructureUsage::AccelerationStructureUsageRefit`.
    pub const AccelerationStructureUsageRefit: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 55;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for AccelerationStructureUsage {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for AccelerationStructureUsage {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::ArgumentBuffersTier` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ArgumentBuffersTier(usize);

impl ArgumentBuffersTier {
    /// Metal value `MTL::ArgumentBuffersTier::ArgumentBuffersTier1`.
    pub const ArgumentBuffersTier1: Self = Self(0);
    /// Metal value `MTL::ArgumentBuffersTier::ArgumentBuffersTier2`.
    pub const ArgumentBuffersTier2: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for ArgumentBuffersTier {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::ArgumentType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ArgumentType(usize);

impl ArgumentType {
    /// Metal value `MTL::ArgumentType::ArgumentTypeBuffer`.
    pub const ArgumentTypeBuffer: Self = Self(0);
    /// Metal value `MTL::ArgumentType::ArgumentTypeImageblock`.
    pub const ArgumentTypeImageblock: Self = Self(17);
    /// Metal value `MTL::ArgumentType::ArgumentTypeImageblockData`.
    pub const ArgumentTypeImageblockData: Self = Self(16);
    /// Metal value `MTL::ArgumentType::ArgumentTypeInstanceAccelerationStructure`.
    pub const ArgumentTypeInstanceAccelerationStructure: Self = Self(26);
    /// Metal value `MTL::ArgumentType::ArgumentTypeIntersectionFunctionTable`.
    pub const ArgumentTypeIntersectionFunctionTable: Self = Self(27);
    /// Metal value `MTL::ArgumentType::ArgumentTypePrimitiveAccelerationStructure`.
    pub const ArgumentTypePrimitiveAccelerationStructure: Self = Self(25);
    /// Metal value `MTL::ArgumentType::ArgumentTypeSampler`.
    pub const ArgumentTypeSampler: Self = Self(3);
    /// Metal value `MTL::ArgumentType::ArgumentTypeTexture`.
    pub const ArgumentTypeTexture: Self = Self(2);
    /// Metal value `MTL::ArgumentType::ArgumentTypeThreadgroupMemory`.
    pub const ArgumentTypeThreadgroupMemory: Self = Self(1);
    /// Metal value `MTL::ArgumentType::ArgumentTypeVisibleFunctionTable`.
    pub const ArgumentTypeVisibleFunctionTable: Self = Self(24);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3 | 16 | 17 | 24..=27)
    }
}

impl std::convert::TryFrom<usize> for ArgumentType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::AttributeFormat` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct AttributeFormat(usize);

impl AttributeFormat {
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar`.
    pub const AttributeFormatChar: Self = Self(46);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar2`.
    pub const AttributeFormatChar2: Self = Self(4);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar2Normalized`.
    pub const AttributeFormatChar2Normalized: Self = Self(10);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar3`.
    pub const AttributeFormatChar3: Self = Self(5);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar3Normalized`.
    pub const AttributeFormatChar3Normalized: Self = Self(11);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar4`.
    pub const AttributeFormatChar4: Self = Self(6);
    /// Metal value `MTL::AttributeFormat::AttributeFormatChar4Normalized`.
    pub const AttributeFormatChar4Normalized: Self = Self(12);
    /// Metal value `MTL::AttributeFormat::AttributeFormatCharNormalized`.
    pub const AttributeFormatCharNormalized: Self = Self(48);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloat`.
    pub const AttributeFormatFloat: Self = Self(28);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloat2`.
    pub const AttributeFormatFloat2: Self = Self(29);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloat3`.
    pub const AttributeFormatFloat3: Self = Self(30);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloat4`.
    pub const AttributeFormatFloat4: Self = Self(31);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloatRG11B10`.
    pub const AttributeFormatFloatRG11B10: Self = Self(54);
    /// Metal value `MTL::AttributeFormat::AttributeFormatFloatRGB9E5`.
    pub const AttributeFormatFloatRGB9E5: Self = Self(55);
    /// Metal value `MTL::AttributeFormat::AttributeFormatHalf`.
    pub const AttributeFormatHalf: Self = Self(53);
    /// Metal value `MTL::AttributeFormat::AttributeFormatHalf2`.
    pub const AttributeFormatHalf2: Self = Self(25);
    /// Metal value `MTL::AttributeFormat::AttributeFormatHalf3`.
    pub const AttributeFormatHalf3: Self = Self(26);
    /// Metal value `MTL::AttributeFormat::AttributeFormatHalf4`.
    pub const AttributeFormatHalf4: Self = Self(27);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInt`.
    pub const AttributeFormatInt: Self = Self(32);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInt1010102Normalized`.
    pub const AttributeFormatInt1010102Normalized: Self = Self(40);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInt2`.
    pub const AttributeFormatInt2: Self = Self(33);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInt3`.
    pub const AttributeFormatInt3: Self = Self(34);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInt4`.
    pub const AttributeFormatInt4: Self = Self(35);
    /// Metal value `MTL::AttributeFormat::AttributeFormatInvalid`.
    pub const AttributeFormatInvalid: Self = Self(0);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort`.
    pub const AttributeFormatShort: Self = Self(50);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort2`.
    pub const AttributeFormatShort2: Self = Self(16);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort2Normalized`.
    pub const AttributeFormatShort2Normalized: Self = Self(22);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort3`.
    pub const AttributeFormatShort3: Self = Self(17);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort3Normalized`.
    pub const AttributeFormatShort3Normalized: Self = Self(23);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort4`.
    pub const AttributeFormatShort4: Self = Self(18);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShort4Normalized`.
    pub const AttributeFormatShort4Normalized: Self = Self(24);
    /// Metal value `MTL::AttributeFormat::AttributeFormatShortNormalized`.
    pub const AttributeFormatShortNormalized: Self = Self(52);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar`.
    pub const AttributeFormatUChar: Self = Self(45);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar2`.
    pub const AttributeFormatUChar2: Self = Self(1);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar2Normalized`.
    pub const AttributeFormatUChar2Normalized: Self = Self(7);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar3`.
    pub const AttributeFormatUChar3: Self = Self(2);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar3Normalized`.
    pub const AttributeFormatUChar3Normalized: Self = Self(8);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar4`.
    pub const AttributeFormatUChar4: Self = Self(3);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar4Normalized`.
    pub const AttributeFormatUChar4Normalized: Self = Self(9);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUChar4Normalized_BGRA`.
    pub const AttributeFormatUChar4Normalized_BGRA: Self = Self(42);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUCharNormalized`.
    pub const AttributeFormatUCharNormalized: Self = Self(47);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUInt`.
    pub const AttributeFormatUInt: Self = Self(36);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUInt1010102Normalized`.
    pub const AttributeFormatUInt1010102Normalized: Self = Self(41);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUInt2`.
    pub const AttributeFormatUInt2: Self = Self(37);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUInt3`.
    pub const AttributeFormatUInt3: Self = Self(38);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUInt4`.
    pub const AttributeFormatUInt4: Self = Self(39);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort`.
    pub const AttributeFormatUShort: Self = Self(49);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort2`.
    pub const AttributeFormatUShort2: Self = Self(13);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort2Normalized`.
    pub const AttributeFormatUShort2Normalized: Self = Self(19);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort3`.
    pub const AttributeFormatUShort3: Self = Self(14);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort3Normalized`.
    pub const AttributeFormatUShort3Normalized: Self = Self(20);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort4`.
    pub const AttributeFormatUShort4: Self = Self(15);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShort4Normalized`.
    pub const AttributeFormatUShort4Normalized: Self = Self(21);
    /// Metal value `MTL::AttributeFormat::AttributeFormatUShortNormalized`.
    pub const AttributeFormatUShortNormalized: Self = Self(51);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=42 | 45..=55)
    }
}

impl std::convert::TryFrom<usize> for AttributeFormat {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BarrierScope` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BarrierScope(usize);

impl BarrierScope {
    /// Metal value `MTL::BarrierScope::BarrierScopeBuffers`.
    pub const BarrierScopeBuffers: Self = Self(1);
    /// Metal value `MTL::BarrierScope::BarrierScopeRenderTargets`.
    pub const BarrierScopeRenderTargets: Self = Self(4);
    /// Metal value `MTL::BarrierScope::BarrierScopeTextures`.
    pub const BarrierScopeTextures: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 7;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for BarrierScope {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for BarrierScope {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::BinaryArchiveError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BinaryArchiveError(usize);

impl BinaryArchiveError {
    /// Metal value `MTL::BinaryArchiveError::BinaryArchiveErrorCompilationFailure`.
    pub const BinaryArchiveErrorCompilationFailure: Self = Self(3);
    /// Metal value `MTL::BinaryArchiveError::BinaryArchiveErrorInternalError`.
    pub const BinaryArchiveErrorInternalError: Self = Self(4);
    /// Metal value `MTL::BinaryArchiveError::BinaryArchiveErrorInvalidFile`.
    pub const BinaryArchiveErrorInvalidFile: Self = Self(1);
    /// Metal value `MTL::BinaryArchiveError::BinaryArchiveErrorNone`.
    pub const BinaryArchiveErrorNone: Self = Self(0);
    /// Metal value `MTL::BinaryArchiveError::BinaryArchiveErrorUnexpectedElement`.
    pub const BinaryArchiveErrorUnexpectedElement: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<usize> for BinaryArchiveError {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BindingAccess` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BindingAccess(usize);

impl BindingAccess {
    /// Metal value `MTL::BindingAccess::ArgumentAccessReadOnly`.
    pub const ArgumentAccessReadOnly: Self = Self(0);
    /// Metal value `MTL::BindingAccess::ArgumentAccessReadWrite`.
    pub const ArgumentAccessReadWrite: Self = Self(1);
    /// Metal value `MTL::BindingAccess::ArgumentAccessWriteOnly`.
    pub const ArgumentAccessWriteOnly: Self = Self(2);
    /// Metal value `MTL::BindingAccess::BindingAccessReadOnly`.
    pub const BindingAccessReadOnly: Self = Self(0);
    /// Metal value `MTL::BindingAccess::BindingAccessReadWrite`.
    pub const BindingAccessReadWrite: Self = Self(1);
    /// Metal value `MTL::BindingAccess::BindingAccessWriteOnly`.
    pub const BindingAccessWriteOnly: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for BindingAccess {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BindingType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BindingType(isize);

impl BindingType {
    /// Metal value `MTL::BindingType::BindingTypeBuffer`.
    pub const BindingTypeBuffer: Self = Self(0);
    /// Metal value `MTL::BindingType::BindingTypeImageblock`.
    pub const BindingTypeImageblock: Self = Self(17);
    /// Metal value `MTL::BindingType::BindingTypeImageblockData`.
    pub const BindingTypeImageblockData: Self = Self(16);
    /// Metal value `MTL::BindingType::BindingTypeInstanceAccelerationStructure`.
    pub const BindingTypeInstanceAccelerationStructure: Self = Self(26);
    /// Metal value `MTL::BindingType::BindingTypeIntersectionFunctionTable`.
    pub const BindingTypeIntersectionFunctionTable: Self = Self(27);
    /// Metal value `MTL::BindingType::BindingTypeObjectPayload`.
    pub const BindingTypeObjectPayload: Self = Self(34);
    /// Metal value `MTL::BindingType::BindingTypePrimitiveAccelerationStructure`.
    pub const BindingTypePrimitiveAccelerationStructure: Self = Self(25);
    /// Metal value `MTL::BindingType::BindingTypeSampler`.
    pub const BindingTypeSampler: Self = Self(3);
    /// Metal value `MTL::BindingType::BindingTypeTensor`.
    pub const BindingTypeTensor: Self = Self(37);
    /// Metal value `MTL::BindingType::BindingTypeTexture`.
    pub const BindingTypeTexture: Self = Self(2);
    /// Metal value `MTL::BindingType::BindingTypeThreadgroupMemory`.
    pub const BindingTypeThreadgroupMemory: Self = Self(1);
    /// Metal value `MTL::BindingType::BindingTypeVisibleFunctionTable`.
    pub const BindingTypeVisibleFunctionTable: Self = Self(24);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3 | 16 | 17 | 24..=27 | 34 | 37)
    }
}

impl std::convert::TryFrom<isize> for BindingType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BlendFactor` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BlendFactor(usize);

impl BlendFactor {
    /// Metal value `MTL::BlendFactor::BlendFactorBlendAlpha`.
    pub const BlendFactorBlendAlpha: Self = Self(13);
    /// Metal value `MTL::BlendFactor::BlendFactorBlendColor`.
    pub const BlendFactorBlendColor: Self = Self(11);
    /// Metal value `MTL::BlendFactor::BlendFactorDestinationAlpha`.
    pub const BlendFactorDestinationAlpha: Self = Self(8);
    /// Metal value `MTL::BlendFactor::BlendFactorDestinationColor`.
    pub const BlendFactorDestinationColor: Self = Self(6);
    /// Metal value `MTL::BlendFactor::BlendFactorOne`.
    pub const BlendFactorOne: Self = Self(1);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusBlendAlpha`.
    pub const BlendFactorOneMinusBlendAlpha: Self = Self(14);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusBlendColor`.
    pub const BlendFactorOneMinusBlendColor: Self = Self(12);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusDestinationAlpha`.
    pub const BlendFactorOneMinusDestinationAlpha: Self = Self(9);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusDestinationColor`.
    pub const BlendFactorOneMinusDestinationColor: Self = Self(7);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusSource1Alpha`.
    pub const BlendFactorOneMinusSource1Alpha: Self = Self(18);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusSource1Color`.
    pub const BlendFactorOneMinusSource1Color: Self = Self(16);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusSourceAlpha`.
    pub const BlendFactorOneMinusSourceAlpha: Self = Self(5);
    /// Metal value `MTL::BlendFactor::BlendFactorOneMinusSourceColor`.
    pub const BlendFactorOneMinusSourceColor: Self = Self(3);
    /// Metal value `MTL::BlendFactor::BlendFactorSource1Alpha`.
    pub const BlendFactorSource1Alpha: Self = Self(17);
    /// Metal value `MTL::BlendFactor::BlendFactorSource1Color`.
    pub const BlendFactorSource1Color: Self = Self(15);
    /// Metal value `MTL::BlendFactor::BlendFactorSourceAlpha`.
    pub const BlendFactorSourceAlpha: Self = Self(4);
    /// Metal value `MTL::BlendFactor::BlendFactorSourceAlphaSaturated`.
    pub const BlendFactorSourceAlphaSaturated: Self = Self(10);
    /// Metal value `MTL::BlendFactor::BlendFactorSourceColor`.
    pub const BlendFactorSourceColor: Self = Self(2);
    /// Metal value `MTL::BlendFactor::BlendFactorUnspecialized`.
    pub const BlendFactorUnspecialized: Self = Self(19);
    /// Metal value `MTL::BlendFactor::BlendFactorZero`.
    pub const BlendFactorZero: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=19)
    }
}

impl std::convert::TryFrom<usize> for BlendFactor {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BlendOperation` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BlendOperation(usize);

impl BlendOperation {
    /// Metal value `MTL::BlendOperation::BlendOperationAdd`.
    pub const BlendOperationAdd: Self = Self(0);
    /// Metal value `MTL::BlendOperation::BlendOperationMax`.
    pub const BlendOperationMax: Self = Self(4);
    /// Metal value `MTL::BlendOperation::BlendOperationMin`.
    pub const BlendOperationMin: Self = Self(3);
    /// Metal value `MTL::BlendOperation::BlendOperationReverseSubtract`.
    pub const BlendOperationReverseSubtract: Self = Self(2);
    /// Metal value `MTL::BlendOperation::BlendOperationSubtract`.
    pub const BlendOperationSubtract: Self = Self(1);
    /// Metal value `MTL::BlendOperation::BlendOperationUnspecialized`.
    pub const BlendOperationUnspecialized: Self = Self(5);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<usize> for BlendOperation {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::BlitOption` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BlitOption(usize);

impl BlitOption {
    /// Metal value `MTL::BlitOption::BlitOptionDepthFromDepthStencil`.
    pub const BlitOptionDepthFromDepthStencil: Self = Self(1);
    /// Metal value `MTL::BlitOption::BlitOptionNone`.
    pub const BlitOptionNone: Self = Self(0);
    /// Metal value `MTL::BlitOption::BlitOptionRowLinearPVRTC`.
    pub const BlitOptionRowLinearPVRTC: Self = Self(4);
    /// Metal value `MTL::BlitOption::BlitOptionStencilFromDepthStencil`.
    pub const BlitOptionStencilFromDepthStencil: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 7;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for BlitOption {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for BlitOption {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::BufferSparseTier` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct BufferSparseTier(isize);

impl BufferSparseTier {
    /// Metal value `MTL::BufferSparseTier::BufferSparseTier1`.
    pub const BufferSparseTier1: Self = Self(1);
    /// Metal value `MTL::BufferSparseTier::BufferSparseTierNone`.
    pub const BufferSparseTierNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for BufferSparseTier {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CPUCacheMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CPUCacheMode(usize);

impl CPUCacheMode {
    /// Metal value `MTL::CPUCacheMode::CPUCacheModeDefaultCache`.
    pub const CPUCacheModeDefaultCache: Self = Self(0);
    /// Metal value `MTL::CPUCacheMode::CPUCacheModeWriteCombined`.
    pub const CPUCacheModeWriteCombined: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for CPUCacheMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CaptureDestination` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CaptureDestination(isize);

impl CaptureDestination {
    /// Metal value `MTL::CaptureDestination::CaptureDestinationDeveloperTools`.
    pub const CaptureDestinationDeveloperTools: Self = Self(1);
    /// Metal value `MTL::CaptureDestination::CaptureDestinationGPUTraceDocument`.
    pub const CaptureDestinationGPUTraceDocument: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1 | 2)
    }
}

impl std::convert::TryFrom<isize> for CaptureDestination {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CaptureError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CaptureError(isize);

impl CaptureError {
    /// Metal value `MTL::CaptureError::CaptureErrorAlreadyCapturing`.
    pub const CaptureErrorAlreadyCapturing: Self = Self(2);
    /// Metal value `MTL::CaptureError::CaptureErrorInvalidDescriptor`.
    pub const CaptureErrorInvalidDescriptor: Self = Self(3);
    /// Metal value `MTL::CaptureError::CaptureErrorNotSupported`.
    pub const CaptureErrorNotSupported: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1..=3)
    }
}

impl std::convert::TryFrom<isize> for CaptureError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::ColorWriteMask` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ColorWriteMask(usize);

impl ColorWriteMask {
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskAll`.
    pub const ColorWriteMaskAll: Self = Self(15);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskAlpha`.
    pub const ColorWriteMaskAlpha: Self = Self(1);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskBlue`.
    pub const ColorWriteMaskBlue: Self = Self(2);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskGreen`.
    pub const ColorWriteMaskGreen: Self = Self(4);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskNone`.
    pub const ColorWriteMaskNone: Self = Self(0);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskRed`.
    pub const ColorWriteMaskRed: Self = Self(8);
    /// Metal value `MTL::ColorWriteMask::ColorWriteMaskUnspecialized`.
    pub const ColorWriteMaskUnspecialized: Self = Self(16);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 31;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for ColorWriteMask {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for ColorWriteMask {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::CommandBufferError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CommandBufferError(usize);

impl CommandBufferError {
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorAccessRevoked`.
    pub const CommandBufferErrorAccessRevoked: Self = Self(4);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorBlacklisted`.
    pub const CommandBufferErrorBlacklisted: Self = Self(4);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorDeviceRemoved`.
    pub const CommandBufferErrorDeviceRemoved: Self = Self(11);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorInternal`.
    pub const CommandBufferErrorInternal: Self = Self(1);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorInvalidResource`.
    pub const CommandBufferErrorInvalidResource: Self = Self(9);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorMemoryless`.
    pub const CommandBufferErrorMemoryless: Self = Self(10);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorNone`.
    pub const CommandBufferErrorNone: Self = Self(0);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorNotPermitted`.
    pub const CommandBufferErrorNotPermitted: Self = Self(7);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorOutOfMemory`.
    pub const CommandBufferErrorOutOfMemory: Self = Self(8);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorPageFault`.
    pub const CommandBufferErrorPageFault: Self = Self(3);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorStackOverflow`.
    pub const CommandBufferErrorStackOverflow: Self = Self(12);
    /// Metal value `MTL::CommandBufferError::CommandBufferErrorTimeout`.
    pub const CommandBufferErrorTimeout: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4 | 7..=12)
    }
}

impl std::convert::TryFrom<usize> for CommandBufferError {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CommandBufferErrorOption` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CommandBufferErrorOption(usize);

impl CommandBufferErrorOption {
    /// Metal value `MTL::CommandBufferErrorOption::CommandBufferErrorOptionEncoderExecutionStatus`.
    pub const CommandBufferErrorOptionEncoderExecutionStatus: Self = Self(1);
    /// Metal value `MTL::CommandBufferErrorOption::CommandBufferErrorOptionNone`.
    pub const CommandBufferErrorOptionNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 1;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for CommandBufferErrorOption {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for CommandBufferErrorOption {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::CommandEncoderErrorState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CommandEncoderErrorState(isize);

impl CommandEncoderErrorState {
    /// Metal value `MTL::CommandEncoderErrorState::CommandEncoderErrorStateAffected`.
    pub const CommandEncoderErrorStateAffected: Self = Self(2);
    /// Metal value `MTL::CommandEncoderErrorState::CommandEncoderErrorStateCompleted`.
    pub const CommandEncoderErrorStateCompleted: Self = Self(1);
    /// Metal value `MTL::CommandEncoderErrorState::CommandEncoderErrorStateFaulted`.
    pub const CommandEncoderErrorStateFaulted: Self = Self(4);
    /// Metal value `MTL::CommandEncoderErrorState::CommandEncoderErrorStatePending`.
    pub const CommandEncoderErrorStatePending: Self = Self(3);
    /// Metal value `MTL::CommandEncoderErrorState::CommandEncoderErrorStateUnknown`.
    pub const CommandEncoderErrorStateUnknown: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<isize> for CommandEncoderErrorState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CompareFunction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CompareFunction(usize);

impl CompareFunction {
    /// Metal value `MTL::CompareFunction::CompareFunctionAlways`.
    pub const CompareFunctionAlways: Self = Self(7);
    /// Metal value `MTL::CompareFunction::CompareFunctionEqual`.
    pub const CompareFunctionEqual: Self = Self(2);
    /// Metal value `MTL::CompareFunction::CompareFunctionGreater`.
    pub const CompareFunctionGreater: Self = Self(4);
    /// Metal value `MTL::CompareFunction::CompareFunctionGreaterEqual`.
    pub const CompareFunctionGreaterEqual: Self = Self(6);
    /// Metal value `MTL::CompareFunction::CompareFunctionLess`.
    pub const CompareFunctionLess: Self = Self(1);
    /// Metal value `MTL::CompareFunction::CompareFunctionLessEqual`.
    pub const CompareFunctionLessEqual: Self = Self(3);
    /// Metal value `MTL::CompareFunction::CompareFunctionNever`.
    pub const CompareFunctionNever: Self = Self(0);
    /// Metal value `MTL::CompareFunction::CompareFunctionNotEqual`.
    pub const CompareFunctionNotEqual: Self = Self(5);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=7)
    }
}

impl std::convert::TryFrom<usize> for CompareFunction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CompileSymbolVisibility` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CompileSymbolVisibility(isize);

impl CompileSymbolVisibility {
    /// Metal value `MTL::CompileSymbolVisibility::CompileSymbolVisibilityDefault`.
    pub const CompileSymbolVisibilityDefault: Self = Self(0);
    /// Metal value `MTL::CompileSymbolVisibility::CompileSymbolVisibilityHidden`.
    pub const CompileSymbolVisibilityHidden: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for CompileSymbolVisibility {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CounterSampleBufferError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CounterSampleBufferError(isize);

impl CounterSampleBufferError {
    /// Metal value `MTL::CounterSampleBufferError::CounterSampleBufferErrorInternal`.
    pub const CounterSampleBufferErrorInternal: Self = Self(2);
    /// Metal value `MTL::CounterSampleBufferError::CounterSampleBufferErrorInvalid`.
    pub const CounterSampleBufferErrorInvalid: Self = Self(1);
    /// Metal value `MTL::CounterSampleBufferError::CounterSampleBufferErrorOutOfMemory`.
    pub const CounterSampleBufferErrorOutOfMemory: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for CounterSampleBufferError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CounterSamplingPoint` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CounterSamplingPoint(usize);

impl CounterSamplingPoint {
    /// Metal value `MTL::CounterSamplingPoint::CounterSamplingPointAtBlitBoundary`.
    pub const CounterSamplingPointAtBlitBoundary: Self = Self(4);
    /// Metal value `MTL::CounterSamplingPoint::CounterSamplingPointAtDispatchBoundary`.
    pub const CounterSamplingPointAtDispatchBoundary: Self = Self(2);
    /// Metal value `MTL::CounterSamplingPoint::CounterSamplingPointAtDrawBoundary`.
    pub const CounterSamplingPointAtDrawBoundary: Self = Self(1);
    /// Metal value `MTL::CounterSamplingPoint::CounterSamplingPointAtStageBoundary`.
    pub const CounterSamplingPointAtStageBoundary: Self = Self(0);
    /// Metal value `MTL::CounterSamplingPoint::CounterSamplingPointAtTileDispatchBoundary`.
    pub const CounterSamplingPointAtTileDispatchBoundary: Self = Self(3);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<usize> for CounterSamplingPoint {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CullMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CullMode(usize);

impl CullMode {
    /// Metal value `MTL::CullMode::CullModeBack`.
    pub const CullModeBack: Self = Self(2);
    /// Metal value `MTL::CullMode::CullModeFront`.
    pub const CullModeFront: Self = Self(1);
    /// Metal value `MTL::CullMode::CullModeNone`.
    pub const CullModeNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for CullMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CurveBasis` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CurveBasis(isize);

impl CurveBasis {
    /// Metal value `MTL::CurveBasis::CurveBasisBSpline`.
    pub const CurveBasisBSpline: Self = Self(0);
    /// Metal value `MTL::CurveBasis::CurveBasisBezier`.
    pub const CurveBasisBezier: Self = Self(3);
    /// Metal value `MTL::CurveBasis::CurveBasisCatmullRom`.
    pub const CurveBasisCatmullRom: Self = Self(1);
    /// Metal value `MTL::CurveBasis::CurveBasisLinear`.
    pub const CurveBasisLinear: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<isize> for CurveBasis {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CurveEndCaps` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CurveEndCaps(isize);

impl CurveEndCaps {
    /// Metal value `MTL::CurveEndCaps::CurveEndCapsDisk`.
    pub const CurveEndCapsDisk: Self = Self(1);
    /// Metal value `MTL::CurveEndCaps::CurveEndCapsNone`.
    pub const CurveEndCapsNone: Self = Self(0);
    /// Metal value `MTL::CurveEndCaps::CurveEndCapsSphere`.
    pub const CurveEndCapsSphere: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for CurveEndCaps {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::CurveType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct CurveType(isize);

impl CurveType {
    /// Metal value `MTL::CurveType::CurveTypeFlat`.
    pub const CurveTypeFlat: Self = Self(1);
    /// Metal value `MTL::CurveType::CurveTypeRound`.
    pub const CurveTypeRound: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for CurveType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DataType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DataType(usize);

impl DataType {
    /// Metal value `MTL::DataType::DataTypeArray`.
    pub const DataTypeArray: Self = Self(2);
    /// Metal value `MTL::DataType::DataTypeBFloat`.
    pub const DataTypeBFloat: Self = Self(121);
    /// Metal value `MTL::DataType::DataTypeBFloat2`.
    pub const DataTypeBFloat2: Self = Self(122);
    /// Metal value `MTL::DataType::DataTypeBFloat3`.
    pub const DataTypeBFloat3: Self = Self(123);
    /// Metal value `MTL::DataType::DataTypeBFloat4`.
    pub const DataTypeBFloat4: Self = Self(124);
    /// Metal value `MTL::DataType::DataTypeBool`.
    pub const DataTypeBool: Self = Self(53);
    /// Metal value `MTL::DataType::DataTypeBool2`.
    pub const DataTypeBool2: Self = Self(54);
    /// Metal value `MTL::DataType::DataTypeBool3`.
    pub const DataTypeBool3: Self = Self(55);
    /// Metal value `MTL::DataType::DataTypeBool4`.
    pub const DataTypeBool4: Self = Self(56);
    /// Metal value `MTL::DataType::DataTypeChar`.
    pub const DataTypeChar: Self = Self(45);
    /// Metal value `MTL::DataType::DataTypeChar2`.
    pub const DataTypeChar2: Self = Self(46);
    /// Metal value `MTL::DataType::DataTypeChar3`.
    pub const DataTypeChar3: Self = Self(47);
    /// Metal value `MTL::DataType::DataTypeChar4`.
    pub const DataTypeChar4: Self = Self(48);
    /// Metal value `MTL::DataType::DataTypeComputePipeline`.
    pub const DataTypeComputePipeline: Self = Self(79);
    /// Metal value `MTL::DataType::DataTypeDepthStencilState`.
    pub const DataTypeDepthStencilState: Self = Self(139);
    /// Metal value `MTL::DataType::DataTypeFloat`.
    pub const DataTypeFloat: Self = Self(3);
    /// Metal value `MTL::DataType::DataTypeFloat2`.
    pub const DataTypeFloat2: Self = Self(4);
    /// Metal value `MTL::DataType::DataTypeFloat2x2`.
    pub const DataTypeFloat2x2: Self = Self(7);
    /// Metal value `MTL::DataType::DataTypeFloat2x3`.
    pub const DataTypeFloat2x3: Self = Self(8);
    /// Metal value `MTL::DataType::DataTypeFloat2x4`.
    pub const DataTypeFloat2x4: Self = Self(9);
    /// Metal value `MTL::DataType::DataTypeFloat3`.
    pub const DataTypeFloat3: Self = Self(5);
    /// Metal value `MTL::DataType::DataTypeFloat3x2`.
    pub const DataTypeFloat3x2: Self = Self(10);
    /// Metal value `MTL::DataType::DataTypeFloat3x3`.
    pub const DataTypeFloat3x3: Self = Self(11);
    /// Metal value `MTL::DataType::DataTypeFloat3x4`.
    pub const DataTypeFloat3x4: Self = Self(12);
    /// Metal value `MTL::DataType::DataTypeFloat4`.
    pub const DataTypeFloat4: Self = Self(6);
    /// Metal value `MTL::DataType::DataTypeFloat4x2`.
    pub const DataTypeFloat4x2: Self = Self(13);
    /// Metal value `MTL::DataType::DataTypeFloat4x3`.
    pub const DataTypeFloat4x3: Self = Self(14);
    /// Metal value `MTL::DataType::DataTypeFloat4x4`.
    pub const DataTypeFloat4x4: Self = Self(15);
    /// Metal value `MTL::DataType::DataTypeHalf`.
    pub const DataTypeHalf: Self = Self(16);
    /// Metal value `MTL::DataType::DataTypeHalf2`.
    pub const DataTypeHalf2: Self = Self(17);
    /// Metal value `MTL::DataType::DataTypeHalf2x2`.
    pub const DataTypeHalf2x2: Self = Self(20);
    /// Metal value `MTL::DataType::DataTypeHalf2x3`.
    pub const DataTypeHalf2x3: Self = Self(21);
    /// Metal value `MTL::DataType::DataTypeHalf2x4`.
    pub const DataTypeHalf2x4: Self = Self(22);
    /// Metal value `MTL::DataType::DataTypeHalf3`.
    pub const DataTypeHalf3: Self = Self(18);
    /// Metal value `MTL::DataType::DataTypeHalf3x2`.
    pub const DataTypeHalf3x2: Self = Self(23);
    /// Metal value `MTL::DataType::DataTypeHalf3x3`.
    pub const DataTypeHalf3x3: Self = Self(24);
    /// Metal value `MTL::DataType::DataTypeHalf3x4`.
    pub const DataTypeHalf3x4: Self = Self(25);
    /// Metal value `MTL::DataType::DataTypeHalf4`.
    pub const DataTypeHalf4: Self = Self(19);
    /// Metal value `MTL::DataType::DataTypeHalf4x2`.
    pub const DataTypeHalf4x2: Self = Self(26);
    /// Metal value `MTL::DataType::DataTypeHalf4x3`.
    pub const DataTypeHalf4x3: Self = Self(27);
    /// Metal value `MTL::DataType::DataTypeHalf4x4`.
    pub const DataTypeHalf4x4: Self = Self(28);
    /// Metal value `MTL::DataType::DataTypeIndirectCommandBuffer`.
    pub const DataTypeIndirectCommandBuffer: Self = Self(80);
    /// Metal value `MTL::DataType::DataTypeInstanceAccelerationStructure`.
    pub const DataTypeInstanceAccelerationStructure: Self = Self(118);
    /// Metal value `MTL::DataType::DataTypeInt`.
    pub const DataTypeInt: Self = Self(29);
    /// Metal value `MTL::DataType::DataTypeInt2`.
    pub const DataTypeInt2: Self = Self(30);
    /// Metal value `MTL::DataType::DataTypeInt3`.
    pub const DataTypeInt3: Self = Self(31);
    /// Metal value `MTL::DataType::DataTypeInt4`.
    pub const DataTypeInt4: Self = Self(32);
    /// Metal value `MTL::DataType::DataTypeIntersectionFunctionTable`.
    pub const DataTypeIntersectionFunctionTable: Self = Self(116);
    /// Metal value `MTL::DataType::DataTypeLong`.
    pub const DataTypeLong: Self = Self(81);
    /// Metal value `MTL::DataType::DataTypeLong2`.
    pub const DataTypeLong2: Self = Self(82);
    /// Metal value `MTL::DataType::DataTypeLong3`.
    pub const DataTypeLong3: Self = Self(83);
    /// Metal value `MTL::DataType::DataTypeLong4`.
    pub const DataTypeLong4: Self = Self(84);
    /// Metal value `MTL::DataType::DataTypeNone`.
    pub const DataTypeNone: Self = Self(0);
    /// Metal value `MTL::DataType::DataTypePointer`.
    pub const DataTypePointer: Self = Self(60);
    /// Metal value `MTL::DataType::DataTypePrimitiveAccelerationStructure`.
    pub const DataTypePrimitiveAccelerationStructure: Self = Self(117);
    /// Metal value `MTL::DataType::DataTypeR16Snorm`.
    pub const DataTypeR16Snorm: Self = Self(65);
    /// Metal value `MTL::DataType::DataTypeR16Unorm`.
    pub const DataTypeR16Unorm: Self = Self(64);
    /// Metal value `MTL::DataType::DataTypeR8Snorm`.
    pub const DataTypeR8Snorm: Self = Self(63);
    /// Metal value `MTL::DataType::DataTypeR8Unorm`.
    pub const DataTypeR8Unorm: Self = Self(62);
    /// Metal value `MTL::DataType::DataTypeRG11B10Float`.
    pub const DataTypeRG11B10Float: Self = Self(76);
    /// Metal value `MTL::DataType::DataTypeRG16Snorm`.
    pub const DataTypeRG16Snorm: Self = Self(69);
    /// Metal value `MTL::DataType::DataTypeRG16Unorm`.
    pub const DataTypeRG16Unorm: Self = Self(68);
    /// Metal value `MTL::DataType::DataTypeRG8Snorm`.
    pub const DataTypeRG8Snorm: Self = Self(67);
    /// Metal value `MTL::DataType::DataTypeRG8Unorm`.
    pub const DataTypeRG8Unorm: Self = Self(66);
    /// Metal value `MTL::DataType::DataTypeRGB10A2Unorm`.
    pub const DataTypeRGB10A2Unorm: Self = Self(75);
    /// Metal value `MTL::DataType::DataTypeRGB9E5Float`.
    pub const DataTypeRGB9E5Float: Self = Self(77);
    /// Metal value `MTL::DataType::DataTypeRGBA16Snorm`.
    pub const DataTypeRGBA16Snorm: Self = Self(74);
    /// Metal value `MTL::DataType::DataTypeRGBA16Unorm`.
    pub const DataTypeRGBA16Unorm: Self = Self(73);
    /// Metal value `MTL::DataType::DataTypeRGBA8Snorm`.
    pub const DataTypeRGBA8Snorm: Self = Self(72);
    /// Metal value `MTL::DataType::DataTypeRGBA8Unorm`.
    pub const DataTypeRGBA8Unorm: Self = Self(70);
    /// Metal value `MTL::DataType::DataTypeRGBA8Unorm_sRGB`.
    pub const DataTypeRGBA8Unorm_sRGB: Self = Self(71);
    /// Metal value `MTL::DataType::DataTypeRenderPipeline`.
    pub const DataTypeRenderPipeline: Self = Self(78);
    /// Metal value `MTL::DataType::DataTypeSampler`.
    pub const DataTypeSampler: Self = Self(59);
    /// Metal value `MTL::DataType::DataTypeShort`.
    pub const DataTypeShort: Self = Self(37);
    /// Metal value `MTL::DataType::DataTypeShort2`.
    pub const DataTypeShort2: Self = Self(38);
    /// Metal value `MTL::DataType::DataTypeShort3`.
    pub const DataTypeShort3: Self = Self(39);
    /// Metal value `MTL::DataType::DataTypeShort4`.
    pub const DataTypeShort4: Self = Self(40);
    /// Metal value `MTL::DataType::DataTypeStruct`.
    pub const DataTypeStruct: Self = Self(1);
    /// Metal value `MTL::DataType::DataTypeTensor`.
    pub const DataTypeTensor: Self = Self(140);
    /// Metal value `MTL::DataType::DataTypeTexture`.
    pub const DataTypeTexture: Self = Self(58);
    /// Metal value `MTL::DataType::DataTypeUChar`.
    pub const DataTypeUChar: Self = Self(49);
    /// Metal value `MTL::DataType::DataTypeUChar2`.
    pub const DataTypeUChar2: Self = Self(50);
    /// Metal value `MTL::DataType::DataTypeUChar3`.
    pub const DataTypeUChar3: Self = Self(51);
    /// Metal value `MTL::DataType::DataTypeUChar4`.
    pub const DataTypeUChar4: Self = Self(52);
    /// Metal value `MTL::DataType::DataTypeUInt`.
    pub const DataTypeUInt: Self = Self(33);
    /// Metal value `MTL::DataType::DataTypeUInt2`.
    pub const DataTypeUInt2: Self = Self(34);
    /// Metal value `MTL::DataType::DataTypeUInt3`.
    pub const DataTypeUInt3: Self = Self(35);
    /// Metal value `MTL::DataType::DataTypeUInt4`.
    pub const DataTypeUInt4: Self = Self(36);
    /// Metal value `MTL::DataType::DataTypeULong`.
    pub const DataTypeULong: Self = Self(85);
    /// Metal value `MTL::DataType::DataTypeULong2`.
    pub const DataTypeULong2: Self = Self(86);
    /// Metal value `MTL::DataType::DataTypeULong3`.
    pub const DataTypeULong3: Self = Self(87);
    /// Metal value `MTL::DataType::DataTypeULong4`.
    pub const DataTypeULong4: Self = Self(88);
    /// Metal value `MTL::DataType::DataTypeUShort`.
    pub const DataTypeUShort: Self = Self(41);
    /// Metal value `MTL::DataType::DataTypeUShort2`.
    pub const DataTypeUShort2: Self = Self(42);
    /// Metal value `MTL::DataType::DataTypeUShort3`.
    pub const DataTypeUShort3: Self = Self(43);
    /// Metal value `MTL::DataType::DataTypeUShort4`.
    pub const DataTypeUShort4: Self = Self(44);
    /// Metal value `MTL::DataType::DataTypeVisibleFunctionTable`.
    pub const DataTypeVisibleFunctionTable: Self = Self(115);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=56 | 58..=60 | 62..=88 | 115..=118 | 121..=124 | 139 | 140)
    }
}

impl std::convert::TryFrom<usize> for DataType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DepthClipMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DepthClipMode(usize);

impl DepthClipMode {
    /// Metal value `MTL::DepthClipMode::DepthClipModeClamp`.
    pub const DepthClipModeClamp: Self = Self(1);
    /// Metal value `MTL::DepthClipMode::DepthClipModeClip`.
    pub const DepthClipModeClip: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for DepthClipMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DeviceError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DeviceError(isize);

impl DeviceError {
    /// Metal value `MTL::DeviceError::DeviceErrorNone`.
    pub const DeviceErrorNone: Self = Self(0);
    /// Metal value `MTL::DeviceError::DeviceErrorNotSupported`.
    pub const DeviceErrorNotSupported: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for DeviceError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DeviceLocation` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DeviceLocation(usize);

impl DeviceLocation {
    /// Metal value `MTL::DeviceLocation::DeviceLocationBuiltIn`.
    pub const DeviceLocationBuiltIn: Self = Self(0);
    /// Metal value `MTL::DeviceLocation::DeviceLocationExternal`.
    pub const DeviceLocationExternal: Self = Self(2);
    /// Metal value `MTL::DeviceLocation::DeviceLocationSlot`.
    pub const DeviceLocationSlot: Self = Self(1);
    /// Metal value `MTL::DeviceLocation::DeviceLocationUnspecified`.
    pub const DeviceLocationUnspecified: Self = Self(usize::MAX);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2 | 18446744073709551615)
    }
}

impl std::convert::TryFrom<usize> for DeviceLocation {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DispatchType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DispatchType(usize);

impl DispatchType {
    /// Metal value `MTL::DispatchType::DispatchTypeConcurrent`.
    pub const DispatchTypeConcurrent: Self = Self(1);
    /// Metal value `MTL::DispatchType::DispatchTypeSerial`.
    pub const DispatchTypeSerial: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for DispatchType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::DynamicLibraryError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct DynamicLibraryError(usize);

impl DynamicLibraryError {
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorCompilationFailure`.
    pub const DynamicLibraryErrorCompilationFailure: Self = Self(2);
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorDependencyLoadFailure`.
    pub const DynamicLibraryErrorDependencyLoadFailure: Self = Self(4);
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorInvalidFile`.
    pub const DynamicLibraryErrorInvalidFile: Self = Self(1);
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorNone`.
    pub const DynamicLibraryErrorNone: Self = Self(0);
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorUnresolvedInstallName`.
    pub const DynamicLibraryErrorUnresolvedInstallName: Self = Self(3);
    /// Metal value `MTL::DynamicLibraryError::DynamicLibraryErrorUnsupported`.
    pub const DynamicLibraryErrorUnsupported: Self = Self(5);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<usize> for DynamicLibraryError {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::FeatureSet` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct FeatureSet(usize);

impl FeatureSet {
    /// Metal value `MTL::FeatureSet::FeatureSet_OSX_GPUFamily1_v1`.
    pub const FeatureSet_OSX_GPUFamily1_v1: Self = Self(10000);
    /// Metal value `MTL::FeatureSet::FeatureSet_OSX_GPUFamily1_v2`.
    pub const FeatureSet_OSX_GPUFamily1_v2: Self = Self(10001);
    /// Metal value `MTL::FeatureSet::FeatureSet_OSX_ReadWriteTextureTier2`.
    pub const FeatureSet_OSX_ReadWriteTextureTier2: Self = Self(10002);
    /// Metal value `MTL::FeatureSet::FeatureSet_TVOS_GPUFamily1_v1`.
    pub const FeatureSet_TVOS_GPUFamily1_v1: Self = Self(30000);
    /// Metal value `MTL::FeatureSet::FeatureSet_WatchOS_GPUFamily1_v1`.
    pub const FeatureSet_WatchOS_GPUFamily1_v1: Self = Self(20000);
    /// Metal value `MTL::FeatureSet::FeatureSet_WatchOS_GPUFamily2_v1`.
    pub const FeatureSet_WatchOS_GPUFamily2_v1: Self = Self(20001);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily1_v1`.
    pub const FeatureSet_iOS_GPUFamily1_v1: Self = Self(0);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily1_v2`.
    pub const FeatureSet_iOS_GPUFamily1_v2: Self = Self(2);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily1_v3`.
    pub const FeatureSet_iOS_GPUFamily1_v3: Self = Self(5);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily1_v4`.
    pub const FeatureSet_iOS_GPUFamily1_v4: Self = Self(8);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily1_v5`.
    pub const FeatureSet_iOS_GPUFamily1_v5: Self = Self(12);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily2_v1`.
    pub const FeatureSet_iOS_GPUFamily2_v1: Self = Self(1);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily2_v2`.
    pub const FeatureSet_iOS_GPUFamily2_v2: Self = Self(3);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily2_v3`.
    pub const FeatureSet_iOS_GPUFamily2_v3: Self = Self(6);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily2_v4`.
    pub const FeatureSet_iOS_GPUFamily2_v4: Self = Self(9);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily2_v5`.
    pub const FeatureSet_iOS_GPUFamily2_v5: Self = Self(13);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily3_v1`.
    pub const FeatureSet_iOS_GPUFamily3_v1: Self = Self(4);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily3_v2`.
    pub const FeatureSet_iOS_GPUFamily3_v2: Self = Self(7);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily3_v3`.
    pub const FeatureSet_iOS_GPUFamily3_v3: Self = Self(10);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily3_v4`.
    pub const FeatureSet_iOS_GPUFamily3_v4: Self = Self(14);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily4_v1`.
    pub const FeatureSet_iOS_GPUFamily4_v1: Self = Self(11);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily4_v2`.
    pub const FeatureSet_iOS_GPUFamily4_v2: Self = Self(15);
    /// Metal value `MTL::FeatureSet::FeatureSet_iOS_GPUFamily5_v1`.
    pub const FeatureSet_iOS_GPUFamily5_v1: Self = Self(16);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_GPUFamily1_v1`.
    pub const FeatureSet_macOS_GPUFamily1_v1: Self = Self(10000);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_GPUFamily1_v2`.
    pub const FeatureSet_macOS_GPUFamily1_v2: Self = Self(10001);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_GPUFamily1_v3`.
    pub const FeatureSet_macOS_GPUFamily1_v3: Self = Self(10003);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_GPUFamily1_v4`.
    pub const FeatureSet_macOS_GPUFamily1_v4: Self = Self(10004);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_GPUFamily2_v1`.
    pub const FeatureSet_macOS_GPUFamily2_v1: Self = Self(10005);
    /// Metal value `MTL::FeatureSet::FeatureSet_macOS_ReadWriteTextureTier2`.
    pub const FeatureSet_macOS_ReadWriteTextureTier2: Self = Self(10002);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily1_v1`.
    pub const FeatureSet_tvOS_GPUFamily1_v1: Self = Self(30000);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily1_v2`.
    pub const FeatureSet_tvOS_GPUFamily1_v2: Self = Self(30001);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily1_v3`.
    pub const FeatureSet_tvOS_GPUFamily1_v3: Self = Self(30002);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily1_v4`.
    pub const FeatureSet_tvOS_GPUFamily1_v4: Self = Self(30004);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily2_v1`.
    pub const FeatureSet_tvOS_GPUFamily2_v1: Self = Self(30003);
    /// Metal value `MTL::FeatureSet::FeatureSet_tvOS_GPUFamily2_v2`.
    pub const FeatureSet_tvOS_GPUFamily2_v2: Self = Self(30005);
    /// Metal value `MTL::FeatureSet::FeatureSet_watchOS_GPUFamily1_v1`.
    pub const FeatureSet_watchOS_GPUFamily1_v1: Self = Self(20000);
    /// Metal value `MTL::FeatureSet::FeatureSet_watchOS_GPUFamily2_v1`.
    pub const FeatureSet_watchOS_GPUFamily2_v1: Self = Self(20001);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=16 | 10000..=10005 | 20000 | 20001 | 30000..=30005)
    }
}

impl std::convert::TryFrom<usize> for FeatureSet {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::FloatingPointConversionRoundingMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct FloatingPointConversionRoundingMode(isize);

impl FloatingPointConversionRoundingMode {
    /// Metal value `MTL::FloatingPointConversionRoundingMode::FloatingPointConversionRoundingModeToNearestEven`.
    pub const FloatingPointConversionRoundingModeToNearestEven: Self = Self(0);
    /// Metal value `MTL::FloatingPointConversionRoundingMode::FloatingPointConversionRoundingModeTowardZero`.
    pub const FloatingPointConversionRoundingModeTowardZero: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for FloatingPointConversionRoundingMode {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::FunctionLogType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct FunctionLogType(usize);

impl FunctionLogType {
    /// Metal value `MTL::FunctionLogType::FunctionLogTypeValidation`.
    pub const FunctionLogTypeValidation: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0)
    }
}

impl std::convert::TryFrom<usize> for FunctionLogType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::FunctionOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct FunctionOptions(usize);

impl FunctionOptions {
    /// Metal value `MTL::FunctionOptions::FunctionOptionCompileToBinary`.
    pub const FunctionOptionCompileToBinary: Self = Self(1);
    /// Metal value `MTL::FunctionOptions::FunctionOptionFailOnBinaryArchiveMiss`.
    pub const FunctionOptionFailOnBinaryArchiveMiss: Self = Self(4);
    /// Metal value `MTL::FunctionOptions::FunctionOptionNone`.
    pub const FunctionOptionNone: Self = Self(0);
    /// Metal value `MTL::FunctionOptions::FunctionOptionPipelineIndependent`.
    pub const FunctionOptionPipelineIndependent: Self = Self(8);
    /// Metal value `MTL::FunctionOptions::FunctionOptionStoreFunctionInMetalPipelinesScript`.
    pub const FunctionOptionStoreFunctionInMetalPipelinesScript: Self = Self(2);
    /// Metal value `MTL::FunctionOptions::FunctionOptionStoreFunctionInMetalScript`.
    pub const FunctionOptionStoreFunctionInMetalScript: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 15;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for FunctionOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for FunctionOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::FunctionType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct FunctionType(usize);

impl FunctionType {
    /// Metal value `MTL::FunctionType::FunctionTypeFragment`.
    pub const FunctionTypeFragment: Self = Self(2);
    /// Metal value `MTL::FunctionType::FunctionTypeIntersection`.
    pub const FunctionTypeIntersection: Self = Self(6);
    /// Metal value `MTL::FunctionType::FunctionTypeKernel`.
    pub const FunctionTypeKernel: Self = Self(3);
    /// Metal value `MTL::FunctionType::FunctionTypeMesh`.
    pub const FunctionTypeMesh: Self = Self(7);
    /// Metal value `MTL::FunctionType::FunctionTypeObject`.
    pub const FunctionTypeObject: Self = Self(8);
    /// Metal value `MTL::FunctionType::FunctionTypeVertex`.
    pub const FunctionTypeVertex: Self = Self(1);
    /// Metal value `MTL::FunctionType::FunctionTypeVisible`.
    pub const FunctionTypeVisible: Self = Self(5);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1..=3 | 5..=8)
    }
}

impl std::convert::TryFrom<usize> for FunctionType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::GPUFamily` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct GPUFamily(isize);

impl GPUFamily {
    /// Metal value `MTL::GPUFamily::GPUFamilyApple1`.
    pub const GPUFamilyApple1: Self = Self(1001);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple10`.
    pub const GPUFamilyApple10: Self = Self(1010);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple2`.
    pub const GPUFamilyApple2: Self = Self(1002);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple3`.
    pub const GPUFamilyApple3: Self = Self(1003);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple4`.
    pub const GPUFamilyApple4: Self = Self(1004);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple5`.
    pub const GPUFamilyApple5: Self = Self(1005);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple6`.
    pub const GPUFamilyApple6: Self = Self(1006);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple7`.
    pub const GPUFamilyApple7: Self = Self(1007);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple8`.
    pub const GPUFamilyApple8: Self = Self(1008);
    /// Metal value `MTL::GPUFamily::GPUFamilyApple9`.
    pub const GPUFamilyApple9: Self = Self(1009);
    /// Metal value `MTL::GPUFamily::GPUFamilyCommon1`.
    pub const GPUFamilyCommon1: Self = Self(3001);
    /// Metal value `MTL::GPUFamily::GPUFamilyCommon2`.
    pub const GPUFamilyCommon2: Self = Self(3002);
    /// Metal value `MTL::GPUFamily::GPUFamilyCommon3`.
    pub const GPUFamilyCommon3: Self = Self(3003);
    /// Metal value `MTL::GPUFamily::GPUFamilyMac1`.
    pub const GPUFamilyMac1: Self = Self(2001);
    /// Metal value `MTL::GPUFamily::GPUFamilyMac2`.
    pub const GPUFamilyMac2: Self = Self(2002);
    /// Metal value `MTL::GPUFamily::GPUFamilyMacCatalyst1`.
    pub const GPUFamilyMacCatalyst1: Self = Self(4001);
    /// Metal value `MTL::GPUFamily::GPUFamilyMacCatalyst2`.
    pub const GPUFamilyMacCatalyst2: Self = Self(4002);
    /// Metal value `MTL::GPUFamily::GPUFamilyMetal3`.
    pub const GPUFamilyMetal3: Self = Self(5001);
    /// Metal value `MTL::GPUFamily::GPUFamilyMetal4`.
    pub const GPUFamilyMetal4: Self = Self(5002);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1001..=1010 | 2001 | 2002 | 3001..=3003 | 4001 | 4002 | 5001 | 5002)
    }
}

impl std::convert::TryFrom<isize> for GPUFamily {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::HazardTrackingMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct HazardTrackingMode(usize);

impl HazardTrackingMode {
    /// Metal value `MTL::HazardTrackingMode::HazardTrackingModeDefault`.
    pub const HazardTrackingModeDefault: Self = Self(0);
    /// Metal value `MTL::HazardTrackingMode::HazardTrackingModeTracked`.
    pub const HazardTrackingModeTracked: Self = Self(2);
    /// Metal value `MTL::HazardTrackingMode::HazardTrackingModeUntracked`.
    pub const HazardTrackingModeUntracked: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for HazardTrackingMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::HeapType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct HeapType(isize);

impl HeapType {
    /// Metal value `MTL::HeapType::HeapTypeAutomatic`.
    pub const HeapTypeAutomatic: Self = Self(0);
    /// Metal value `MTL::HeapType::HeapTypePlacement`.
    pub const HeapTypePlacement: Self = Self(1);
    /// Metal value `MTL::HeapType::HeapTypeSparse`.
    pub const HeapTypeSparse: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for HeapType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOCommandQueueType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOCommandQueueType(isize);

impl IOCommandQueueType {
    /// Metal value `MTL::IOCommandQueueType::IOCommandQueueTypeConcurrent`.
    pub const IOCommandQueueTypeConcurrent: Self = Self(0);
    /// Metal value `MTL::IOCommandQueueType::IOCommandQueueTypeSerial`.
    pub const IOCommandQueueTypeSerial: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for IOCommandQueueType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOCompressionMethod` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOCompressionMethod(isize);

impl IOCompressionMethod {
    /// Metal value `MTL::IOCompressionMethod::IOCompressionMethodLZ4`.
    pub const IOCompressionMethodLZ4: Self = Self(2);
    /// Metal value `MTL::IOCompressionMethod::IOCompressionMethodLZBitmap`.
    pub const IOCompressionMethodLZBitmap: Self = Self(4);
    /// Metal value `MTL::IOCompressionMethod::IOCompressionMethodLZFSE`.
    pub const IOCompressionMethodLZFSE: Self = Self(1);
    /// Metal value `MTL::IOCompressionMethod::IOCompressionMethodLZMA`.
    pub const IOCompressionMethodLZMA: Self = Self(3);
    /// Metal value `MTL::IOCompressionMethod::IOCompressionMethodZlib`.
    pub const IOCompressionMethodZlib: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<isize> for IOCompressionMethod {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOCompressionStatus` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOCompressionStatus(isize);

impl IOCompressionStatus {
    /// Metal value `MTL::IOCompressionStatus::IOCompressionStatusComplete`.
    pub const IOCompressionStatusComplete: Self = Self(0);
    /// Metal value `MTL::IOCompressionStatus::IOCompressionStatusError`.
    pub const IOCompressionStatusError: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for IOCompressionStatus {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOError(isize);

impl IOError {
    /// Metal value `MTL::IOError::IOErrorInternal`.
    pub const IOErrorInternal: Self = Self(2);
    /// Metal value `MTL::IOError::IOErrorURLInvalid`.
    pub const IOErrorURLInvalid: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1 | 2)
    }
}

impl std::convert::TryFrom<isize> for IOError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOPriority` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOPriority(isize);

impl IOPriority {
    /// Metal value `MTL::IOPriority::IOPriorityHigh`.
    pub const IOPriorityHigh: Self = Self(0);
    /// Metal value `MTL::IOPriority::IOPriorityLow`.
    pub const IOPriorityLow: Self = Self(2);
    /// Metal value `MTL::IOPriority::IOPriorityNormal`.
    pub const IOPriorityNormal: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for IOPriority {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IOStatus` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IOStatus(isize);

impl IOStatus {
    /// Metal value `MTL::IOStatus::IOStatusCancelled`.
    pub const IOStatusCancelled: Self = Self(1);
    /// Metal value `MTL::IOStatus::IOStatusComplete`.
    pub const IOStatusComplete: Self = Self(3);
    /// Metal value `MTL::IOStatus::IOStatusError`.
    pub const IOStatusError: Self = Self(2);
    /// Metal value `MTL::IOStatus::IOStatusPending`.
    pub const IOStatusPending: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<isize> for IOStatus {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IndexType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IndexType(usize);

impl IndexType {
    /// Metal value `MTL::IndexType::IndexTypeUInt16`.
    pub const IndexTypeUInt16: Self = Self(0);
    /// Metal value `MTL::IndexType::IndexTypeUInt32`.
    pub const IndexTypeUInt32: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for IndexType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::IndirectCommandType` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IndirectCommandType(usize);

impl IndirectCommandType {
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeConcurrentDispatch`.
    pub const IndirectCommandTypeConcurrentDispatch: Self = Self(32);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeConcurrentDispatchThreads`.
    pub const IndirectCommandTypeConcurrentDispatchThreads: Self = Self(64);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDraw`.
    pub const IndirectCommandTypeDraw: Self = Self(1);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDrawIndexed`.
    pub const IndirectCommandTypeDrawIndexed: Self = Self(2);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDrawIndexedPatches`.
    pub const IndirectCommandTypeDrawIndexedPatches: Self = Self(8);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDrawMeshThreadgroups`.
    pub const IndirectCommandTypeDrawMeshThreadgroups: Self = Self(128);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDrawMeshThreads`.
    pub const IndirectCommandTypeDrawMeshThreads: Self = Self(256);
    /// Metal value `MTL::IndirectCommandType::IndirectCommandTypeDrawPatches`.
    pub const IndirectCommandTypeDrawPatches: Self = Self(4);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 495;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for IndirectCommandType {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for IndirectCommandType {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::IntersectionFunctionSignature` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct IntersectionFunctionSignature(usize);

impl IntersectionFunctionSignature {
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureCurveData`.
    pub const IntersectionFunctionSignatureCurveData: Self = Self(128);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureExtendedLimits`.
    pub const IntersectionFunctionSignatureExtendedLimits: Self = Self(32);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureInstanceMotion`.
    pub const IntersectionFunctionSignatureInstanceMotion: Self = Self(8);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureInstancing`.
    pub const IntersectionFunctionSignatureInstancing: Self = Self(1);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureIntersectionFunctionBuffer`.
    pub const IntersectionFunctionSignatureIntersectionFunctionBuffer: Self = Self(256);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureMaxLevels`.
    pub const IntersectionFunctionSignatureMaxLevels: Self = Self(64);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureNone`.
    pub const IntersectionFunctionSignatureNone: Self = Self(0);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignaturePrimitiveMotion`.
    pub const IntersectionFunctionSignaturePrimitiveMotion: Self = Self(16);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureTriangleData`.
    pub const IntersectionFunctionSignatureTriangleData: Self = Self(2);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureUserData`.
    pub const IntersectionFunctionSignatureUserData: Self = Self(512);
    /// Metal value `MTL::IntersectionFunctionSignature::IntersectionFunctionSignatureWorldSpaceData`.
    pub const IntersectionFunctionSignatureWorldSpaceData: Self = Self(4);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 1023;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for IntersectionFunctionSignature {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for IntersectionFunctionSignature {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::LanguageVersion` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LanguageVersion(usize);

impl LanguageVersion {
    /// Metal value `MTL::LanguageVersion::LanguageVersion1_0`.
    pub const LanguageVersion1_0: Self = Self(65536);
    /// Metal value `MTL::LanguageVersion::LanguageVersion1_1`.
    pub const LanguageVersion1_1: Self = Self(65537);
    /// Metal value `MTL::LanguageVersion::LanguageVersion1_2`.
    pub const LanguageVersion1_2: Self = Self(65538);
    /// Metal value `MTL::LanguageVersion::LanguageVersion2_0`.
    pub const LanguageVersion2_0: Self = Self(131072);
    /// Metal value `MTL::LanguageVersion::LanguageVersion2_1`.
    pub const LanguageVersion2_1: Self = Self(131073);
    /// Metal value `MTL::LanguageVersion::LanguageVersion2_2`.
    pub const LanguageVersion2_2: Self = Self(131074);
    /// Metal value `MTL::LanguageVersion::LanguageVersion2_3`.
    pub const LanguageVersion2_3: Self = Self(131075);
    /// Metal value `MTL::LanguageVersion::LanguageVersion2_4`.
    pub const LanguageVersion2_4: Self = Self(131076);
    /// Metal value `MTL::LanguageVersion::LanguageVersion3_0`.
    pub const LanguageVersion3_0: Self = Self(196608);
    /// Metal value `MTL::LanguageVersion::LanguageVersion3_1`.
    pub const LanguageVersion3_1: Self = Self(196609);
    /// Metal value `MTL::LanguageVersion::LanguageVersion3_2`.
    pub const LanguageVersion3_2: Self = Self(196610);
    /// Metal value `MTL::LanguageVersion::LanguageVersion4_0`.
    pub const LanguageVersion4_0: Self = Self(262144);
    /// Metal value `MTL::LanguageVersion::LanguageVersion4_1`.
    pub const LanguageVersion4_1: Self = Self(262145);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 65536..=65538 | 131072..=131076 | 196608..=196610 | 262144 | 262145)
    }
}

impl std::convert::TryFrom<usize> for LanguageVersion {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LibraryError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LibraryError(usize);

impl LibraryError {
    /// Metal value `MTL::LibraryError::LibraryErrorCompileFailure`.
    pub const LibraryErrorCompileFailure: Self = Self(3);
    /// Metal value `MTL::LibraryError::LibraryErrorCompileWarning`.
    pub const LibraryErrorCompileWarning: Self = Self(4);
    /// Metal value `MTL::LibraryError::LibraryErrorFileNotFound`.
    pub const LibraryErrorFileNotFound: Self = Self(6);
    /// Metal value `MTL::LibraryError::LibraryErrorFunctionNotFound`.
    pub const LibraryErrorFunctionNotFound: Self = Self(5);
    /// Metal value `MTL::LibraryError::LibraryErrorInternal`.
    pub const LibraryErrorInternal: Self = Self(2);
    /// Metal value `MTL::LibraryError::LibraryErrorUnsupported`.
    pub const LibraryErrorUnsupported: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1..=6)
    }
}

impl std::convert::TryFrom<usize> for LibraryError {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LibraryOptimizationLevel` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LibraryOptimizationLevel(isize);

impl LibraryOptimizationLevel {
    /// Metal value `MTL::LibraryOptimizationLevel::LibraryOptimizationLevelDefault`.
    pub const LibraryOptimizationLevelDefault: Self = Self(0);
    /// Metal value `MTL::LibraryOptimizationLevel::LibraryOptimizationLevelSize`.
    pub const LibraryOptimizationLevelSize: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for LibraryOptimizationLevel {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LibraryType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LibraryType(isize);

impl LibraryType {
    /// Metal value `MTL::LibraryType::LibraryTypeDynamic`.
    pub const LibraryTypeDynamic: Self = Self(1);
    /// Metal value `MTL::LibraryType::LibraryTypeExecutable`.
    pub const LibraryTypeExecutable: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for LibraryType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LoadAction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LoadAction(usize);

impl LoadAction {
    /// Metal value `MTL::LoadAction::LoadActionClear`.
    pub const LoadActionClear: Self = Self(2);
    /// Metal value `MTL::LoadAction::LoadActionDontCare`.
    pub const LoadActionDontCare: Self = Self(0);
    /// Metal value `MTL::LoadAction::LoadActionLoad`.
    pub const LoadActionLoad: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for LoadAction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LogLevel` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LogLevel(isize);

impl LogLevel {
    /// Metal value `MTL::LogLevel::LogLevelDebug`.
    pub const LogLevelDebug: Self = Self(1);
    /// Metal value `MTL::LogLevel::LogLevelError`.
    pub const LogLevelError: Self = Self(4);
    /// Metal value `MTL::LogLevel::LogLevelFault`.
    pub const LogLevelFault: Self = Self(5);
    /// Metal value `MTL::LogLevel::LogLevelInfo`.
    pub const LogLevelInfo: Self = Self(2);
    /// Metal value `MTL::LogLevel::LogLevelNotice`.
    pub const LogLevelNotice: Self = Self(3);
    /// Metal value `MTL::LogLevel::LogLevelUndefined`.
    pub const LogLevelUndefined: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<isize> for LogLevel {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::LogStateError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LogStateError(usize);

impl LogStateError {
    /// Metal value `MTL::LogStateError::LogStateErrorInvalid`.
    pub const LogStateErrorInvalid: Self = Self(2);
    /// Metal value `MTL::LogStateError::LogStateErrorInvalidSize`.
    pub const LogStateErrorInvalidSize: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1 | 2)
    }
}

impl std::convert::TryFrom<usize> for LogStateError {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MathFloatingPointFunctions` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MathFloatingPointFunctions(isize);

impl MathFloatingPointFunctions {
    /// Metal value `MTL::MathFloatingPointFunctions::MathFloatingPointFunctionsFast`.
    pub const MathFloatingPointFunctionsFast: Self = Self(0);
    /// Metal value `MTL::MathFloatingPointFunctions::MathFloatingPointFunctionsPrecise`.
    pub const MathFloatingPointFunctionsPrecise: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for MathFloatingPointFunctions {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MathMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MathMode(isize);

impl MathMode {
    /// Metal value `MTL::MathMode::MathModeFast`.
    pub const MathModeFast: Self = Self(2);
    /// Metal value `MTL::MathMode::MathModeRelaxed`.
    pub const MathModeRelaxed: Self = Self(1);
    /// Metal value `MTL::MathMode::MathModeSafe`.
    pub const MathModeSafe: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for MathMode {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MatrixLayout` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MatrixLayout(isize);

impl MatrixLayout {
    /// Metal value `MTL::MatrixLayout::MatrixLayoutColumnMajor`.
    pub const MatrixLayoutColumnMajor: Self = Self(0);
    /// Metal value `MTL::MatrixLayout::MatrixLayoutRowMajor`.
    pub const MatrixLayoutRowMajor: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for MatrixLayout {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MotionBorderMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MotionBorderMode(u32);

impl MotionBorderMode {
    /// Metal value `MTL::MotionBorderMode::MotionBorderModeClamp`.
    pub const MotionBorderModeClamp: Self = Self(0);
    /// Metal value `MTL::MotionBorderMode::MotionBorderModeVanish`.
    pub const MotionBorderModeVanish: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: u32) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> u32 {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<u32> for MotionBorderMode {
    type Error = ();

    fn try_from(value: u32) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MultisampleDepthResolveFilter` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MultisampleDepthResolveFilter(usize);

impl MultisampleDepthResolveFilter {
    /// Metal value `MTL::MultisampleDepthResolveFilter::MultisampleDepthResolveFilterMax`.
    pub const MultisampleDepthResolveFilterMax: Self = Self(2);
    /// Metal value `MTL::MultisampleDepthResolveFilter::MultisampleDepthResolveFilterMin`.
    pub const MultisampleDepthResolveFilterMin: Self = Self(1);
    /// Metal value `MTL::MultisampleDepthResolveFilter::MultisampleDepthResolveFilterSample0`.
    pub const MultisampleDepthResolveFilterSample0: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for MultisampleDepthResolveFilter {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::MultisampleStencilResolveFilter` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct MultisampleStencilResolveFilter(usize);

impl MultisampleStencilResolveFilter {
    /// Metal value `MTL::MultisampleStencilResolveFilter::MultisampleStencilResolveFilterDepthResolvedSample`.
    pub const MultisampleStencilResolveFilterDepthResolvedSample: Self = Self(1);
    /// Metal value `MTL::MultisampleStencilResolveFilter::MultisampleStencilResolveFilterSample0`.
    pub const MultisampleStencilResolveFilterSample0: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for MultisampleStencilResolveFilter {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::Mutability` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Mutability(usize);

impl Mutability {
    /// Metal value `MTL::Mutability::MutabilityDefault`.
    pub const MutabilityDefault: Self = Self(0);
    /// Metal value `MTL::Mutability::MutabilityImmutable`.
    pub const MutabilityImmutable: Self = Self(2);
    /// Metal value `MTL::Mutability::MutabilityMutable`.
    pub const MutabilityMutable: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for Mutability {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::PatchType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct PatchType(usize);

impl PatchType {
    /// Metal value `MTL::PatchType::PatchTypeNone`.
    pub const PatchTypeNone: Self = Self(0);
    /// Metal value `MTL::PatchType::PatchTypeQuad`.
    pub const PatchTypeQuad: Self = Self(2);
    /// Metal value `MTL::PatchType::PatchTypeTriangle`.
    pub const PatchTypeTriangle: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for PatchType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::PipelineOption` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct PipelineOption(usize);

impl PipelineOption {
    /// Metal value `MTL::PipelineOption::PipelineOptionArgumentInfo`.
    pub const PipelineOptionArgumentInfo: Self = Self(1);
    /// Metal value `MTL::PipelineOption::PipelineOptionBindingInfo`.
    pub const PipelineOptionBindingInfo: Self = Self(1);
    /// Metal value `MTL::PipelineOption::PipelineOptionBufferTypeInfo`.
    pub const PipelineOptionBufferTypeInfo: Self = Self(2);
    /// Metal value `MTL::PipelineOption::PipelineOptionFailOnBinaryArchiveMiss`.
    pub const PipelineOptionFailOnBinaryArchiveMiss: Self = Self(4);
    /// Metal value `MTL::PipelineOption::PipelineOptionNone`.
    pub const PipelineOptionNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 7;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for PipelineOption {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for PipelineOption {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::PrimitiveTopologyClass` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct PrimitiveTopologyClass(usize);

impl PrimitiveTopologyClass {
    /// Metal value `MTL::PrimitiveTopologyClass::PrimitiveTopologyClassLine`.
    pub const PrimitiveTopologyClassLine: Self = Self(2);
    /// Metal value `MTL::PrimitiveTopologyClass::PrimitiveTopologyClassPoint`.
    pub const PrimitiveTopologyClassPoint: Self = Self(1);
    /// Metal value `MTL::PrimitiveTopologyClass::PrimitiveTopologyClassTriangle`.
    pub const PrimitiveTopologyClassTriangle: Self = Self(3);
    /// Metal value `MTL::PrimitiveTopologyClass::PrimitiveTopologyClassUnspecified`.
    pub const PrimitiveTopologyClassUnspecified: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<usize> for PrimitiveTopologyClass {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::PurgeableState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct PurgeableState(usize);

impl PurgeableState {
    /// Metal value `MTL::PurgeableState::PurgeableStateEmpty`.
    pub const PurgeableStateEmpty: Self = Self(4);
    /// Metal value `MTL::PurgeableState::PurgeableStateKeepCurrent`.
    pub const PurgeableStateKeepCurrent: Self = Self(1);
    /// Metal value `MTL::PurgeableState::PurgeableStateNonVolatile`.
    pub const PurgeableStateNonVolatile: Self = Self(2);
    /// Metal value `MTL::PurgeableState::PurgeableStateVolatile`.
    pub const PurgeableStateVolatile: Self = Self(3);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 1..=4)
    }
}

impl std::convert::TryFrom<usize> for PurgeableState {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::ReadWriteTextureTier` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ReadWriteTextureTier(usize);

impl ReadWriteTextureTier {
    /// Metal value `MTL::ReadWriteTextureTier::ReadWriteTextureTier1`.
    pub const ReadWriteTextureTier1: Self = Self(1);
    /// Metal value `MTL::ReadWriteTextureTier::ReadWriteTextureTier2`.
    pub const ReadWriteTextureTier2: Self = Self(2);
    /// Metal value `MTL::ReadWriteTextureTier::ReadWriteTextureTierNone`.
    pub const ReadWriteTextureTierNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for ReadWriteTextureTier {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::RenderStages` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct RenderStages(usize);

impl RenderStages {
    /// Metal value `MTL::RenderStages::RenderStageFragment`.
    pub const RenderStageFragment: Self = Self(2);
    /// Metal value `MTL::RenderStages::RenderStageMesh`.
    pub const RenderStageMesh: Self = Self(16);
    /// Metal value `MTL::RenderStages::RenderStageObject`.
    pub const RenderStageObject: Self = Self(8);
    /// Metal value `MTL::RenderStages::RenderStageTile`.
    pub const RenderStageTile: Self = Self(4);
    /// Metal value `MTL::RenderStages::RenderStageVertex`.
    pub const RenderStageVertex: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 31;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for RenderStages {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for RenderStages {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::ResourceUsage` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ResourceUsage(usize);

impl ResourceUsage {
    /// Metal value `MTL::ResourceUsage::ResourceUsageRead`.
    pub const ResourceUsageRead: Self = Self(1);
    /// Metal value `MTL::ResourceUsage::ResourceUsageSample`.
    pub const ResourceUsageSample: Self = Self(4);
    /// Metal value `MTL::ResourceUsage::ResourceUsageWrite`.
    pub const ResourceUsageWrite: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 7;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for ResourceUsage {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for ResourceUsage {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::SamplerAddressMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SamplerAddressMode(usize);

impl SamplerAddressMode {
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeClampToBorderColor`.
    pub const SamplerAddressModeClampToBorderColor: Self = Self(5);
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeClampToEdge`.
    pub const SamplerAddressModeClampToEdge: Self = Self(0);
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeClampToZero`.
    pub const SamplerAddressModeClampToZero: Self = Self(4);
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeMirrorClampToEdge`.
    pub const SamplerAddressModeMirrorClampToEdge: Self = Self(1);
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeMirrorRepeat`.
    pub const SamplerAddressModeMirrorRepeat: Self = Self(3);
    /// Metal value `MTL::SamplerAddressMode::SamplerAddressModeRepeat`.
    pub const SamplerAddressModeRepeat: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<usize> for SamplerAddressMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SamplerBorderColor` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SamplerBorderColor(usize);

impl SamplerBorderColor {
    /// Metal value `MTL::SamplerBorderColor::SamplerBorderColorOpaqueBlack`.
    pub const SamplerBorderColorOpaqueBlack: Self = Self(1);
    /// Metal value `MTL::SamplerBorderColor::SamplerBorderColorOpaqueWhite`.
    pub const SamplerBorderColorOpaqueWhite: Self = Self(2);
    /// Metal value `MTL::SamplerBorderColor::SamplerBorderColorTransparentBlack`.
    pub const SamplerBorderColorTransparentBlack: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for SamplerBorderColor {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SamplerMinMagFilter` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SamplerMinMagFilter(usize);

impl SamplerMinMagFilter {
    /// Metal value `MTL::SamplerMinMagFilter::SamplerMinMagFilterLinear`.
    pub const SamplerMinMagFilterLinear: Self = Self(1);
    /// Metal value `MTL::SamplerMinMagFilter::SamplerMinMagFilterNearest`.
    pub const SamplerMinMagFilterNearest: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for SamplerMinMagFilter {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SamplerMipFilter` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SamplerMipFilter(usize);

impl SamplerMipFilter {
    /// Metal value `MTL::SamplerMipFilter::SamplerMipFilterLinear`.
    pub const SamplerMipFilterLinear: Self = Self(2);
    /// Metal value `MTL::SamplerMipFilter::SamplerMipFilterNearest`.
    pub const SamplerMipFilterNearest: Self = Self(1);
    /// Metal value `MTL::SamplerMipFilter::SamplerMipFilterNotMipmapped`.
    pub const SamplerMipFilterNotMipmapped: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for SamplerMipFilter {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SamplerReductionMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SamplerReductionMode(isize);

impl SamplerReductionMode {
    /// Metal value `MTL::SamplerReductionMode::SamplerReductionModeMaximum`.
    pub const SamplerReductionModeMaximum: Self = Self(2);
    /// Metal value `MTL::SamplerReductionMode::SamplerReductionModeMinimum`.
    pub const SamplerReductionModeMinimum: Self = Self(1);
    /// Metal value `MTL::SamplerReductionMode::SamplerReductionModeWeightedAverage`.
    pub const SamplerReductionModeWeightedAverage: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for SamplerReductionMode {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::ShaderValidation` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ShaderValidation(isize);

impl ShaderValidation {
    /// Metal value `MTL::ShaderValidation::ShaderValidationDefault`.
    pub const ShaderValidationDefault: Self = Self(0);
    /// Metal value `MTL::ShaderValidation::ShaderValidationDisabled`.
    pub const ShaderValidationDisabled: Self = Self(2);
    /// Metal value `MTL::ShaderValidation::ShaderValidationEnabled`.
    pub const ShaderValidationEnabled: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for ShaderValidation {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SparsePageSize` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SparsePageSize(isize);

impl SparsePageSize {
    /// Metal value `MTL::SparsePageSize::SparsePageSize16`.
    pub const SparsePageSize16: Self = Self(101);
    /// Metal value `MTL::SparsePageSize::SparsePageSize256`.
    pub const SparsePageSize256: Self = Self(103);
    /// Metal value `MTL::SparsePageSize::SparsePageSize64`.
    pub const SparsePageSize64: Self = Self(102);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 101..=103)
    }
}

impl std::convert::TryFrom<isize> for SparsePageSize {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SparseTextureMappingMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SparseTextureMappingMode(usize);

impl SparseTextureMappingMode {
    /// Metal value `MTL::SparseTextureMappingMode::SparseTextureMappingModeMap`.
    pub const SparseTextureMappingModeMap: Self = Self(0);
    /// Metal value `MTL::SparseTextureMappingMode::SparseTextureMappingModeUnmap`.
    pub const SparseTextureMappingModeUnmap: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for SparseTextureMappingMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::SparseTextureRegionAlignmentMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct SparseTextureRegionAlignmentMode(usize);

impl SparseTextureRegionAlignmentMode {
    /// Metal value `MTL::SparseTextureRegionAlignmentMode::SparseTextureRegionAlignmentModeInward`.
    pub const SparseTextureRegionAlignmentModeInward: Self = Self(1);
    /// Metal value `MTL::SparseTextureRegionAlignmentMode::SparseTextureRegionAlignmentModeOutward`.
    pub const SparseTextureRegionAlignmentModeOutward: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for SparseTextureRegionAlignmentMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::Stages` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Stages(usize);

impl Stages {
    /// Metal value `MTL::Stages::StageAccelerationStructure`.
    pub const StageAccelerationStructure: Self = Self(536870912);
    /// Metal value `MTL::Stages::StageAll`.
    pub const StageAll: Self = Self(9223372036854775807);
    /// Metal value `MTL::Stages::StageBlit`.
    pub const StageBlit: Self = Self(268435456);
    /// Metal value `MTL::Stages::StageDispatch`.
    pub const StageDispatch: Self = Self(134217728);
    /// Metal value `MTL::Stages::StageFragment`.
    pub const StageFragment: Self = Self(2);
    /// Metal value `MTL::Stages::StageMachineLearning`.
    pub const StageMachineLearning: Self = Self(1073741824);
    /// Metal value `MTL::Stages::StageMesh`.
    pub const StageMesh: Self = Self(16);
    /// Metal value `MTL::Stages::StageObject`.
    pub const StageObject: Self = Self(8);
    /// Metal value `MTL::Stages::StageResourceState`.
    pub const StageResourceState: Self = Self(67108864);
    /// Metal value `MTL::Stages::StageTile`.
    pub const StageTile: Self = Self(4);
    /// Metal value `MTL::Stages::StageVertex`.
    pub const StageVertex: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 9223372036854775807;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for Stages {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for Stages {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::StencilOperation` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StencilOperation(usize);

impl StencilOperation {
    /// Metal value `MTL::StencilOperation::StencilOperationDecrementClamp`.
    pub const StencilOperationDecrementClamp: Self = Self(4);
    /// Metal value `MTL::StencilOperation::StencilOperationDecrementWrap`.
    pub const StencilOperationDecrementWrap: Self = Self(7);
    /// Metal value `MTL::StencilOperation::StencilOperationIncrementClamp`.
    pub const StencilOperationIncrementClamp: Self = Self(3);
    /// Metal value `MTL::StencilOperation::StencilOperationIncrementWrap`.
    pub const StencilOperationIncrementWrap: Self = Self(6);
    /// Metal value `MTL::StencilOperation::StencilOperationInvert`.
    pub const StencilOperationInvert: Self = Self(5);
    /// Metal value `MTL::StencilOperation::StencilOperationKeep`.
    pub const StencilOperationKeep: Self = Self(0);
    /// Metal value `MTL::StencilOperation::StencilOperationReplace`.
    pub const StencilOperationReplace: Self = Self(2);
    /// Metal value `MTL::StencilOperation::StencilOperationZero`.
    pub const StencilOperationZero: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=7)
    }
}

impl std::convert::TryFrom<usize> for StencilOperation {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::StepFunction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StepFunction(usize);

impl StepFunction {
    /// Metal value `MTL::StepFunction::StepFunctionConstant`.
    pub const StepFunctionConstant: Self = Self(0);
    /// Metal value `MTL::StepFunction::StepFunctionPerInstance`.
    pub const StepFunctionPerInstance: Self = Self(2);
    /// Metal value `MTL::StepFunction::StepFunctionPerPatch`.
    pub const StepFunctionPerPatch: Self = Self(3);
    /// Metal value `MTL::StepFunction::StepFunctionPerPatchControlPoint`.
    pub const StepFunctionPerPatchControlPoint: Self = Self(4);
    /// Metal value `MTL::StepFunction::StepFunctionPerVertex`.
    pub const StepFunctionPerVertex: Self = Self(1);
    /// Metal value `MTL::StepFunction::StepFunctionThreadPositionInGridX`.
    pub const StepFunctionThreadPositionInGridX: Self = Self(5);
    /// Metal value `MTL::StepFunction::StepFunctionThreadPositionInGridXIndexed`.
    pub const StepFunctionThreadPositionInGridXIndexed: Self = Self(7);
    /// Metal value `MTL::StepFunction::StepFunctionThreadPositionInGridY`.
    pub const StepFunctionThreadPositionInGridY: Self = Self(6);
    /// Metal value `MTL::StepFunction::StepFunctionThreadPositionInGridYIndexed`.
    pub const StepFunctionThreadPositionInGridYIndexed: Self = Self(8);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=8)
    }
}

impl std::convert::TryFrom<usize> for StepFunction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::StitchedLibraryOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StitchedLibraryOptions(usize);

impl StitchedLibraryOptions {
    /// Metal value `MTL::StitchedLibraryOptions::StitchedLibraryOptionFailOnBinaryArchiveMiss`.
    pub const StitchedLibraryOptionFailOnBinaryArchiveMiss: Self = Self(1);
    /// Metal value `MTL::StitchedLibraryOptions::StitchedLibraryOptionNone`.
    pub const StitchedLibraryOptionNone: Self = Self(0);
    /// Metal value `MTL::StitchedLibraryOptions::StitchedLibraryOptionStoreLibraryInMetalPipelinesScript`.
    pub const StitchedLibraryOptionStoreLibraryInMetalPipelinesScript: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 3;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for StitchedLibraryOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for StitchedLibraryOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::StoreAction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StoreAction(usize);

impl StoreAction {
    /// Metal value `MTL::StoreAction::StoreActionCustomSampleDepthStore`.
    pub const StoreActionCustomSampleDepthStore: Self = Self(5);
    /// Metal value `MTL::StoreAction::StoreActionDontCare`.
    pub const StoreActionDontCare: Self = Self(0);
    /// Metal value `MTL::StoreAction::StoreActionMultisampleResolve`.
    pub const StoreActionMultisampleResolve: Self = Self(2);
    /// Metal value `MTL::StoreAction::StoreActionStore`.
    pub const StoreActionStore: Self = Self(1);
    /// Metal value `MTL::StoreAction::StoreActionStoreAndMultisampleResolve`.
    pub const StoreActionStoreAndMultisampleResolve: Self = Self(3);
    /// Metal value `MTL::StoreAction::StoreActionUnknown`.
    pub const StoreActionUnknown: Self = Self(4);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<usize> for StoreAction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::StoreActionOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StoreActionOptions(usize);

impl StoreActionOptions {
    /// Metal value `MTL::StoreActionOptions::StoreActionOptionCustomSamplePositions`.
    pub const StoreActionOptionCustomSamplePositions: Self = Self(1);
    /// Metal value `MTL::StoreActionOptions::StoreActionOptionNone`.
    pub const StoreActionOptionNone: Self = Self(0);
    /// Metal value `MTL::StoreActionOptions::StoreActionOptionValidMask`.
    pub const StoreActionOptionValidMask: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 1;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for StoreActionOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for StoreActionOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::TensorDataType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TensorDataType(isize);

impl TensorDataType {
    /// Metal value `MTL::TensorDataType::TensorDataTypeBFloat16`.
    pub const TensorDataTypeBFloat16: Self = Self(121);
    /// Metal value `MTL::TensorDataType::TensorDataTypeFloat16`.
    pub const TensorDataTypeFloat16: Self = Self(16);
    /// Metal value `MTL::TensorDataType::TensorDataTypeFloat32`.
    pub const TensorDataTypeFloat32: Self = Self(3);
    /// Metal value `MTL::TensorDataType::TensorDataTypeInt16`.
    pub const TensorDataTypeInt16: Self = Self(37);
    /// Metal value `MTL::TensorDataType::TensorDataTypeInt2`.
    pub const TensorDataTypeInt2: Self = Self(150);
    /// Metal value `MTL::TensorDataType::TensorDataTypeInt32`.
    pub const TensorDataTypeInt32: Self = Self(29);
    /// Metal value `MTL::TensorDataType::TensorDataTypeInt4`.
    pub const TensorDataTypeInt4: Self = Self(143);
    /// Metal value `MTL::TensorDataType::TensorDataTypeInt8`.
    pub const TensorDataTypeInt8: Self = Self(45);
    /// Metal value `MTL::TensorDataType::TensorDataTypeMetalFloat4E2M1`.
    pub const TensorDataTypeMetalFloat4E2M1: Self = Self(148);
    /// Metal value `MTL::TensorDataType::TensorDataTypeMetalFloat8E4M3`.
    pub const TensorDataTypeMetalFloat8E4M3: Self = Self(142);
    /// Metal value `MTL::TensorDataType::TensorDataTypeMetalFloat8E5M2`.
    pub const TensorDataTypeMetalFloat8E5M2: Self = Self(141);
    /// Metal value `MTL::TensorDataType::TensorDataTypeMetalFloat8UE8M0`.
    pub const TensorDataTypeMetalFloat8UE8M0: Self = Self(145);
    /// Metal value `MTL::TensorDataType::TensorDataTypeNone`.
    pub const TensorDataTypeNone: Self = Self(0);
    /// Metal value `MTL::TensorDataType::TensorDataTypeUInt16`.
    pub const TensorDataTypeUInt16: Self = Self(41);
    /// Metal value `MTL::TensorDataType::TensorDataTypeUInt2`.
    pub const TensorDataTypeUInt2: Self = Self(149);
    /// Metal value `MTL::TensorDataType::TensorDataTypeUInt32`.
    pub const TensorDataTypeUInt32: Self = Self(33);
    /// Metal value `MTL::TensorDataType::TensorDataTypeUInt4`.
    pub const TensorDataTypeUInt4: Self = Self(144);
    /// Metal value `MTL::TensorDataType::TensorDataTypeUInt8`.
    pub const TensorDataTypeUInt8: Self = Self(49);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 3 | 16 | 29 | 33 | 37 | 41 | 45 | 49 | 121 | 141..=145 | 148..=150)
    }
}

impl std::convert::TryFrom<isize> for TensorDataType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TensorError` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TensorError(isize);

impl TensorError {
    /// Metal value `MTL::TensorError::TensorErrorInternalError`.
    pub const TensorErrorInternalError: Self = Self(1);
    /// Metal value `MTL::TensorError::TensorErrorInvalidDescriptor`.
    pub const TensorErrorInvalidDescriptor: Self = Self(2);
    /// Metal value `MTL::TensorError::TensorErrorNone`.
    pub const TensorErrorNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for TensorError {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TensorPlaneType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TensorPlaneType(isize);

impl TensorPlaneType {
    /// Metal value `MTL::TensorPlaneType::TensorPlaneTypeData`.
    pub const TensorPlaneTypeData: Self = Self(0);
    /// Metal value `MTL::TensorPlaneType::TensorPlaneTypeScales`.
    pub const TensorPlaneTypeScales: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for TensorPlaneType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TensorUsage` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TensorUsage(usize);

impl TensorUsage {
    /// Metal value `MTL::TensorUsage::TensorUsageCompute`.
    pub const TensorUsageCompute: Self = Self(1);
    /// Metal value `MTL::TensorUsage::TensorUsageMachineLearning`.
    pub const TensorUsageMachineLearning: Self = Self(4);
    /// Metal value `MTL::TensorUsage::TensorUsageRender`.
    pub const TensorUsageRender: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 7;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for TensorUsage {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for TensorUsage {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `MTL::TessellationControlPointIndexType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TessellationControlPointIndexType(usize);

impl TessellationControlPointIndexType {
    /// Metal value `MTL::TessellationControlPointIndexType::TessellationControlPointIndexTypeNone`.
    pub const TessellationControlPointIndexTypeNone: Self = Self(0);
    /// Metal value `MTL::TessellationControlPointIndexType::TessellationControlPointIndexTypeUInt16`.
    pub const TessellationControlPointIndexTypeUInt16: Self = Self(1);
    /// Metal value `MTL::TessellationControlPointIndexType::TessellationControlPointIndexTypeUInt32`.
    pub const TessellationControlPointIndexTypeUInt32: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for TessellationControlPointIndexType {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TessellationFactorFormat` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TessellationFactorFormat(usize);

impl TessellationFactorFormat {
    /// Metal value `MTL::TessellationFactorFormat::TessellationFactorFormatHalf`.
    pub const TessellationFactorFormatHalf: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0)
    }
}

impl std::convert::TryFrom<usize> for TessellationFactorFormat {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TessellationFactorStepFunction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TessellationFactorStepFunction(usize);

impl TessellationFactorStepFunction {
    /// Metal value `MTL::TessellationFactorStepFunction::TessellationFactorStepFunctionConstant`.
    pub const TessellationFactorStepFunctionConstant: Self = Self(0);
    /// Metal value `MTL::TessellationFactorStepFunction::TessellationFactorStepFunctionPerInstance`.
    pub const TessellationFactorStepFunctionPerInstance: Self = Self(2);
    /// Metal value `MTL::TessellationFactorStepFunction::TessellationFactorStepFunctionPerPatch`.
    pub const TessellationFactorStepFunctionPerPatch: Self = Self(1);
    /// Metal value `MTL::TessellationFactorStepFunction::TessellationFactorStepFunctionPerPatchAndPerInstance`.
    pub const TessellationFactorStepFunctionPerPatchAndPerInstance: Self = Self(3);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<usize> for TessellationFactorStepFunction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TessellationPartitionMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TessellationPartitionMode(usize);

impl TessellationPartitionMode {
    /// Metal value `MTL::TessellationPartitionMode::TessellationPartitionModeFractionalEven`.
    pub const TessellationPartitionModeFractionalEven: Self = Self(3);
    /// Metal value `MTL::TessellationPartitionMode::TessellationPartitionModeFractionalOdd`.
    pub const TessellationPartitionModeFractionalOdd: Self = Self(2);
    /// Metal value `MTL::TessellationPartitionMode::TessellationPartitionModeInteger`.
    pub const TessellationPartitionModeInteger: Self = Self(1);
    /// Metal value `MTL::TessellationPartitionMode::TessellationPartitionModePow2`.
    pub const TessellationPartitionModePow2: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<usize> for TessellationPartitionMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TextureCompressionType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TextureCompressionType(isize);

impl TextureCompressionType {
    /// Metal value `MTL::TextureCompressionType::TextureCompressionTypeLossless`.
    pub const TextureCompressionTypeLossless: Self = Self(0);
    /// Metal value `MTL::TextureCompressionType::TextureCompressionTypeLossy`.
    pub const TextureCompressionTypeLossy: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for TextureCompressionType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TextureSparseTier` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TextureSparseTier(isize);

impl TextureSparseTier {
    /// Metal value `MTL::TextureSparseTier::TextureSparseTier1`.
    pub const TextureSparseTier1: Self = Self(1);
    /// Metal value `MTL::TextureSparseTier::TextureSparseTier2`.
    pub const TextureSparseTier2: Self = Self(2);
    /// Metal value `MTL::TextureSparseTier::TextureSparseTierNone`.
    pub const TextureSparseTierNone: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<isize> for TextureSparseTier {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TextureSwizzle` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TextureSwizzle(u8);

impl TextureSwizzle {
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleAlpha`.
    pub const TextureSwizzleAlpha: Self = Self(5);
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleBlue`.
    pub const TextureSwizzleBlue: Self = Self(4);
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleGreen`.
    pub const TextureSwizzleGreen: Self = Self(3);
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleOne`.
    pub const TextureSwizzleOne: Self = Self(1);
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleRed`.
    pub const TextureSwizzleRed: Self = Self(2);
    /// Metal value `MTL::TextureSwizzle::TextureSwizzleZero`.
    pub const TextureSwizzleZero: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: u8) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> u8 {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=5)
    }
}

impl std::convert::TryFrom<u8> for TextureSwizzle {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TransformType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TransformType(isize);

impl TransformType {
    /// Metal value `MTL::TransformType::TransformTypeComponent`.
    pub const TransformTypeComponent: Self = Self(1);
    /// Metal value `MTL::TransformType::TransformTypePackedFloat4x3`.
    pub const TransformTypePackedFloat4x3: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for TransformType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::TriangleFillMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct TriangleFillMode(usize);

impl TriangleFillMode {
    /// Metal value `MTL::TriangleFillMode::TriangleFillModeFill`.
    pub const TriangleFillModeFill: Self = Self(0);
    /// Metal value `MTL::TriangleFillMode::TriangleFillModeLines`.
    pub const TriangleFillModeLines: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for TriangleFillMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::VertexFormat` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VertexFormat(usize);

impl VertexFormat {
    /// Metal value `MTL::VertexFormat::VertexFormatChar`.
    pub const VertexFormatChar: Self = Self(46);
    /// Metal value `MTL::VertexFormat::VertexFormatChar2`.
    pub const VertexFormatChar2: Self = Self(4);
    /// Metal value `MTL::VertexFormat::VertexFormatChar2Normalized`.
    pub const VertexFormatChar2Normalized: Self = Self(10);
    /// Metal value `MTL::VertexFormat::VertexFormatChar3`.
    pub const VertexFormatChar3: Self = Self(5);
    /// Metal value `MTL::VertexFormat::VertexFormatChar3Normalized`.
    pub const VertexFormatChar3Normalized: Self = Self(11);
    /// Metal value `MTL::VertexFormat::VertexFormatChar4`.
    pub const VertexFormatChar4: Self = Self(6);
    /// Metal value `MTL::VertexFormat::VertexFormatChar4Normalized`.
    pub const VertexFormatChar4Normalized: Self = Self(12);
    /// Metal value `MTL::VertexFormat::VertexFormatCharNormalized`.
    pub const VertexFormatCharNormalized: Self = Self(48);
    /// Metal value `MTL::VertexFormat::VertexFormatFloat`.
    pub const VertexFormatFloat: Self = Self(28);
    /// Metal value `MTL::VertexFormat::VertexFormatFloat2`.
    pub const VertexFormatFloat2: Self = Self(29);
    /// Metal value `MTL::VertexFormat::VertexFormatFloat3`.
    pub const VertexFormatFloat3: Self = Self(30);
    /// Metal value `MTL::VertexFormat::VertexFormatFloat4`.
    pub const VertexFormatFloat4: Self = Self(31);
    /// Metal value `MTL::VertexFormat::VertexFormatFloatRG11B10`.
    pub const VertexFormatFloatRG11B10: Self = Self(54);
    /// Metal value `MTL::VertexFormat::VertexFormatFloatRGB9E5`.
    pub const VertexFormatFloatRGB9E5: Self = Self(55);
    /// Metal value `MTL::VertexFormat::VertexFormatHalf`.
    pub const VertexFormatHalf: Self = Self(53);
    /// Metal value `MTL::VertexFormat::VertexFormatHalf2`.
    pub const VertexFormatHalf2: Self = Self(25);
    /// Metal value `MTL::VertexFormat::VertexFormatHalf3`.
    pub const VertexFormatHalf3: Self = Self(26);
    /// Metal value `MTL::VertexFormat::VertexFormatHalf4`.
    pub const VertexFormatHalf4: Self = Self(27);
    /// Metal value `MTL::VertexFormat::VertexFormatInt`.
    pub const VertexFormatInt: Self = Self(32);
    /// Metal value `MTL::VertexFormat::VertexFormatInt1010102Normalized`.
    pub const VertexFormatInt1010102Normalized: Self = Self(40);
    /// Metal value `MTL::VertexFormat::VertexFormatInt2`.
    pub const VertexFormatInt2: Self = Self(33);
    /// Metal value `MTL::VertexFormat::VertexFormatInt3`.
    pub const VertexFormatInt3: Self = Self(34);
    /// Metal value `MTL::VertexFormat::VertexFormatInt4`.
    pub const VertexFormatInt4: Self = Self(35);
    /// Metal value `MTL::VertexFormat::VertexFormatInvalid`.
    pub const VertexFormatInvalid: Self = Self(0);
    /// Metal value `MTL::VertexFormat::VertexFormatShort`.
    pub const VertexFormatShort: Self = Self(50);
    /// Metal value `MTL::VertexFormat::VertexFormatShort2`.
    pub const VertexFormatShort2: Self = Self(16);
    /// Metal value `MTL::VertexFormat::VertexFormatShort2Normalized`.
    pub const VertexFormatShort2Normalized: Self = Self(22);
    /// Metal value `MTL::VertexFormat::VertexFormatShort3`.
    pub const VertexFormatShort3: Self = Self(17);
    /// Metal value `MTL::VertexFormat::VertexFormatShort3Normalized`.
    pub const VertexFormatShort3Normalized: Self = Self(23);
    /// Metal value `MTL::VertexFormat::VertexFormatShort4`.
    pub const VertexFormatShort4: Self = Self(18);
    /// Metal value `MTL::VertexFormat::VertexFormatShort4Normalized`.
    pub const VertexFormatShort4Normalized: Self = Self(24);
    /// Metal value `MTL::VertexFormat::VertexFormatShortNormalized`.
    pub const VertexFormatShortNormalized: Self = Self(52);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar`.
    pub const VertexFormatUChar: Self = Self(45);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar2`.
    pub const VertexFormatUChar2: Self = Self(1);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar2Normalized`.
    pub const VertexFormatUChar2Normalized: Self = Self(7);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar3`.
    pub const VertexFormatUChar3: Self = Self(2);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar3Normalized`.
    pub const VertexFormatUChar3Normalized: Self = Self(8);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar4`.
    pub const VertexFormatUChar4: Self = Self(3);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar4Normalized`.
    pub const VertexFormatUChar4Normalized: Self = Self(9);
    /// Metal value `MTL::VertexFormat::VertexFormatUChar4Normalized_BGRA`.
    pub const VertexFormatUChar4Normalized_BGRA: Self = Self(42);
    /// Metal value `MTL::VertexFormat::VertexFormatUCharNormalized`.
    pub const VertexFormatUCharNormalized: Self = Self(47);
    /// Metal value `MTL::VertexFormat::VertexFormatUInt`.
    pub const VertexFormatUInt: Self = Self(36);
    /// Metal value `MTL::VertexFormat::VertexFormatUInt1010102Normalized`.
    pub const VertexFormatUInt1010102Normalized: Self = Self(41);
    /// Metal value `MTL::VertexFormat::VertexFormatUInt2`.
    pub const VertexFormatUInt2: Self = Self(37);
    /// Metal value `MTL::VertexFormat::VertexFormatUInt3`.
    pub const VertexFormatUInt3: Self = Self(38);
    /// Metal value `MTL::VertexFormat::VertexFormatUInt4`.
    pub const VertexFormatUInt4: Self = Self(39);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort`.
    pub const VertexFormatUShort: Self = Self(49);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort2`.
    pub const VertexFormatUShort2: Self = Self(13);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort2Normalized`.
    pub const VertexFormatUShort2Normalized: Self = Self(19);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort3`.
    pub const VertexFormatUShort3: Self = Self(14);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort3Normalized`.
    pub const VertexFormatUShort3Normalized: Self = Self(20);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort4`.
    pub const VertexFormatUShort4: Self = Self(15);
    /// Metal value `MTL::VertexFormat::VertexFormatUShort4Normalized`.
    pub const VertexFormatUShort4Normalized: Self = Self(21);
    /// Metal value `MTL::VertexFormat::VertexFormatUShortNormalized`.
    pub const VertexFormatUShortNormalized: Self = Self(51);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=42 | 45..=55)
    }
}

impl std::convert::TryFrom<usize> for VertexFormat {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::VertexStepFunction` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VertexStepFunction(usize);

impl VertexStepFunction {
    /// Metal value `MTL::VertexStepFunction::VertexStepFunctionConstant`.
    pub const VertexStepFunctionConstant: Self = Self(0);
    /// Metal value `MTL::VertexStepFunction::VertexStepFunctionPerInstance`.
    pub const VertexStepFunctionPerInstance: Self = Self(2);
    /// Metal value `MTL::VertexStepFunction::VertexStepFunctionPerPatch`.
    pub const VertexStepFunctionPerPatch: Self = Self(3);
    /// Metal value `MTL::VertexStepFunction::VertexStepFunctionPerPatchControlPoint`.
    pub const VertexStepFunctionPerPatchControlPoint: Self = Self(4);
    /// Metal value `MTL::VertexStepFunction::VertexStepFunctionPerVertex`.
    pub const VertexStepFunctionPerVertex: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=4)
    }
}

impl std::convert::TryFrom<usize> for VertexStepFunction {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::VisibilityResultMode` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VisibilityResultMode(usize);

impl VisibilityResultMode {
    /// Metal value `MTL::VisibilityResultMode::VisibilityResultModeBoolean`.
    pub const VisibilityResultModeBoolean: Self = Self(1);
    /// Metal value `MTL::VisibilityResultMode::VisibilityResultModeCounting`.
    pub const VisibilityResultModeCounting: Self = Self(2);
    /// Metal value `MTL::VisibilityResultMode::VisibilityResultModeDisabled`.
    pub const VisibilityResultModeDisabled: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=2)
    }
}

impl std::convert::TryFrom<usize> for VisibilityResultMode {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::VisibilityResultType` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct VisibilityResultType(isize);

impl VisibilityResultType {
    /// Metal value `MTL::VisibilityResultType::VisibilityResultTypeAccumulate`.
    pub const VisibilityResultTypeAccumulate: Self = Self(1);
    /// Metal value `MTL::VisibilityResultType::VisibilityResultTypeReset`.
    pub const VisibilityResultTypeReset: Self = Self(0);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<isize> for VisibilityResultType {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `MTL::Winding` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct Winding(usize);

impl Winding {
    /// Metal value `MTL::Winding::WindingClockwise`.
    pub const WindingClockwise: Self = Self(0);
    /// Metal value `MTL::Winding::WindingCounterClockwise`.
    pub const WindingCounterClockwise: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0 | 1)
    }
}

impl std::convert::TryFrom<usize> for Winding {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `NS::ActivityOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ActivityOptions(u64);

impl ActivityOptions {
    /// Metal value `NS::ActivityOptions::ActivityAutomaticTerminationDisabled`.
    pub const ActivityAutomaticTerminationDisabled: Self = Self(32768);
    /// Metal value `NS::ActivityOptions::ActivityBackground`.
    pub const ActivityBackground: Self = Self(255);
    /// Metal value `NS::ActivityOptions::ActivityIdleDisplaySleepDisabled`.
    pub const ActivityIdleDisplaySleepDisabled: Self = Self(1099511627776);
    /// Metal value `NS::ActivityOptions::ActivityIdleSystemSleepDisabled`.
    pub const ActivityIdleSystemSleepDisabled: Self = Self(1048576);
    /// Metal value `NS::ActivityOptions::ActivityLatencyCritical`.
    pub const ActivityLatencyCritical: Self = Self(1095216660480);
    /// Metal value `NS::ActivityOptions::ActivitySuddenTerminationDisabled`.
    pub const ActivitySuddenTerminationDisabled: Self = Self(16384);
    /// Metal value `NS::ActivityOptions::ActivityUserInitiated`.
    pub const ActivityUserInitiated: Self = Self(16777215);
    /// Metal value `NS::ActivityOptions::ActivityUserInitiatedAllowingIdleSystemSleep`.
    pub const ActivityUserInitiatedAllowingIdleSystemSleep: Self = Self(15728639);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: u64) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> u64 {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: u64 = 2194745065471;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: u64) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for ActivityOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for ActivityOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `NS::ComparisonResult` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ComparisonResult(isize);

impl ComparisonResult {
    /// Metal value `NS::ComparisonResult::OrderedAscending`.
    pub const OrderedAscending: Self = Self(-1);
    /// Metal value `NS::ComparisonResult::OrderedDescending`.
    pub const OrderedDescending: Self = Self(0);
    /// Metal value `NS::ComparisonResult::OrderedSame`.
    pub const OrderedSame: Self = Self(1);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, -1..=1)
    }
}

impl std::convert::TryFrom<isize> for ComparisonResult {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `NS::ProcessInfoThermalState` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct ProcessInfoThermalState(isize);

impl ProcessInfoThermalState {
    /// Metal value `NS::ProcessInfoThermalState::ProcessInfoThermalStateCritical`.
    pub const ProcessInfoThermalStateCritical: Self = Self(3);
    /// Metal value `NS::ProcessInfoThermalState::ProcessInfoThermalStateFair`.
    pub const ProcessInfoThermalStateFair: Self = Self(1);
    /// Metal value `NS::ProcessInfoThermalState::ProcessInfoThermalStateNominal`.
    pub const ProcessInfoThermalStateNominal: Self = Self(0);
    /// Metal value `NS::ProcessInfoThermalState::ProcessInfoThermalStateSerious`.
    pub const ProcessInfoThermalStateSerious: Self = Self(2);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: isize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> isize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(self.0, 0..=3)
    }
}

impl std::convert::TryFrom<isize> for ProcessInfoThermalState {
    type Error = ();

    fn try_from(value: isize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}

/// Safe scalar wrapper for the Metal `NS::StringCompareOptions` option set.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StringCompareOptions(usize);

impl StringCompareOptions {
    /// Metal value `NS::StringCompareOptions::AnchoredSearch`.
    pub const AnchoredSearch: Self = Self(8);
    /// Metal value `NS::StringCompareOptions::BackwardsSearch`.
    pub const BackwardsSearch: Self = Self(4);
    /// Metal value `NS::StringCompareOptions::CaseInsensitiveSearch`.
    pub const CaseInsensitiveSearch: Self = Self(1);
    /// Metal value `NS::StringCompareOptions::DiacriticInsensitiveSearch`.
    pub const DiacriticInsensitiveSearch: Self = Self(128);
    /// Metal value `NS::StringCompareOptions::ForcedOrderingSearch`.
    pub const ForcedOrderingSearch: Self = Self(512);
    /// Metal value `NS::StringCompareOptions::LiteralSearch`.
    pub const LiteralSearch: Self = Self(2);
    /// Metal value `NS::StringCompareOptions::NumericSearch`.
    pub const NumericSearch: Self = Self(64);
    /// Metal value `NS::StringCompareOptions::RegularExpressionSearch`.
    pub const RegularExpressionSearch: Self = Self(1024);
    /// Metal value `NS::StringCompareOptions::WidthInsensitiveSearch`.
    pub const WidthInsensitiveSearch: Self = Self(256);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        const VALID_BITS: usize = 1999;
        self.0 & !VALID_BITS == 0
    }

    /// Creates an option set when every bit is declared.
    #[must_use]
    pub const fn from_bits(value: usize) -> Option<Self> {
        let value = Self(value);
        if value.is_valid() { Some(value) } else { None }
    }
}

impl std::ops::BitOr for StringCompareOptions {
    type Output = Self;

    fn bitor(self, other: Self) -> Self {
        Self(self.0 | other.0)
    }
}

impl std::ops::BitAnd for StringCompareOptions {
    type Output = Self;

    fn bitand(self, other: Self) -> Self {
        Self(self.0 & other.0)
    }
}

/// Safe scalar wrapper for the Metal `NS::StringEncoding` enumeration.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct StringEncoding(usize);

impl StringEncoding {
    /// Metal value `NS::StringEncoding::ASCIIStringEncoding`.
    pub const ASCIIStringEncoding: Self = Self(1);
    /// Metal value `NS::StringEncoding::ISO2022JPStringEncoding`.
    pub const ISO2022JPStringEncoding: Self = Self(21);
    /// Metal value `NS::StringEncoding::ISOLatin1StringEncoding`.
    pub const ISOLatin1StringEncoding: Self = Self(5);
    /// Metal value `NS::StringEncoding::ISOLatin2StringEncoding`.
    pub const ISOLatin2StringEncoding: Self = Self(9);
    /// Metal value `NS::StringEncoding::JapaneseEUCStringEncoding`.
    pub const JapaneseEUCStringEncoding: Self = Self(3);
    /// Metal value `NS::StringEncoding::MacOSRomanStringEncoding`.
    pub const MacOSRomanStringEncoding: Self = Self(30);
    /// Metal value `NS::StringEncoding::NEXTSTEPStringEncoding`.
    pub const NEXTSTEPStringEncoding: Self = Self(2);
    /// Metal value `NS::StringEncoding::NonLossyASCIIStringEncoding`.
    pub const NonLossyASCIIStringEncoding: Self = Self(7);
    /// Metal value `NS::StringEncoding::ShiftJISStringEncoding`.
    pub const ShiftJISStringEncoding: Self = Self(8);
    /// Metal value `NS::StringEncoding::SymbolStringEncoding`.
    pub const SymbolStringEncoding: Self = Self(6);
    /// Metal value `NS::StringEncoding::UTF16BigEndianStringEncoding`.
    pub const UTF16BigEndianStringEncoding: Self = Self(2415919360);
    /// Metal value `NS::StringEncoding::UTF16LittleEndianStringEncoding`.
    pub const UTF16LittleEndianStringEncoding: Self = Self(2483028224);
    /// Metal value `NS::StringEncoding::UTF16StringEncoding`.
    pub const UTF16StringEncoding: Self = Self(10);
    /// Metal value `NS::StringEncoding::UTF32BigEndianStringEncoding`.
    pub const UTF32BigEndianStringEncoding: Self = Self(2550137088);
    /// Metal value `NS::StringEncoding::UTF32LittleEndianStringEncoding`.
    pub const UTF32LittleEndianStringEncoding: Self = Self(2617245952);
    /// Metal value `NS::StringEncoding::UTF32StringEncoding`.
    pub const UTF32StringEncoding: Self = Self(2348810496);
    /// Metal value `NS::StringEncoding::UTF8StringEncoding`.
    pub const UTF8StringEncoding: Self = Self(4);
    /// Metal value `NS::StringEncoding::UnicodeStringEncoding`.
    pub const UnicodeStringEncoding: Self = Self(10);
    /// Metal value `NS::StringEncoding::WindowsCP1250StringEncoding`.
    pub const WindowsCP1250StringEncoding: Self = Self(15);
    /// Metal value `NS::StringEncoding::WindowsCP1251StringEncoding`.
    pub const WindowsCP1251StringEncoding: Self = Self(11);
    /// Metal value `NS::StringEncoding::WindowsCP1252StringEncoding`.
    pub const WindowsCP1252StringEncoding: Self = Self(12);
    /// Metal value `NS::StringEncoding::WindowsCP1253StringEncoding`.
    pub const WindowsCP1253StringEncoding: Self = Self(13);
    /// Metal value `NS::StringEncoding::WindowsCP1254StringEncoding`.
    pub const WindowsCP1254StringEncoding: Self = Self(14);

    /// Preserves a raw value returned by the framework.
    pub(crate) const fn from_system_raw(value: usize) -> Self {
        Self(value)
    }

    /// Returns the framework's integer representation.
    #[must_use]
    pub const fn as_raw(self) -> usize {
        self.0
    }

    /// Returns whether this is a declared value or valid option-bit combination.
    #[must_use]
    pub const fn is_valid(self) -> bool {
        matches!(
            self.0,
            1..=15 | 21 | 30 | 2348810496 | 2415919360 | 2483028224 | 2550137088 | 2617245952
        )
    }
}

impl std::convert::TryFrom<usize> for StringEncoding {
    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {
        let value = Self(value);
        if value.is_valid() { Ok(value) } else { Err(()) }
    }
}