//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use objc2::rc::{Allocated, Retained};
use objc2::runtime::ProtocolObject;
use objc2::{extern_class, extern_conformance, extern_methods, extern_protocol};
use objc2_foundation::{
    CopyingHelper, NSArray, NSCopying, NSError, NSObject, NSObjectProtocol, NSString, NSURL,
};

use crate::*;

/// Completion block signatures matching Metal APIs
pub type MTLNewLibraryCompletionHandler =
    *mut block2::DynBlock<dyn Fn(*mut ProtocolObject<dyn MTLLibrary>, *mut NSError)>;
pub type MTLNewDynamicLibraryCompletionHandler = *mut block2::DynBlock<
    dyn Fn(*mut ProtocolObject<dyn crate::dynamic_library::MTLDynamicLibrary>, *mut NSError),
>;
pub type MTLNewComputePipelineStateCompletionHandler = *mut block2::DynBlock<
    dyn Fn(*mut ProtocolObject<dyn crate::compute_pipeline::MTLComputePipelineState>, *mut NSError),
>;
pub type MTLNewRenderPipelineStateCompletionHandler = *mut block2::DynBlock<
    dyn Fn(*mut ProtocolObject<dyn crate::render_pipeline::MTLRenderPipelineState>, *mut NSError),
>;

extern_class!(
    /// Groups together properties for creating a compiler context.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4compilerdescriptor?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MTL4CompilerDescriptor;
);

extern_conformance!(
    unsafe impl NSCopying for MTL4CompilerDescriptor {}
);

unsafe impl CopyingHelper for MTL4CompilerDescriptor {
    type Result = Self;
}

extern_conformance!(
    unsafe impl NSObjectProtocol for MTL4CompilerDescriptor {}
);

impl MTL4CompilerDescriptor {
    extern_methods!(
        /// Assigns an optional descriptor label to the compiler for debugging purposes.
        #[unsafe(method(label))]
        #[unsafe(method_family = none)]
        pub fn label(&self) -> Option<Retained<NSString>>;

        /// Setter for [`label`][Self::label].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setLabel:))]
        #[unsafe(method_family = none)]
        pub fn set_label(&self, label: Option<&NSString>);

        /// Assigns a pipeline data set serializer into which this compiler stores data for all pipelines it creates.
        #[unsafe(method(pipelineDataSetSerializer))]
        #[unsafe(method_family = none)]
        pub fn pipeline_data_set_serializer(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn MTL4PipelineDataSetSerializer>>>;

        /// Setter for [`pipelineDataSetSerializer`][Self::pipelineDataSetSerializer].
        #[unsafe(method(setPipelineDataSetSerializer:))]
        #[unsafe(method_family = none)]
        pub fn set_pipeline_data_set_serializer(
            &self,
            pipeline_data_set_serializer: Option<
                &ProtocolObject<dyn MTL4PipelineDataSetSerializer>,
            >,
        );
    );
}

/// Methods declared on superclass `NSObject`.
impl MTL4CompilerDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4compilertaskoptions?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MTL4CompilerTaskOptions;
);

extern_conformance!(
    unsafe impl NSCopying for MTL4CompilerTaskOptions {}
);

unsafe impl CopyingHelper for MTL4CompilerTaskOptions {
    type Result = Self;
}

extern_conformance!(
    unsafe impl NSObjectProtocol for MTL4CompilerTaskOptions {}
);

impl MTL4CompilerTaskOptions {
    extern_methods!(
        /// Specifies a set of archive instances this compilation process uses for accelerating the build process.
        ///
        /// In case of a match in the archive, the compiler can skip one or more compilation tasks, speeding up the build process.
        #[unsafe(method(lookupArchives))]
        #[unsafe(method_family = none)]
        pub fn lookup_archives(
            &self,
        ) -> Option<Retained<NSArray<ProtocolObject<dyn MTL4Archive>>>>;

        /// Setter for [`lookupArchives`][Self::lookupArchives].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setLookupArchives:))]
        #[unsafe(method_family = none)]
        pub fn set_lookup_archives(
            &self,
            lookup_archives: Option<&NSArray<ProtocolObject<dyn MTL4Archive>>>,
        );
    );
}

/// Methods declared on superclass `NSObject`.
impl MTL4CompilerTaskOptions {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub fn new() -> Retained<Self>;
    );
}

/// Provides a signature for a callback block that Metal calls when the compiler finishes a build task for a binary function.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4newbinaryfunctioncompletionhandler?language=objc)
pub type MTL4NewBinaryFunctionCompletionHandler =
    *mut block2::DynBlock<dyn Fn(*mut ProtocolObject<dyn MTL4BinaryFunction>, *mut NSError)>;

/// Provides a signature for a callback block that Metal calls when the compiler finishes a build task for a machine learning pipeline state.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4newmachinelearningpipelinestatecompletionhandler?language=objc)
pub type MTL4NewMachineLearningPipelineStateCompletionHandler = *mut block2::DynBlock<
    dyn Fn(*mut ProtocolObject<dyn MTL4MachineLearningPipelineState>, *mut NSError),
>;

extern_protocol!(
    /// A abstraction for a pipeline state and shader function compiler.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metal/mtl4compiler?language=objc)
    pub unsafe trait MTL4Compiler: NSObjectProtocol + Send + Sync {
        /// Returns the device that this compiler belongs to.
        #[unsafe(method(device))]
        #[unsafe(method_family = none)]
        fn device(&self) -> Retained<ProtocolObject<dyn MTLDevice>>;

        /// Returns the optional label you specify at creation time.
        #[unsafe(method(label))]
        #[unsafe(method_family = none)]
        fn label(&self) -> Option<Retained<NSString>>;

        /// Returns the pipeline data set serializer into which this compiler stores data for all pipelines it creates.
        #[unsafe(method(pipelineDataSetSerializer))]
        #[unsafe(method_family = none)]
        fn pipeline_data_set_serializer(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn MTL4PipelineDataSetSerializer>>>;

        /// Creates a new Metal library synchronously.
        ///
        /// - Parameters:
        /// - descriptor: A description of the library to create.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: a Metal library instance upon success, `nil` otherwise.
        #[unsafe(method(newLibraryWithDescriptor:error:_))]
        #[unsafe(method_family = new)]
        fn new_library_with_descriptor_error(
            &self,
            descriptor: &MTL4LibraryDescriptor,
        ) -> Result<Retained<ProtocolObject<dyn MTLLibrary>>, Retained<NSError>>;

        /// Creates a new dynamic library from a library containing Metal IR code synchronously.
        ///
        /// - Parameters:
        /// - library: A library from which this compiler creates the new a dynamic library
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new dynamic Metal library upon success, `nil` otherwise.
        #[unsafe(method(newDynamicLibrary:error:_))]
        #[unsafe(method_family = new)]
        fn new_dynamic_library_error(
            &self,
            library: &ProtocolObject<dyn MTLLibrary>,
        ) -> Result<Retained<ProtocolObject<dyn MTLDynamicLibrary>>, Retained<NSError>>;

        /// Creates a new dynamic library from the contents of a file at an URL location synchronously.
        ///
        /// - Parameters:
        /// - url: An URL referencing a file whose contents this compiler uses to build a dynamic library.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new dynamic Metal library upon success, `nil` otherwise.
        #[unsafe(method(newDynamicLibraryWithURL:error:_))]
        #[unsafe(method_family = new)]
        fn new_dynamic_library_with_url_error(
            &self,
            url: &NSURL,
        ) -> Result<Retained<ProtocolObject<dyn MTLDynamicLibrary>>, Retained<NSError>>;

        /// Creates a new compute pipeline state object synchronously.
        ///
        /// - Parameters:
        /// - descriptor: A compute pipeline state descriptor describing the pipeline this compiler creates.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new compute pipeline state object upon success, `nil` otherwise.
        #[unsafe(method(newComputePipelineStateWithDescriptor:compilerTaskOptions:error:_))]
        #[unsafe(method_family = new)]
        fn new_compute_pipeline_state_with_descriptor_compiler_task_options_error(
            &self,
            descriptor: &MTL4ComputePipelineDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
        ) -> Result<Retained<ProtocolObject<dyn MTLComputePipelineState>>, Retained<NSError>>;

        /// Creates a new compute pipeline state synchronously.
        ///
        /// - Parameters:
        /// - descriptor: A compute pipeline state descriptor describing the pipeline this compiler creates.
        /// - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new compute pipeline state object upon success, `nil` otherwise.
        #[unsafe(method(newComputePipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:error:_))]
        #[unsafe(method_family = new)]
        fn new_compute_pipeline_state_with_descriptor_dynamic_linking_descriptor_compiler_task_options_error(
            &self,
            descriptor: &MTL4ComputePipelineDescriptor,
            dynamic_linking_descriptor: Option<&MTL4PipelineStageDynamicLinkingDescriptor>,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
        ) -> Result<Retained<ProtocolObject<dyn MTLComputePipelineState>>, Retained<NSError>>;

        /// Creates a new render pipeline state synchronously.
        ///
        /// Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states.
        /// The type of the descriptor you pass indicates the pipeline type this method builds.
        ///
        /// Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error.
        ///
        /// - Parameters:
        /// - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new render pipeline state object upon success, `nil` otherwise.
        #[unsafe(method(newRenderPipelineStateWithDescriptor:compilerTaskOptions:error:_))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_with_descriptor_compiler_task_options_error(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
        ) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>, Retained<NSError>>;

        /// Creates a new render pipeline state synchronously.
        ///
        /// Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states.
        /// The type of the descriptor you pass indicates the pipeline type this method builds.
        ///
        /// Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error.
        ///
        /// - Parameters:
        /// - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create.
        /// - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A new render pipeline state object upon success, `nil` otherwise.
        #[unsafe(method(newRenderPipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:error:_))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_with_descriptor_dynamic_linking_descriptor_compiler_task_options_error(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            dynamic_linking_descriptor: Option<&MTL4RenderPipelineDynamicLinkingDescriptor>,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
        ) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>, Retained<NSError>>;

        /// Creates a new render pipeline state from another, previously unspecialized, pipeline state.
        ///
        /// Metal specializes the pipeline state with new state values the descriptor provides, observing the following rules:
        /// * The compiler only updates properties that were originally specified as *unspecialized*. It doesn't modify other
        /// already-specialized properties
        /// * The compiler sets to their default behavior any unspecialized properties that your passed-in descriptor doesn't specialize
        ///
        /// Additionally, there are some cases where the Metal can't specialize a pipeline:
        /// * If the original pipeline state object doesn't have any unspecialized properties
        /// * You can't re-specialize a previously specialized pipeline state object
        ///
        /// - Parameters:
        /// - descriptor: A render pipeline state descriptor or any type: default, tile, or mesh render pipeline descriptor.
        /// - pipeline: A render pipeline state containing unspecialized substate.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: a fully-specialized pipeline state object.
        #[unsafe(method(newRenderPipelineStateBySpecializationWithDescriptor:pipeline:error:_))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_by_specialization_with_descriptor_pipeline_error(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            pipeline: &ProtocolObject<dyn MTLRenderPipelineState>,
        ) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>, Retained<NSError>>;

        /// Creates a new binary visible or intersection function synchronously.
        ///
        /// - Parameters:
        /// - descriptor: A binary function descriptor to use for creating the binary function.
        /// - compilerTaskOptions: A descriptor of the compilation itself, providing parameters that
        /// influence execution of the compilation process.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: a new binary function upon success, `nil` otherwise.
        #[unsafe(method(newBinaryFunctionWithDescriptor:compilerTaskOptions:error:_))]
        #[unsafe(method_family = new)]
        fn new_binary_function_with_descriptor_compiler_task_options_error(
            &self,
            descriptor: &MTL4BinaryFunctionDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
        ) -> Result<Retained<ProtocolObject<dyn MTL4BinaryFunction>>, Retained<NSError>>;

        /// Creates a new Metal library instance asynchronously.
        ///
        /// - Parameters:
        /// - descriptor: A description of the library to create.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newLibraryWithDescriptor:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_library_with_descriptor_completion_handler(
            &self,
            descriptor: &MTL4LibraryDescriptor,
            completion_handler: MTLNewLibraryCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new dynamic Metal library instance asynchronously.
        ///
        /// - Parameters:
        /// - library: A library from which this compiler creates the new a dynamic library
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: A compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newDynamicLibrary:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_dynamic_library_completion_handler(
            &self,
            library: &ProtocolObject<dyn MTLLibrary>,
            completion_handler: MTLNewDynamicLibraryCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new dynamic library from the contents of a file at an URL location synchronously.
        ///
        /// - Parameters:
        /// - url: An URL referencing a file whose contents this compiler uses to build a dynamic library.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newDynamicLibraryWithURL:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_dynamic_library_with_url_completion_handler(
            &self,
            url: &NSURL,
            completion_handler: MTLNewDynamicLibraryCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new compute pipeline state asynchronously.
        ///
        /// - Parameters:
        /// - descriptor: A compute pipeline state descriptor, describing the compute pipeline to create.
        /// - compilerTaskOptions: A descriptor of the compilation itself, providing parameters that
        /// influence execution of the compilation process.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newComputePipelineStateWithDescriptor:compilerTaskOptions:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_compute_pipeline_state_with_descriptor_compiler_task_options_completion_handler(
            &self,
            descriptor: &MTL4ComputePipelineDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
            completion_handler: MTLNewComputePipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new compute pipeline state asynchronously.
        ///
        /// - Parameters:
        /// - descriptor: A compute pipeline state descriptor, describing the compute pipeline to create.
        /// - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newComputePipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_compute_pipeline_state_with_descriptor_dynamic_linking_descriptor_compiler_task_options_completion_handler(
            &self,
            descriptor: &MTL4ComputePipelineDescriptor,
            dynamic_linking_descriptor: Option<&MTL4PipelineStageDynamicLinkingDescriptor>,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
            completion_handler: MTLNewComputePipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new render pipeline state asynchronously.
        ///
        /// Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states.
        /// The type of the descriptor you pass indicates the pipeline type this method builds.
        ///
        /// Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error.
        ///
        /// - Parameters:
        /// - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newRenderPipelineStateWithDescriptor:compilerTaskOptions:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_with_descriptor_compiler_task_options_completion_handler(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
            completion_handler: MTLNewRenderPipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new render pipeline state asynchronously.
        ///
        /// Use this method to build any render pipeline type, including render, tile, and mesh render pipeline states.
        /// The type of the descriptor you pass indicates the pipeline type this method builds.
        ///
        /// Passing in a compute pipeline descriptor to the `descriptor` parameter produces an error.
        ///
        /// - Parameters:
        /// - descriptor: A render, tile, or mesh pipeline state descriptor that describes the pipeline to create.
        /// - dynamicLinkingDescriptor: An optional parameter that provides additional configuration for linking the pipeline state object.
        /// - compilerTaskOptions: A description of the compilation process itself, providing parameters that
        /// influence execution of the compilation process.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newRenderPipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_with_descriptor_dynamic_linking_descriptor_compiler_task_options_completion_handler(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            dynamic_linking_descriptor: Option<&MTL4RenderPipelineDynamicLinkingDescriptor>,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
            completion_handler: MTLNewRenderPipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new render pipeline state from another, previously unspecialized, pipeline state
        ///
        /// Metal specializes the pipeline state with new state values the descriptor provides, observing the following rules:
        /// * The compiler only updates properties that were originally specified as *unspecialized*. It doesn't modify other
        /// already-specialized properties
        /// * The compiler sets to their default behavior any unspecialized properties that your passed-in descriptor doesn't specialize
        ///
        /// Additionally, there are some cases where the Metal can't specialize a pipeline:
        /// * If the original pipeline state object doesn't have any unspecialized properties
        /// * You can't re-specialize a previosuly specialized pipeline state object
        ///
        /// - Parameters:
        /// - descriptor: A render pipeline state descriptor or any type: default, tile, or mesh render pipeline descriptor.
        /// - pipeline: A render pipeline state containing unspecialized substate.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newRenderPipelineStateBySpecializationWithDescriptor:pipeline:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_render_pipeline_state_by_specialization_with_descriptor_pipeline_completion_handler(
            &self,
            descriptor: &MTL4PipelineDescriptor,
            pipeline: &ProtocolObject<dyn MTLRenderPipelineState>,
            completion_handler: MTLNewRenderPipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new binary visible/intersection function asynchronously.
        /// - Parameters:
        /// - descriptor: a binary function descriptor used to create the binary function.
        /// - compilerTaskOptions: a descriptor of the compilation itself, providing parameters to
        /// influence execution of this compilation, but not the resulting object.
        /// - completionHandler: a callback used on task completion.
        /// - Returns: a compiler task indicating the asynchronous compilation job.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newBinaryFunctionWithDescriptor:compilerTaskOptions:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_binary_function_with_descriptor_compiler_task_options_completion_handler(
            &self,
            descriptor: &MTL4BinaryFunctionDescriptor,
            compiler_task_options: Option<&MTL4CompilerTaskOptions>,
            completion_handler: MTL4NewBinaryFunctionCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;

        /// Creates a new ML pipeline state with descriptor.
        ///
        /// - Parameters:
        /// - descriptor: A machine learning pipeline state descriptor to use for creating the new pipeline state.
        /// - error: An optional parameter into which Metal stores information in case of an error.
        ///
        /// - Returns: A machine learning pipeline state if operation is successful, otherwise `nil`.
        #[unsafe(method(newMachineLearningPipelineStateWithDescriptor:error:_))]
        #[unsafe(method_family = new)]
        fn new_machine_learning_pipeline_state_with_descriptor_error(
            &self,
            descriptor: &MTL4MachineLearningPipelineDescriptor,
        ) -> Result<Retained<ProtocolObject<dyn MTL4MachineLearningPipelineState>>, Retained<NSError>>;

        /// Creates a new machine learning pipeline state asynchronously.
        ///
        /// - Parameters:
        /// - descriptor: A machine learning pipeline state descriptor to use for creating the new pipeline state.
        /// - completionHandler: A block Metal calls when it finishes the build task.
        ///
        /// - Returns: a compiler task representing the asynchronous compilation task.
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(newMachineLearningPipelineStateWithDescriptor:completionHandler:))]
        #[unsafe(method_family = new)]
        fn new_machine_learning_pipeline_state_with_descriptor_completion_handler(
            &self,
            descriptor: &MTL4MachineLearningPipelineDescriptor,
            completion_handler: MTL4NewMachineLearningPipelineStateCompletionHandler,
        ) -> Retained<ProtocolObject<dyn MTL4CompilerTask>>;
    }
);
