objc2_metal_performance_shaders/generated/MPSNeuralNetwork/

MPSNNGraphNodes.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;
use objc2_metal::*;

use crate::*;

extern_protocol!(
    /// MPS resource identification
    ///
    /// Most of the time, there is only one image and one or fewer states needed as
    /// input to a graph, so the order of the images and states passed to
    /// [MPSNNGraph encodeToCommandBuffer:sourceImages:] or
    /// [MPSNNGraph encodeToCommandBuffer:sourceImages:sourceStates:intermediateImages:destinationStates:]
    /// is clear. There is only one order. However, sometimes graphs have more than one
    /// input image or state. What order should they appear in the NSArray passed to
    /// these methods?
    ///
    /// Each MPSNNImageNode or MPSNNStateNode can be tagged with a MPSHandle. MPSNNGraph
    /// keeps track of these. You can request that the MPSNNGraph return them to you in
    /// an array in the same order as needed to encode the MPSNNGraph, using
    /// MPSNNGraph.sourceImageHandles and MPSNNGraph.sourceStateHandles.
    ///
    /// Example:
    ///
    /// ```text
    ///               @interface MyHandle : NSObject <MPSHandle>
    ///                   // Add a method for my use to get the image needed based on the handle to it.
    ///                   // This isn't part of the MPSHandle protocol, but we need it for MyEncodeGraph
    ///                   // below. Since it is my code calling my object, we can add whatever we want like this.
    ///                   -(MPSImage*__nonnull) image;    // return the MPSImage corresponding to the handle
    ///
    ///                   // required by MPSHandle protocol
    ///                   -(NSString * __nullable) label;
    ///
    ///                   // MPSHandle implies NSSecureCoding too
    ///                   +(BOOL) supportsSecureCoding;
    ///                   - (void)encodeWithCoder:(NSCoder * __nonnull )aCoder;
    ///                   - (nullable instancetype)initWithCoder:(NSCoder * __nonnull )aDecoder; // NS_DESIGNATED_INITIALIZER
    ///               @end
    ///
    ///               // Encode a graph to cmdBuf using handles for images
    ///               // Here we assume that the MPSNNImageNodes that are graph inputs (not produced
    ///               // by the graph) are tagged with a unique instance of MyHandle that can be used
    ///               // to get the appropriate image for that node.
    ///               static void MyEncodeGraph( MPSNNGraph * graph, id <MTLCommandBuffer> cmdBuf )
    ///               {
    ///                   @autoreleasepool{
    ///                       // prepare an array of source images, using the handles
    ///                       NSArray<MyHandle*> * handles = graph.sourceImageHandles;
    ///                       unsigned long count = handles.count;
    ///                       NSMutableArray<MPSImage*> * __nonnull images = [NSMutableArray arrayWithCapacity: count];
    ///                       for( unsigned long i = 0; i < count; i++ )
    ///                           images[i] = handles[i].image;
    ///
    ///                       // encode the graph using the array
    ///                       [ graph encodeToCommandBuffer: cmdBuf
    ///                                        sourceImages: images ];
    ///                   }
    ///               }
    /// ```
    ///
    /// But what is a handle?  Here MPS is giving you enough rope with which to hang
    /// yourself. Don't panic! As long as your response is not to start tying nooses,
    /// you should be fine. It is just rope. More precisely, it is just a pointer to a
    /// NSObject. MPS doesn't know or care what it is or does, so long as it conforms
    /// to the MPSHandle protocol. What it does is entirely up to you. We imagine it
    /// will be an object that describes the data that you intend to pass later to the graph.
    /// It could be a file reference, or an input to your own software component that wraps
    /// the graph or even the MPSImage / MPSState that you plan to use.
    ///
    /// Do take note of the NSSecureCoding requirement in the MPSHandle protocol, however.
    /// This is needed if you attempt to use NSSecureCoding to serialize the MPSNNGraph.
    /// Normal MPSImages and MPSStates don't do that part.
    ///
    /// Your application should be able to use the handle to locate / create the correct
    /// image / state or batch thereof to pass as input to the graph.  Handles are also
    /// used to disambiguate graph intermediate images and state outputs. They aren't used
    /// to disambiguate image results (see -[MPSNNGraph initWithDevice:resultImages:resultsAreNeeded:]
    /// as you should already know the ordering of outputs there. It is the same as what
    /// you asked for.
    ///
    /// Do take note of the NSSecureCoding requirement in the MPSHandle protocol, however.
    /// This is needed if you attempt to use NSSecureCoding to serialize the MPSNNGraph.
    /// Normal MPSImages and MPSStates don't do that part.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpshandle?language=objc)
    pub unsafe trait MPSHandle: NSSecureCoding + NSObjectProtocol {
        /// A label to be attached to associated MTLResources for this node
        ///
        /// Returns: A human readable string for debugging purposes
        #[unsafe(method(label))]
        #[unsafe(method_family = none)]
        unsafe fn label(&self) -> Option<Retained<NSString>>;
    }
);

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnntrainablenode?language=objc)
    pub unsafe trait MPSNNTrainableNode: NSObjectProtocol {
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Configure whether and when neural network training parameters are updated
        ///
        /// Default: MPSNNTrainingStyleUpdateDeviceGPU
        #[unsafe(method(trainingStyle))]
        #[unsafe(method_family = none)]
        unsafe fn trainingStyle(&self) -> MPSNNTrainingStyle;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`trainingStyle`][Self::trainingStyle].
        #[unsafe(method(setTrainingStyle:))]
        #[unsafe(method_family = none)]
        unsafe fn setTrainingStyle(&self, training_style: MPSNNTrainingStyle);
    }
);

extern_class!(
    /// A placeholder node denoting the position of a MPSImage in a graph
    ///
    /// MPS neural network graphs are made up of filter nodes connected by
    /// image (or state) nodes. An image node is produced by one filter but
    /// may be consumed by more than one filter.
    ///
    /// Most image nodes will be created by MPS and made available through
    /// MPSNNFilterNode.resultImage. Image nodes that are not created by MPS
    /// (i.e. "the graph inputs") must be created by you.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnimagenode?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNImageNode;
);

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

impl MPSNNImageNode {
    extern_methods!(
        /// # Safety
        ///
        /// `handle` must implement MPSHandle.
        #[unsafe(method(initWithHandle:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithHandle(
            this: Allocated<Self>,
            handle: Option<&NSObject>,
        ) -> Retained<Self>;

        /// # Safety
        ///
        /// `handle` must implement MPSHandle.
        #[unsafe(method(nodeWithHandle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithHandle(handle: Option<&NSObject>) -> Retained<Self>;

        /// Create a autoreleased MPSNNImageNode with exportFromGraph = YES.
        ///
        /// Note: image is still temporary. See MPSNNImageNode.imageAllocator parameter.
        ///
        /// # Safety
        ///
        /// `handle` must implement MPSHandle.
        #[unsafe(method(exportedNodeWithHandle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn exportedNodeWithHandle(handle: Option<&NSObject>) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        /// MPS resource identifier
        ///
        /// See MPSHandle protocol description.  Default: nil
        #[unsafe(method(handle))]
        #[unsafe(method_family = none)]
        pub unsafe fn handle(&self) -> Option<Retained<ProtocolObject<dyn MPSHandle>>>;

        /// Setter for [`handle`][Self::handle].
        #[unsafe(method(setHandle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setHandle(&self, handle: Option<&ProtocolObject<dyn MPSHandle>>);

        #[cfg(all(feature = "MPSCore", feature = "MPSCoreTypes"))]
        /// The preferred precision for the image
        ///
        /// Default: MPSImageFeatureChannelFormatNone, meaning MPS should pick a format
        /// Typically, this is 16-bit floating-point.
        #[unsafe(method(format))]
        #[unsafe(method_family = none)]
        pub unsafe fn format(&self) -> MPSImageFeatureChannelFormat;

        #[cfg(all(feature = "MPSCore", feature = "MPSCoreTypes"))]
        /// Setter for [`format`][Self::format].
        #[unsafe(method(setFormat:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFormat(&self, format: MPSImageFeatureChannelFormat);

        #[cfg(all(feature = "MPSCore", feature = "MPSImage"))]
        /// Configurability for image allocation
        ///
        /// Allows you to influence how the image is allocated
        /// Default: MPSTemporaryImage.defaultAllocator
        #[unsafe(method(imageAllocator))]
        #[unsafe(method_family = none)]
        pub unsafe fn imageAllocator(&self) -> Retained<ProtocolObject<dyn MPSImageAllocator>>;

        #[cfg(all(feature = "MPSCore", feature = "MPSImage"))]
        /// Setter for [`imageAllocator`][Self::imageAllocator].
        #[unsafe(method(setImageAllocator:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setImageAllocator(
            &self,
            image_allocator: &ProtocolObject<dyn MPSImageAllocator>,
        );

        /// Tag a image node for view later
        ///
        /// Most image nodes are private to the graph. These alias memory heavily and
        /// consequently generally have invalid state when the graph exits.  When
        /// exportFromGraph = YES, the image is preserved and made available through
        /// the [MPSNNGraph encode... intermediateImages:... list.
        ///
        /// CAUTION: exporting an image from a graph prevents MPS from
        /// recycling memory. It will nearly always cause the
        /// amount of memory used by the graph to increase by the size
        /// of the image. There will probably be a performance
        /// regression accordingly.  This feature should generally
        /// be used only when the node is needed as an input for
        /// further work and recomputing it is prohibitively costly.
        ///
        /// Default: NO
        #[unsafe(method(exportFromGraph))]
        #[unsafe(method_family = none)]
        pub unsafe fn exportFromGraph(&self) -> bool;

        /// Setter for [`exportFromGraph`][Self::exportFromGraph].
        #[unsafe(method(setExportFromGraph:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setExportFromGraph(&self, export_from_graph: bool);

        /// Set to true to cause the resource to be synchronized with the CPU
        ///
        /// It is not needed on iOS/tvOS devices, where it does nothing.
        #[unsafe(method(synchronizeResource))]
        #[unsafe(method_family = none)]
        pub unsafe fn synchronizeResource(&self) -> bool;

        /// Setter for [`synchronizeResource`][Self::synchronizeResource].
        #[unsafe(method(setSynchronizeResource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSynchronizeResource(&self, synchronize_resource: bool);

        /// Stop training graph automatic creation at this node.
        ///
        /// An inference graph of MPSNNFilterNodes, MPSNNStateNodes and MPSNNImageNodes can be automatically
        /// converted to a training graph using -[MPSNNFilterNode trainingGraphWithSourceGradient:nodeHandler:].
        /// Sometimes, an inference graph may contain extra nodes at start to do operations like resampling or range
        /// adjustment that should not be part of the training graph. To prevent gradient operations for these extra
        /// nodes from being included in the training graph, set
        /// <undesired
        /// node>.resultImage.stopGradient = YES.
        /// This will prevent gradient propagation beyond this MPSNNImageNode.
        /// Default: NO
        #[unsafe(method(stopGradient))]
        #[unsafe(method_family = none)]
        pub unsafe fn stopGradient(&self) -> bool;

        /// Setter for [`stopGradient`][Self::stopGradient].
        #[unsafe(method(setStopGradient:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setStopGradient(&self, stop_gradient: bool);
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSNNImageNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A placeholder node denoting the position in the graph of a MPSState object
    ///
    /// Some filters need additional information about an image in order to function. For example
    /// a max-pooling gradient filter needs to know which position the max result came from in the
    /// original pooling filter in order to select the right data for gradient computation.  In other cases,
    /// state may be moved into a MPSState object in order to keep the filter itself immutable.
    /// The MPSState object typically encapsulates one or more MTLResource objects.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnstatenode?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNStateNode;
);

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

impl MPSNNStateNode {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        /// MPS resource identification
        ///
        /// See MPSHandle protocol reference.  Default: nil
        #[unsafe(method(handle))]
        #[unsafe(method_family = none)]
        pub unsafe fn handle(&self) -> Option<Retained<ProtocolObject<dyn MPSHandle>>>;

        /// Setter for [`handle`][Self::handle].
        #[unsafe(method(setHandle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setHandle(&self, handle: Option<&ProtocolObject<dyn MPSHandle>>);

        /// Tag a state node for view later
        ///
        /// Most state nodes are private to the graph. These alias memory heavily and
        /// consequently generally have invalid state when the graph exits.  When
        /// exportFromGraph = YES, the image is preserved and made available through
        /// the [MPSNNGraph encode... resultStates:... list.
        ///
        /// CAUTION: exporting an state from a graph prevents MPS from
        /// recycling memory. It will nearly always cause the
        /// amount of memory used by the graph to increase by the size
        /// of the state. There will probably be a performance
        /// regression accordingly.  This feature should generally
        /// be used only when the node is needed as an input for
        /// further work and recomputing it is prohibitively costly.
        ///
        /// Default: NO
        #[unsafe(method(exportFromGraph))]
        #[unsafe(method_family = none)]
        pub unsafe fn exportFromGraph(&self) -> bool;

        /// Setter for [`exportFromGraph`][Self::exportFromGraph].
        #[unsafe(method(setExportFromGraph:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setExportFromGraph(&self, export_from_graph: bool);

        /// Set to true to cause the resource to be synchronized with the CPU
        ///
        /// Ignored on non-MacOS.
        #[unsafe(method(synchronizeResource))]
        #[unsafe(method_family = none)]
        pub unsafe fn synchronizeResource(&self) -> bool;

        /// Setter for [`synchronizeResource`][Self::synchronizeResource].
        #[unsafe(method(setSynchronizeResource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSynchronizeResource(&self, synchronize_resource: bool);
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSNNStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// During training, each MPSNNFilterNode has a corresponding
    /// MPSNNGradientFilterNode for the gradient computation for
    /// trainable parameter update. The two communicate through a
    /// MPSNNGradientStateNode or subclass which carries information
    /// about the inference pass settings to the gradient pass.
    /// You can avoid managing these -- there will be many! -- by
    /// using -[MPSNNFilterNode gradientFilterWithSources:] to make
    /// the MPSNNGradientFilterNodes. That method will append
    /// the necessary extra information like MPSNNGradientState
    /// nodes and inference filter source image nodes to the object as
    /// needed.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnngradientstatenode?language=objc)
    #[unsafe(super(MPSNNStateNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNGradientStateNode;
);

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

impl MPSNNGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNConvolutionGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnconvolutiontransposegradientstatenode?language=objc)
    #[unsafe(super(
        MPSCNNConvolutionGradientStateNode,
        MPSNNGradientStateNode,
        MPSNNStateNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNConvolutionTransposeGradientStateNode;
);

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

impl MPSCNNConvolutionTransposeGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionTransposeGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNBinaryGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNBinaryGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNMultiaryGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNMultiaryGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNArithmeticGradientStateNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNArithmeticGradientStateNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// Block callback for customizing gradient nodes as they are constructed
///
/// Example code for copying handles from inference image nodes to corresponding gradient nodes:
///
/// ```text
///               MPSNodeCustomizationBlock myCopyHandleBlock = ^( MPSNNFilterNode * __nonnull gradientNode,
///                                                                MPSNNFilterNode * __nonnull inferenceNode,
///                                                                MPSNNImageNode * __nonnull inferenceSource )
///               {
///                   gradientNode.resultImage.handle = inferenceSource.handle;
///               }
/// ```
///
///
/// Parameter `gradientNode`: The new gradient node created to mirror inferenceNode
///
/// Parameter `inferenceNode`: The preexisting inference node mirrored by gradient node.
/// If nil, an extra node was automatically inserted into the graph.
/// An MPSNNAdditionNode may be inserted at junctions
/// where multiple inference MPSNNFilterNodes read from the
/// same MPSNNImageNode.
///
/// Parameter `inferenceSource`: The  source image argument to the inference node to which the gradient result corresponds
///
/// Parameter `gradientSource`: The source gradient argument to the new gradient node.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsgradientnodeblock?language=objc)
#[cfg(feature = "block2")]
pub type MPSGradientNodeBlock = *mut block2::DynBlock<
    dyn Fn(
        NonNull<MPSNNFilterNode>,
        NonNull<MPSNNFilterNode>,
        NonNull<MPSNNImageNode>,
        NonNull<MPSNNImageNode>,
    ),
>;

extern_class!(
    /// A placeholder node denoting a neural network filter stage
    ///
    /// There are as many MPSNNFilterNode subclasses as there are
    /// MPS neural network filter objects. Make one of those.
    /// This class defines an polymorphic interface for them.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnfilternode?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNFilterNode;
);

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

impl MPSNNFilterNode {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        /// Get the node representing the image result of the filter
        ///
        /// Except where otherwise noted, the precision used for the
        /// result image (see format property) is copied from the precision
        /// from the first input image node.
        #[unsafe(method(resultImage))]
        #[unsafe(method_family = none)]
        pub unsafe fn resultImage(&self) -> Retained<MPSNNImageNode>;

        /// convenience method for resultStates[0]
        ///
        /// If resultStates is nil, returns nil
        #[unsafe(method(resultState))]
        #[unsafe(method_family = none)]
        pub unsafe fn resultState(&self) -> Option<Retained<MPSNNStateNode>>;

        /// Get the node representing the state result of the filter
        ///
        /// If more than one, see description of subclass for ordering.
        #[unsafe(method(resultStates))]
        #[unsafe(method_family = none)]
        pub unsafe fn resultStates(&self) -> Option<Retained<NSArray<MPSNNStateNode>>>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// The padding method used for the filter node
        ///
        /// The padding policy configures how the filter centers
        /// the region of interest in the source image. It principally
        /// is responsible for setting the MPSCNNKernel.offset and
        /// the size of the image produced, and sometimes will also
        /// configure .sourceFeatureChannelOffset, .sourceFeatureChannelMaxCount,
        /// and .edgeMode.  It is permitted to set any other filter properties
        /// as needed using a custom padding policy. The default padding
        /// policy varies per filter to conform to consensus expectation for
        /// the behavior of that filter.  In some cases, pre-made padding
        /// policies are provided to match the behavior of common neural
        /// networking frameworks with particularly complex or unexpected
        /// behavior for specific nodes. See MPSNNDefaultPadding class methods
        /// in MPSNeuralNetworkTypes.h for more.
        ///
        /// BUG: MPS doesn't provide a good way to reset the MPSKernel properties
        /// in the context of a MPSNNGraph after the kernel is finished encoding.
        /// These values carry on to the next time the graph is used. Consequently,
        /// if your custom padding policy modifies the property as a function of the
        /// previous value, e.g.:
        ///
        /// kernel.someProperty += 2;
        ///
        /// then the second time the graph runs, the property may have an inconsistent
        /// value, leading to unexpected behavior. The default padding computation
        /// runs before the custom padding method to provide it with a sense of
        /// what is expected for the default configuration and will reinitialize the value
        /// in the case of the .offset. However, that computation usually doesn't reset
        /// other properties. In such cases, the custom padding policy may need to keep
        /// a record of the original value to enable consistent behavior.
        #[unsafe(method(paddingPolicy))]
        #[unsafe(method_family = none)]
        pub unsafe fn paddingPolicy(&self) -> Retained<ProtocolObject<dyn MPSNNPadding>>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`paddingPolicy`][Self::paddingPolicy].
        #[unsafe(method(setPaddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPaddingPolicy(&self, padding_policy: &ProtocolObject<dyn MPSNNPadding>);

        /// A string to help identify this object.
        #[unsafe(method(label))]
        #[unsafe(method_family = none)]
        pub unsafe 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 unsafe fn setLabel(&self, label: Option<&NSString>);

        /// Return the gradient (backwards) version of this filter.
        ///
        /// The backwards training version of the filter will be returned.
        /// The non-gradient image and state arguments for the filter are automatically
        /// obtained from the target.
        ///
        /// Parameter `gradientImage`: The gradient images corresponding with the resultImage
        /// of the target
        #[unsafe(method(gradientFilterWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSource(
            &self,
            gradient_image: &MPSNNImageNode,
        ) -> Retained<MPSNNGradientFilterNode>;

        /// Return the gradient (backwards) version of this filter.
        ///
        /// The backwards training version of the filter will be returned.
        /// The non-gradient image and state arguments for the filter are automatically
        /// obtained from the target.
        ///
        /// Parameter `gradientImages`: The gradient images corresponding with the resultImage
        /// of the target
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;

        /// Return multiple gradient versions of the filter
        ///
        /// MPSNNFilters that consume multiple inputs generally result in
        /// multiple conjugate filters for the gradient computation at
        /// the end of training. For example, a single concatenation operation
        /// that concatenates multple images will result in an array of slice
        /// operators that carve out subsections of the input gradient image.
        #[unsafe(method(gradientFiltersWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<NSArray<MPSNNGradientFilterNode>>;

        /// Return multiple gradient versions of the filter
        ///
        /// MPSNNFilters that consume multiple inputs generally result in
        /// multiple conjugate filters for the gradient computation at
        /// the end of training. For example, a single concatenation operation
        /// that concatenates multple images will result in an array of slice
        /// operators that carve out subsections of the input gradient image.
        #[unsafe(method(gradientFiltersWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSource(
            &self,
            gradient_image: &MPSNNImageNode,
        ) -> Retained<NSArray<MPSNNGradientFilterNode>>;

        #[cfg(feature = "block2")]
        /// Build training graph from inference graph
        ///
        /// This method will iteratively build the training portion of a graph based
        /// on an inference graph. Self should be the last node in the
        /// inference graph. It is typically a loss layer, but can be anything.
        /// Typically, the "inference graph" used here is the desired inference
        /// graph with a dropout node and a loss layer node appended.
        ///
        /// The nodes that are created will have default properties. In certain cases,
        /// these may not be appropriate (e.g. if you want to do CPU based updates
        /// of convolution weights instead of default GPU updates.) In such cases, your
        /// application should use the nodeHandler to configure the new nodes as they are
        /// created.
        ///
        /// BUG: This method can not follow links to regions of the graph that are
        /// connected to the rest of the graph solely via MPSNNStateNodes. A gradient
        /// image input is required to construct a MPSNNGradientFilterNode from a
        /// inference filter node.
        ///
        ///
        /// Parameter `gradientImage`: The input gradient image for the first gradient
        /// node in the training section of the graph. If nil,
        /// self.resultImage is used. This results in a standard monolithic
        /// training graph. If the graph is instead divided into multiple
        /// subgraphs (potentially to allow for your custom code to appear
        /// inbetween MPSNNGraph segments) a new MPSImageNode*
        /// may be substituted.
        ///
        /// Parameter `nodeHandler`: An optional block to allow for customization of gradient
        /// nodes and intermediate images as the graph is constructed.
        /// It may also be used to prune braches of the developing
        /// training graph. If nil, the default handler is used. It builds
        /// the full graph, and assigns any inferenceNodeSources[i].handle
        /// to their gradient counterparts.
        ///
        /// Returns: The list of new MPSNNFilterNode training graph termini. These MPSNNFilterNodes
        /// are not necessarily all MPSNNGradientFilterNodes. To build a full list of nodes
        /// created, use a custom nodeHandler. If no nodes are created nil is returned.
        ///
        /// # Safety
        ///
        /// `node_handler` must be a valid pointer or null.
        #[unsafe(method(trainingGraphWithSourceGradient:nodeHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn trainingGraphWithSourceGradient_nodeHandler(
            &self,
            gradient_image: Option<&MPSNNImageNode>,
            node_handler: MPSGradientNodeBlock,
        ) -> Option<Retained<NSArray<MPSNNFilterNode>>>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSNNFilterNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// For each MPSNNFilterNode, there is a corresponding MPSNNGradientFilterNode
    /// used for training that back propagates image gradients to refine the
    /// various parameters in each node. Generally, it takes as input a gradient
    /// corresponding to the result image from the MPSNNFilterNode and returns
    /// a gradient image corresponding to the source image of the MPSNNFilterNode.
    /// In addition, there is generally a MPSNNState produced by the MPSNNFilterNode
    /// that is consumed by the MPSNNGradientNode and the MPSNNGradientNode generally
    /// needs to look at the MPSNNFilterNode source image.
    ///
    /// If you have a simple method to traverse your inference graph backwards, then
    /// -[MPSNNFilterNode gradientFilterWithSource:] is a simple way to construct
    /// these.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnngradientfilternode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNGradientFilterNode;
);

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

impl MPSNNGradientFilterNode {
    extern_methods!(
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            source_gradient: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;

        #[unsafe(method(gradientFiltersWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSources(
            &self,
            source_gradient: &NSArray<MPSNNImageNode>,
        ) -> Retained<NSArray<MPSNNGradientFilterNode>>;

        #[unsafe(method(gradientFilterWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSource(
            &self,
            source_gradient: &MPSNNImageNode,
        ) -> Retained<MPSNNGradientFilterNode>;

        #[unsafe(method(gradientFiltersWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSource(
            &self,
            source_gradient: &MPSNNImageNode,
        ) -> Retained<NSArray<MPSNNGradientFilterNode>>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNGradientFilterNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNFilterNode representing a MPSCNNConvolution kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnconvolutionnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNConvolutionNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNConvolutionNode {}
);

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

impl MPSCNNConvolutionNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// The training style of the forward node will be propagated to gradient nodes made from it
        #[unsafe(method(trainingStyle))]
        #[unsafe(method_family = none)]
        pub unsafe fn trainingStyle(&self) -> MPSNNTrainingStyle;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`trainingStyle`][Self::trainingStyle].
        #[unsafe(method(setTrainingStyle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTrainingStyle(&self, training_style: MPSNNTrainingStyle);

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Set the floating-point precision used by the convolution accumulator
        ///
        /// Default:  MPSNNConvolutionAccumulatorPrecisionOptionFloat
        #[unsafe(method(accumulatorPrecision))]
        #[unsafe(method_family = none)]
        pub unsafe fn accumulatorPrecision(&self) -> MPSNNConvolutionAccumulatorPrecisionOption;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`accumulatorPrecision`][Self::accumulatorPrecision].
        #[unsafe(method(setAccumulatorPrecision:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAccumulatorPrecision(
            &self,
            accumulator_precision: MPSNNConvolutionAccumulatorPrecisionOption,
        );

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(initWithSource:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        /// A node to represent a MPSCNNConvolutionGradientState object
        ///
        /// Use this if the convolution is mirrored by a convolution transpose node
        /// later on in the graph to make sure that the size of the image returned
        /// from the convolution transpose matches the size of the image passed in
        /// to this node.
        #[unsafe(method(convolutionGradientState))]
        #[unsafe(method_family = none)]
        pub unsafe fn convolutionGradientState(
            &self,
        ) -> Option<Retained<MPSCNNConvolutionGradientStateNode>>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNFilterNode representing a MPSCNNFullyConnected kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnfullyconnectednode?language=objc)
    #[unsafe(super(MPSCNNConvolutionNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNFullyConnectedNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNFullyConnectedNode {}
);

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

impl MPSCNNFullyConnectedNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNFullyConnected kernel.
        #[unsafe(method(initWithSource:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNFullyConnectedNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNFilterNode representing a MPSCNNBinaryConvolution kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnbinaryconvolutionnode?language=objc)
    #[unsafe(super(MPSCNNConvolutionNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNBinaryConvolutionNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNBinaryConvolutionNode {}
);

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

impl MPSCNNBinaryConvolutionNode {
    extern_methods!(
        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init an autoreleased node representing a MPSCNNBinaryConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `scaleValue`: A floating point value used to scale the entire convolution.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:scaleValue:type:flags:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights_scaleValue_type_flags(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            scale_value: c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init a node representing a MPSCNNBinaryConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `scaleValue`: A floating point value used to scale the entire convolution.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.
        #[unsafe(method(initWithSource:weights:scaleValue:type:flags:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights_scaleValue_type_flags(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            scale_value: c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init an autoreleased node representing a MPSCNNBinaryConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `outputBiasTerms`: A pointer to bias terms to be applied to the convolution output.
        /// See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `outputScaleTerms`: A pointer to scale terms to be applied to binary convolution
        /// results per output feature channel. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputBiasTerms`: A pointer to offset terms to be applied to the input before convolution and
        /// before input scaling. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputScaleTerms`: A pointer to scale terms to be applied to the input before convolution,
        /// but after input biasing. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.
        ///
        /// # Safety
        ///
        /// - `output_bias_terms` must be a valid pointer or null.
        /// - `output_scale_terms` must be a valid pointer or null.
        /// - `input_bias_terms` must be a valid pointer or null.
        /// - `input_scale_terms` must be a valid pointer or null.
        #[unsafe(method(nodeWithSource:weights:outputBiasTerms:outputScaleTerms:inputBiasTerms:inputScaleTerms:type:flags:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights_outputBiasTerms_outputScaleTerms_inputBiasTerms_inputScaleTerms_type_flags(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            output_bias_terms: *const c_float,
            output_scale_terms: *const c_float,
            input_bias_terms: *const c_float,
            input_scale_terms: *const c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init a node representing a MPSCNNBinaryConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `outputBiasTerms`: A pointer to bias terms to be applied to the convolution output.
        /// See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `outputScaleTerms`: A pointer to scale terms to be applied to binary convolution
        /// results per output feature channel. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputBiasTerms`: A pointer to offset terms to be applied to the input before convolution and
        /// before input scaling. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputScaleTerms`: A pointer to scale terms to be applied to the input before convolution,
        /// but after input biasing. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryConvolution kernel.
        ///
        /// # Safety
        ///
        /// - `output_bias_terms` must be a valid pointer or null.
        /// - `output_scale_terms` must be a valid pointer or null.
        /// - `input_bias_terms` must be a valid pointer or null.
        /// - `input_scale_terms` must be a valid pointer or null.
        #[unsafe(method(initWithSource:weights:outputBiasTerms:outputScaleTerms:inputBiasTerms:inputScaleTerms:type:flags:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights_outputBiasTerms_outputScaleTerms_inputBiasTerms_inputScaleTerms_type_flags(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            output_bias_terms: *const c_float,
            output_scale_terms: *const c_float,
            input_bias_terms: *const c_float,
            input_scale_terms: *const c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        /// unavailable
        #[unsafe(method(convolutionGradientState))]
        #[unsafe(method_family = none)]
        pub unsafe fn convolutionGradientState(
            &self,
        ) -> Option<Retained<MPSCNNConvolutionGradientStateNode>>;
    );
}

/// Methods declared on superclass `MPSCNNConvolutionNode`.
impl MPSCNNBinaryConvolutionNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(initWithSource:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNBinaryConvolutionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNFilterNode representing a MPSCNNBinaryFullyConnected kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnbinaryfullyconnectednode?language=objc)
    #[unsafe(super(
        MPSCNNBinaryConvolutionNode,
        MPSCNNConvolutionNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNBinaryFullyConnectedNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNBinaryFullyConnectedNode {}
);

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

impl MPSCNNBinaryFullyConnectedNode {
    extern_methods!(
        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init an autoreleased node representing a MPSCNNBinaryFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `scaleValue`: A floating point value used to scale the entire convolution.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.
        #[unsafe(method(nodeWithSource:weights:scaleValue:type:flags:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights_scaleValue_type_flags(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            scale_value: c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init a node representing a MPSCNNBinaryFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `scaleValue`: A floating point value used to scale the entire convolution.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.
        #[unsafe(method(initWithSource:weights:scaleValue:type:flags:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights_scaleValue_type_flags(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            scale_value: c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init an autoreleased node representing a MPSCNNBinaryFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `outputBiasTerms`: A pointer to bias terms to be applied to the convolution output.
        /// See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `outputScaleTerms`: A pointer to scale terms to be applied to binary convolution
        /// results per output feature channel. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputBiasTerms`: A pointer to offset terms to be applied to the input before convolution and
        /// before input scaling. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputScaleTerms`: A pointer to scale terms to be applied to the input before convolution,
        /// but after input biasing. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.
        ///
        /// # Safety
        ///
        /// - `output_bias_terms` must be a valid pointer or null.
        /// - `output_scale_terms` must be a valid pointer or null.
        /// - `input_bias_terms` must be a valid pointer or null.
        /// - `input_scale_terms` must be a valid pointer or null.
        #[unsafe(method(nodeWithSource:weights:outputBiasTerms:outputScaleTerms:inputBiasTerms:inputScaleTerms:type:flags:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights_outputBiasTerms_outputScaleTerms_inputBiasTerms_inputScaleTerms_type_flags(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            output_bias_terms: *const c_float,
            output_scale_terms: *const c_float,
            input_bias_terms: *const c_float,
            input_scale_terms: *const c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCNNConvolution", feature = "MPSNeuralNetworkTypes"))]
        /// Init a node representing a MPSCNNBinaryFullyConnected kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Parameter `outputBiasTerms`: A pointer to bias terms to be applied to the convolution output.
        /// See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `outputScaleTerms`: A pointer to scale terms to be applied to binary convolution
        /// results per output feature channel. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputBiasTerms`: A pointer to offset terms to be applied to the input before convolution and
        /// before input scaling. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `inputScaleTerms`: A pointer to scale terms to be applied to the input before convolution,
        /// but after input biasing. See MPSCNNBinaryConvolution for more details.
        ///
        /// Parameter `type`: What kind of binarization strategy is to be used.
        ///
        /// Parameter `flags`: See documentation of MPSCNNBinaryConvolutionFlags.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNBinaryFullyConnected kernel.
        ///
        /// # Safety
        ///
        /// - `output_bias_terms` must be a valid pointer or null.
        /// - `output_scale_terms` must be a valid pointer or null.
        /// - `input_bias_terms` must be a valid pointer or null.
        /// - `input_scale_terms` must be a valid pointer or null.
        #[unsafe(method(initWithSource:weights:outputBiasTerms:outputScaleTerms:inputBiasTerms:inputScaleTerms:type:flags:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights_outputBiasTerms_outputScaleTerms_inputBiasTerms_inputScaleTerms_type_flags(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
            output_bias_terms: *const c_float,
            output_scale_terms: *const c_float,
            input_bias_terms: *const c_float,
            input_scale_terms: *const c_float,
            r#type: MPSCNNBinaryConvolutionType,
            flags: MPSCNNBinaryConvolutionFlags,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNConvolutionNode`.
impl MPSCNNBinaryFullyConnectedNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(initWithSource:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNBinaryFullyConnectedNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNFilterNode representing a MPSCNNConvolutionTranspose kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnconvolutiontransposenode?language=objc)
    #[unsafe(super(MPSCNNConvolutionNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNConvolutionTransposeNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNConvolutionTransposeNode {}
);

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

impl MPSCNNConvolutionTransposeNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNConvolutionTransposeNode kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `convolutionGradientState`: When the convolution transpose is used to 'undo' an earlier convolution
        /// in the graph, it is generally desired that the output image be the same
        /// size as the input image to the earlier convolution. You may optionally
        /// specify this size identity by passing in the MPSNNConvolutionGradientStateNode
        /// created by the convolution node here.
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolutionTransposeNode kernel.
        #[unsafe(method(nodeWithSource:convolutionGradientState:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_convolutionGradientState_weights(
            source_node: &MPSNNImageNode,
            convolution_gradient_state: Option<&MPSCNNConvolutionGradientStateNode>,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNConvolutionTransposeNode kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `convolutionGradientState`: When the convolution transpose is used to 'undo' an earlier convolution
        /// in the graph, it is generally desired that the output image be the same
        /// size as the input image to the earlier convolution. You may optionally
        /// specify this size identity by passing in the MPSCNNConvolutionGradientState node
        /// here.
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolutionTransposeNode kernel.
        #[unsafe(method(initWithSource:convolutionGradientState:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_convolutionGradientState_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            convolution_gradient_state: Option<&MPSCNNConvolutionGradientStateNode>,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        /// unavailable
        #[unsafe(method(convolutionGradientState))]
        #[unsafe(method_family = none)]
        pub unsafe fn convolutionGradientState(
            &self,
        ) -> Option<Retained<MPSCNNConvolutionGradientStateNode>>;
    );
}

/// Methods declared on superclass `MPSCNNConvolutionNode`.
impl MPSCNNConvolutionTransposeNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// Init an autoreleased not representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(nodeWithSource:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_weights(
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// Init a node representing a MPSCNNConvolution kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `weights`: A pointer to a valid object conforming to the MPSCNNConvolutionDataSource
        /// protocol. This object is provided by you to encapsulate storage for
        /// convolution weights and biases. If it is used for training, it may not
        /// have a neuron embedded in the convolution descriptor.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNConvolution kernel.
        #[unsafe(method(initWithSource:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_weights(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            weights: &ProtocolObject<dyn MPSCNNConvolutionDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionTransposeNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNConvolutionGradientNode {}
);

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

impl MPSCNNConvolutionGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution
        ///
        /// Parameter `weights`: The data source from the forward convolution. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution pass.
        ///
        /// Returns: A MPSCNNConvolutionGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_convolutionGradientState_weights(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution
        ///
        /// Parameter `weights`: The data source from the forward convolution. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution pass.
        ///
        /// Returns: A MPSCNNConvolutionGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_convolutionGradientState_weights(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnfullyconnectedgradientnode?language=objc)
    #[unsafe(super(
        MPSCNNConvolutionGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNFullyConnectedGradientNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNFullyConnectedGradientNode {}
);

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

impl MPSCNNFullyConnectedGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for fully connected training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward fully connected node
        ///
        /// Parameter `gradientState`: The gradient state from the forward fully connected
        ///
        /// Parameter `weights`: The data source from the forward fully connected. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward fully connected pass.
        ///
        /// Returns: A MPSCNNFullyConnectedGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_convolutionGradientState_weights(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for fully connectd training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward fully connected node
        ///
        /// Parameter `gradientState`: The gradient state from the forward fully connected
        ///
        /// Parameter `weights`: The data source from the forward fully connected. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution pass.
        ///
        /// Returns: A MPSCNNFullyConnectedGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_convolutionGradientState_weights(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNFullyConnectedGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnconvolutiontransposegradientnode?language=objc)
    #[unsafe(super(
        MPSCNNConvolutionGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNConvolutionTransposeGradientNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNConvolutionTransposeGradientNode {}
);

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

impl MPSCNNConvolutionTransposeGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution transpose training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution transpose node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution transpose
        ///
        /// Parameter `weights`: The data source from the forward convolution transpose. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution transpose pass.
        ///
        /// Returns: A MPSCNNConvolutionTransposeGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:convolutionTransposeGradientState:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_convolutionTransposeGradientState_weights(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionTransposeGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution transpose training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution transpose node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution transpose
        ///
        /// Parameter `weights`: The data source from the forward convolution transpose. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution transpose pass.
        ///
        /// Returns: A MPSCNNConvolutionTransposeGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:convolutionTransposeGradientState:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_convolutionTransposeGradientState_weights(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionTransposeGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNConvolutionGradientNode`.
impl MPSCNNConvolutionTransposeGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution
        ///
        /// Parameter `weights`: The data source from the forward convolution. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution pass.
        ///
        /// Returns: A MPSCNNConvolutionGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_convolutionGradientState_weights(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNConvolution")]
        /// A node to represent the gradient calculation for convolution training.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter. Often
        /// that is a neuron gradient filter node.
        ///
        /// Parameter `sourceImage`: The input image from the forward convolution node
        ///
        /// Parameter `gradientState`: The gradient state from the forward convolution
        ///
        /// Parameter `weights`: The data source from the forward convolution. It may not contain
        /// an integrated neuron. Similary, any normalization should be
        /// broken out into a separate node. Pass nil to use the weights
        /// from the forward convolution pass.
        ///
        /// Returns: A MPSCNNConvolutionGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:convolutionGradientState:weights:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_convolutionGradientState_weights(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSCNNConvolutionGradientStateNode,
            weights: Option<&ProtocolObject<dyn MPSCNNConvolutionDataSource>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNConvolutionTransposeGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// virtual base class for MPSCNNNeuron nodes
    ///
    /// This is a virtual base class only. Please create a
    /// subclass using +newNeuronNodeWithSouce:descriptor or
    /// by making one of the subclasses directly. Better yet, skip
    /// the node entirely and specify the neuron function directly in
    /// your MPSCNNConvolutionDataSource.descriptor.neuronDescriptor.
    ///
    /// MPSCNNNeuronNodes are provided as a representational convenience.
    /// However, you are usually better off incorporating your neuron
    /// into the MPSCNNConvolutionDataSource when possible. The MPSNNGraph
    /// will attempt to optimize away the neuron pass by fusing it with a
    /// preceeding convolution, but it might be prevented from doing so
    /// if the neuron pass has a custom padding method or more than one
    /// node reads from the convolution result. The graph -debugDescription
    /// should reveal what happened.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronNode;
);

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

impl MPSCNNNeuronNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        /// filter parameter a
        #[unsafe(method(a))]
        #[unsafe(method_family = none)]
        pub unsafe fn a(&self) -> c_float;

        /// filter parameter b
        #[unsafe(method(b))]
        #[unsafe(method_family = none)]
        pub unsafe fn b(&self) -> c_float;

        /// filter parameter c
        #[unsafe(method(c))]
        #[unsafe(method_family = none)]
        pub unsafe fn c(&self) -> c_float;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronAbsolute kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = fabs(x)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronabsolutenode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronAbsoluteNode;
);

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

impl MPSCNNNeuronAbsoluteNode {
    extern_methods!(
        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronAbsoluteNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronAbsoluteNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronELU kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = a * exp(x) - 1, x <  0
    ///              x             , x >= 0
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronelunode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronELUNode;
);

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

impl MPSCNNNeuronELUNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a(source_node: &MPSNNImageNode, a: c_float) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:a:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronELUNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronELUNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronReLUN kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = min((x >= 0 ? x : a * x), b)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronrelunnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronReLUNNode;
);

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

impl MPSCNNNeuronReLUNNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:a:b:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronReLUNNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronReLUNNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronLinear kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = a * x + b
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronlinearnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronLinearNode;
);

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

impl MPSCNNNeuronLinearNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronLinear kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronLinear kernel.
        #[unsafe(method(initWithSource:a:b:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronLinearNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronLinearNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronReLU kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = x            if x >= 0
    ///            = a * x        if x < 0
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronrelunode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronReLUNode;
);

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

impl MPSCNNNeuronReLUNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a(source_node: &MPSNNImageNode, a: c_float) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:a:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronReLUNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronReLUNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronSigmoid kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = 1 / (1 + e^-x)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronsigmoidnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronSigmoidNode;
);

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

impl MPSCNNNeuronSigmoidNode {
    extern_methods!(
        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronSigmoidNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronSigmoidNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronHardSigmoid kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = clamp((a * x) + b, 0, 1)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronhardsigmoidnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronHardSigmoidNode;
);

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

impl MPSCNNNeuronHardSigmoidNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronHardSigmoid kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronHardSigmoid kernel.
        #[unsafe(method(initWithSource:a:b:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronHardSigmoidNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronHardSigmoidNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronSoftPlus kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = a * log(1 + e^(b * x))
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronsoftplusnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronSoftPlusNode;
);

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

impl MPSCNNNeuronSoftPlusNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronSoftPlus kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronSoftPlus kernel.
        #[unsafe(method(initWithSource:a:b:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronSoftPlusNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronSoftPlusNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronSoftSign kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = x / (1 + abs(x))
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronsoftsignnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronSoftSignNode;
);

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

impl MPSCNNNeuronSoftSignNode {
    extern_methods!(
        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronSoftSignNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronSoftSignNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronTanH kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = a * tanh(b * x)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneurontanhnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronTanHNode;
);

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

impl MPSCNNNeuronTanHNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronTanH kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// ```text
        ///       f(x) = a * tanh(b * x)
        /// ```
        ///
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronTanH kernel.
        #[unsafe(method(initWithSource:a:b:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a
        /// &
        /// b
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronTanHNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronTanHNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A ReLU node with parameter a provided independently for each feature channel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = x                if x >= 0
    ///            = aData[i] * x     if x < 0,  i is the index of the feature channel
    ///   @param      sourceNode              The MPSNNImageNode representing the source MPSImage for the filter
    ///   @param      aData                   An array of single precision floating-point alpha values to use
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronprelunode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronPReLUNode;
);

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

impl MPSCNNNeuronPReLUNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:aData:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_aData(
            source_node: &MPSNNImageNode,
            a_data: &NSData,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronTanH kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// ```text
        ///       f(x) = x                if x >= 0
        ///            = aData[i] * x     if x < 0,  i is the index of the feature channel
        /// ```
        ///
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `aData`: An array of single precision floating-point alpha values to use
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronTanH kernel.
        #[unsafe(method(initWithSource:aData:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_aData(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a_data: &NSData,
        ) -> Retained<Self>;

        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronPReLUNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronPReLUNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronPower kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = (a * x + b) ^ c
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronpowernode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronPowerNode;
);

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

impl MPSCNNNeuronPowerNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:c:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b_c(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronPower kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// ```text
        ///       f(x) = (a * x + b) ^ c
        /// ```
        ///
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Parameter `c`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronPower kernel.
        #[unsafe(method(initWithSource:a:b:c:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b_c(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a, b, and c
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a, b, and c
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronPowerNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronPowerNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronExponential kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = c ^ (a * x + b)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronexponentialnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronExponentialNode;
);

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

impl MPSCNNNeuronExponentialNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:c:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b_c(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronExponential kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// ```text
        ///       f(x) = c ^ (a * x + b)
        /// ```
        ///
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Parameter `c`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronExponential kernel.
        #[unsafe(method(initWithSource:a:b:c:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b_c(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a, b, and c
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a, b, and c
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronExponentialNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronExponentialNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronLogarithm kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// ```text
    ///       f(x) = log_c(a * x + b)
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneuronlogarithmnode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronLogarithmNode;
);

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

impl MPSCNNNeuronLogarithmNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:a:b:c:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_a_b_c(
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNNeuronLogarithm kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// ```text
        ///       f(x) = log_c(a * x + b)
        /// ```
        ///
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `a`: See discussion above.
        ///
        /// Parameter `b`: See discussion above.
        ///
        /// Parameter `c`: See discussion above.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronLogarithm kernel.
        #[unsafe(method(initWithSource:a:b:c:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_a_b_c(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            a: c_float,
            b: c_float,
            c: c_float,
        ) -> Retained<Self>;

        /// Create an autoreleased node with default values for parameters a, b, and c
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node with default values for parameters a, b, and c
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronLogarithmNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronLogarithmNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronGeLU kernel
    ///
    /// For each pixel, applies the following function:
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneurongelunode?language=objc)
    #[unsafe(super(MPSCNNNeuronNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronGeLUNode;
);

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

impl MPSCNNNeuronGeLUNode {
    extern_methods!(
        /// Init a node representing a MPSCNNNeuronGeLU kernel
        ///
        /// For each pixel, applies the following function:
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNNeuronLogarithm kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// Create an autoreleased node
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNeuronNode`.
impl MPSCNNNeuronGeLUNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// Create a neuron node of the appropriate type with a MPSNNNeuronDescriptor
        #[unsafe(method(nodeWithSource:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_descriptor(
            source_node: &MPSNNImageNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronGeLUNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNNeuronGradient
    ///
    /// We use one generic neuron gradient node
    /// instead of having dozens of subclasses.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnneurongradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNeuronGradientNode;
);

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

impl MPSCNNNeuronGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNNeuron")]
        /// create a new neuron gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodeWithSources:]
        /// for an easier way to do this
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_descriptor(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNNeuron")]
        /// create a new neuron gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodeWithSources:]
        /// for an easier way to do this
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:descriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_descriptor(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            descriptor: &MPSNNNeuronDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNNeuron")]
        /// The neuron descriptor
        #[unsafe(method(descriptor))]
        #[unsafe(method_family = none)]
        pub unsafe fn descriptor(&self) -> Retained<MPSNNNeuronDescriptor>;

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl MPSCNNNeuronGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a unary MPSNNReduce node.
    ///
    /// This is an abstract base class that does not correspond with any
    /// particular MPSCNNKernel. Please make one of the MPSNNReduction
    /// subclasses instead.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnunaryreductionnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNUnaryReductionNode;
);

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

impl MPSNNUnaryReductionNode {
    extern_methods!(
        /// The clip rectangle to apply to the source image.
        #[unsafe(method(clipRectSource))]
        #[unsafe(method_family = none)]
        pub unsafe fn clipRectSource(&self) -> MTLRegion;

        /// Setter for [`clipRectSource`][Self::clipRectSource].
        #[unsafe(method(setClipRectSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setClipRectSource(&self, clip_rect_source: MTLRegion);

        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNUnaryReductionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionRowMinNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionRowMinNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionRowMinNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionColumnMinNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionColumnMinNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionColumnMinNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsMinNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsMinNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsMinNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsArgumentMinNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsArgumentMinNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsArgumentMinNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionRowMaxNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionRowMaxNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionRowMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionColumnMaxNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionColumnMaxNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionColumnMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsMaxNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsMaxNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsArgumentMaxNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsArgumentMaxNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsArgumentMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionRowMeanNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionRowMeanNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionRowMeanNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionColumnMeanNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionColumnMeanNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionColumnMeanNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsMeanNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsMeanNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsMeanNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionSpatialMeanNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionSpatialMeanNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionSpatialMeanNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionRowSumNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionRowSumNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionRowSumNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionColumnSumNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionColumnSumNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionColumnSumNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionFeatureChannelsSumNode {
    extern_methods!(
        /// A scale factor to apply to each feature channel sum.
        #[unsafe(method(weight))]
        #[unsafe(method_family = none)]
        pub unsafe fn weight(&self) -> c_float;

        /// Setter for [`weight`][Self::weight].
        #[unsafe(method(setWeight:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setWeight(&self, weight: c_float);
    );
}

/// Methods declared on superclass `MPSNNUnaryReductionNode`.
impl MPSNNReductionFeatureChannelsSumNode {
    extern_methods!(
        /// Create an autoreleased node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing an MPS reduction kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for an MPS reduction kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionFeatureChannelsSumNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a MPSCNNPooling kernel
    ///
    /// This is an abstract base class that does not correspond with any
    /// particular MPSCNNKernel. Please make one of the MPSCNNPooling
    /// subclasses instead.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingNode;
);

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

impl MPSCNNPoolingNode {
    extern_methods!(
        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;

        #[unsafe(method(strideInPixelsX))]
        #[unsafe(method_family = none)]
        pub unsafe fn strideInPixelsX(&self) -> NSUInteger;

        #[unsafe(method(strideInPixelsY))]
        #[unsafe(method_family = none)]
        pub unsafe fn strideInPixelsY(&self) -> NSUInteger;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels and a different stride
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:stride:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize_stride(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNPooling kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `kernelWidth`: The width of the max filter window
        ///
        /// Parameter `kernelHeight`: The height of the max filter window
        ///
        /// Parameter `strideInPixelsX`: The output stride (downsampling factor) in the x dimension.
        ///
        /// Parameter `strideInPixelsY`: The output stride (downsampling factor) in the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:stride:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize_stride(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNPoolingAverage kernel
    ///
    /// The default edge mode is MPSImageEdgeModeClamp
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingaveragenode?language=objc)
    #[unsafe(super(MPSCNNPoolingNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingAverageNode;
);

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

impl MPSCNNPoolingAverageNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingNode`.
impl MPSCNNPoolingAverageNode {
    extern_methods!(
        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels and a different stride
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:stride:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize_stride(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNPooling kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `kernelWidth`: The width of the max filter window
        ///
        /// Parameter `kernelHeight`: The height of the max filter window
        ///
        /// Parameter `strideInPixelsX`: The output stride (downsampling factor) in the x dimension.
        ///
        /// Parameter `strideInPixelsY`: The output stride (downsampling factor) in the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:stride:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize_stride(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingAverageNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNPoolingL2Norm kernel
    ///
    /// The default edge mode is MPSImageEdgeModeClamp
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingl2normnode?language=objc)
    #[unsafe(super(MPSCNNPoolingNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingL2NormNode;
);

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

impl MPSCNNPoolingL2NormNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingNode`.
impl MPSCNNPoolingL2NormNode {
    extern_methods!(
        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels and a different stride
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:stride:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize_stride(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNPooling kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `kernelWidth`: The width of the max filter window
        ///
        /// Parameter `kernelHeight`: The height of the max filter window
        ///
        /// Parameter `strideInPixelsX`: The output stride (downsampling factor) in the x dimension.
        ///
        /// Parameter `strideInPixelsY`: The output stride (downsampling factor) in the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:stride:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize_stride(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingL2NormNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing a MPSCNNPoolingMax kernel
    ///
    /// The default edge mode is MPSImageEdgeModeClamp
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingmaxnode?language=objc)
    #[unsafe(super(MPSCNNPoolingNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingMaxNode;
);

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

impl MPSCNNPoolingMaxNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingNode`.
impl MPSCNNPoolingMaxNode {
    extern_methods!(
        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels and a different stride
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:stride:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize_stride(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNPooling kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `kernelWidth`: The width of the max filter window
        ///
        /// Parameter `kernelHeight`: The height of the max filter window
        ///
        /// Parameter `strideInPixelsX`: The output stride (downsampling factor) in the x dimension.
        ///
        /// Parameter `strideInPixelsY`: The output stride (downsampling factor) in the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:stride:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize_stride(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:filterSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a MPSCNNDilatedPooling kernel
    ///
    /// This class corresponds to the MPSCNNDilatedPooling class.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnndilatedpoolingmaxnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNDilatedPoolingMaxNode;
);

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

impl MPSCNNDilatedPoolingMaxNode {
    extern_methods!(
        #[unsafe(method(dilationRateX))]
        #[unsafe(method_family = none)]
        pub unsafe fn dilationRateX(&self) -> NSUInteger;

        #[unsafe(method(dilationRateY))]
        #[unsafe(method_family = none)]
        pub unsafe fn dilationRateY(&self) -> NSUInteger;

        /// Convenience initializer for MPSCNNDilatedPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = dilationRateX = dilationRateY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNDilatedPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNDilatedPooling nodes with square kernels and equal dilation factors
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Parameter `dilationRate`: dilationRateX = dilationRateY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNDilatedPooling kernel.
        #[unsafe(method(nodeWithSource:filterSize:stride:dilationRate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_filterSize_stride_dilationRate(
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
            dilation_rate: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNPooling kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `kernelWidth`: The width of the max filter window
        ///
        /// Parameter `kernelHeight`: The height of the max filter window
        ///
        /// Parameter `strideInPixelsX`: The output stride (downsampling factor) in the x dimension.
        ///
        /// Parameter `strideInPixelsY`: The output stride (downsampling factor) in the y dimension.
        ///
        /// Parameter `dilationRateX`: The dilation factor in the x dimension.
        ///
        /// Parameter `dilationRateY`: The dilation factor in the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNPooling kernel.
        #[unsafe(method(initWithSource:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:dilationRateX:dilationRateY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_dilationRateX_dilationRateY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            dilation_rate_x: NSUInteger,
            dilation_rate_y: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNDilatedPooling nodes with square kernels and equal dilation factors
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = size
        ///
        /// Parameter `stride`: strideInPixelsX = strideInPixelsY = stride
        ///
        /// Parameter `dilationRate`: dilationRateX = dilationRateY = stride
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNDilatedPooling kernel.
        #[unsafe(method(initWithSource:filterSize:stride:dilationRate:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize_stride_dilationRate(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
            stride: NSUInteger,
            dilation_rate: NSUInteger,
        ) -> Retained<Self>;

        /// Convenience initializer for MPSCNNDilatedPooling nodes with square non-overlapping kernels
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `size`: kernelWidth = kernelHeight = strideInPixelsX = strideInPixelsY = dilationRateX = dilationRateY = size
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNDilatedPooling kernel.
        #[unsafe(method(initWithSource:filterSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_filterSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNDilatedPoolingMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNPoolingGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;

        #[unsafe(method(strideInPixelsX))]
        #[unsafe(method_family = none)]
        pub unsafe fn strideInPixelsX(&self) -> NSUInteger;

        #[unsafe(method(strideInPixelsY))]
        #[unsafe(method_family = none)]
        pub unsafe fn strideInPixelsY(&self) -> NSUInteger;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingmaxgradientnode?language=objc)
    #[unsafe(super(
        MPSCNNPoolingGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingMaxGradientNode;
);

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

impl MPSCNNPoolingMaxGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingGradientNode`.
impl MPSCNNPoolingMaxGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingMaxGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingaveragegradientnode?language=objc)
    #[unsafe(super(
        MPSCNNPoolingGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingAverageGradientNode;
);

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

impl MPSCNNPoolingAverageGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingGradientNode`.
impl MPSCNNPoolingAverageGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingAverageGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnpoolingl2normgradientnode?language=objc)
    #[unsafe(super(
        MPSCNNPoolingGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNPoolingL2NormGradientNode;
);

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

impl MPSCNNPoolingL2NormGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSCNNPoolingGradientNode`.
impl MPSCNNPoolingL2NormGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNPoolingL2NormGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnndilatedpoolingmaxgradientnode?language=objc)
    #[unsafe(super(
        MPSCNNPoolingGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNDilatedPoolingMaxGradientNode;
);

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

impl MPSCNNDilatedPoolingMaxGradientNode {
    extern_methods!(
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:dilationRateX:dilationRateY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_dilationRateX_dilationRateY(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            dilation_rate_x: NSUInteger,
            dilation_rate_y: NSUInteger,
        ) -> Retained<Self>;

        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:dilationRateX:dilationRateY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_dilationRateX_dilationRateY(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            dilation_rate_x: NSUInteger,
            dilation_rate_y: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(dilationRateX))]
        #[unsafe(method_family = none)]
        pub unsafe fn dilationRateX(&self) -> NSUInteger;

        #[unsafe(method(dilationRateY))]
        #[unsafe(method_family = none)]
        pub unsafe fn dilationRateY(&self) -> NSUInteger;
    );
}

/// Methods declared on superclass `MPSCNNPoolingGradientNode`.
impl MPSCNNDilatedPoolingMaxGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// make a pooling gradient node
        ///
        /// It would be much easier to use [inferencePoolingNode gradientNodeForSourceGradient:] instead.
        ///
        /// Parameter `sourceGradient`: The gradient from the downstream gradient filter.
        ///
        /// Parameter `sourceImage`: The input image to the inference pooling filter
        ///
        /// Parameter `gradientState`: The gradient state produced by the inference poolin filter
        ///
        /// Parameter `kernelWidth`: The kernel width of the inference filter
        ///
        /// Parameter `kernelHeight`: The kernel height of the inference filter
        ///
        /// Parameter `strideInPixelsX`: The X stride from the inference filter
        ///
        /// Parameter `strideInPixelsY`: The Y stride from the inference filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:strideInPixelsX:strideInPixelsY:paddingPolicy:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight_strideInPixelsX_strideInPixelsY_paddingPolicy(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
            stride_in_pixels_x: NSUInteger,
            stride_in_pixels_y: NSUInteger,
            padding_policy: Option<&ProtocolObject<dyn MPSNNPadding>>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNDilatedPoolingMaxGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// virtual base class for CNN normalization nodes
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnnormalizationnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNNormalizationNode;
);

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

impl MPSCNNNormalizationNode {
    extern_methods!(
        /// The value of alpha.  Default is 1.0. Must be non-negative.
        #[unsafe(method(alpha))]
        #[unsafe(method_family = none)]
        pub unsafe fn alpha(&self) -> c_float;

        /// Setter for [`alpha`][Self::alpha].
        #[unsafe(method(setAlpha:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAlpha(&self, alpha: c_float);

        /// The value of beta.  Default is 5.0
        #[unsafe(method(beta))]
        #[unsafe(method_family = none)]
        pub unsafe fn beta(&self) -> c_float;

        /// Setter for [`beta`][Self::beta].
        #[unsafe(method(setBeta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBeta(&self, beta: c_float);

        /// The value of delta.  Default is 1.0
        #[unsafe(method(delta))]
        #[unsafe(method_family = none)]
        pub unsafe fn delta(&self) -> c_float;

        /// Setter for [`delta`][Self::delta].
        #[unsafe(method(setDelta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelta(&self, delta: c_float);

        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing MPSCNNSpatialNormalization
    ///
    /// For each feature channel, the function computes the sum of squares of X inside each rectangle, N2(i,j).
    /// It then divides each element of X as follows:
    /// Y(i,j) = X(i,j) / (delta + alpha/(kw*kh) * N2(i,j))^beta,
    /// where kw and kh are the kernelWidth and the kernelHeight.
    ///
    ///
    /// ```text
    ///         Defaults:
    ///              alpha = 1.0f
    ///              beta  = 5.0f
    ///              delta = 1.0f
    ///              kernelHeight = kernelWidth = kernelSize
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnspatialnormalizationnode?language=objc)
    #[unsafe(super(MPSCNNNormalizationNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNSpatialNormalizationNode;
);

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

impl MPSCNNSpatialNormalizationNode {
    extern_methods!(
        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        /// Setter for [`kernelWidth`][Self::kernelWidth].
        #[unsafe(method(setKernelWidth:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelWidth(&self, kernel_width: NSUInteger);

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;

        /// Setter for [`kernelHeight`][Self::kernelHeight].
        #[unsafe(method(setKernelHeight:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelHeight(&self, kernel_height: NSUInteger);

        #[unsafe(method(nodeWithSource:kernelSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_kernelSize(
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:kernelSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNormalizationNode`.
impl MPSCNNSpatialNormalizationNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNSpatialNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNSpatialNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        /// Setter for [`kernelWidth`][Self::kernelWidth].
        #[unsafe(method(setKernelWidth:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelWidth(&self, kernel_width: NSUInteger);

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;

        /// Setter for [`kernelHeight`][Self::kernelHeight].
        #[unsafe(method(setKernelHeight:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelHeight(&self, kernel_height: NSUInteger);

        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelSize(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelSize(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        /// The value of alpha.  Default is 1.0. Must be non-negative.
        #[unsafe(method(alpha))]
        #[unsafe(method_family = none)]
        pub unsafe fn alpha(&self) -> c_float;

        /// Setter for [`alpha`][Self::alpha].
        #[unsafe(method(setAlpha:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAlpha(&self, alpha: c_float);

        /// The value of beta.  Default is 5.0
        #[unsafe(method(beta))]
        #[unsafe(method_family = none)]
        pub unsafe fn beta(&self) -> c_float;

        /// Setter for [`beta`][Self::beta].
        #[unsafe(method(setBeta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBeta(&self, beta: c_float);

        /// The value of delta.  Default is 1.0
        #[unsafe(method(delta))]
        #[unsafe(method_family = none)]
        pub unsafe fn delta(&self) -> c_float;

        /// Setter for [`delta`][Self::delta].
        #[unsafe(method(setDelta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelta(&self, delta: c_float);
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNSpatialNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing MPSCNNLocalContrastNormalization
    ///
    /// The result is computed for each element of X as follows:
    ///
    /// Y(i,j) = pm + ps * ( X(i,j) - p0 * M(i,j)) / pow((delta + alpha * variance(i,j)), beta),
    ///
    /// where kw and kh are the kernelWidth and the kernelHeight and pm, ps and p0 are parameters that
    /// can be used to offset and scale the result in various ways. *
    ///
    /// ```text
    ///         Defaults:
    ///              alpha = 1.0f
    ///              beta  = 0.5f
    ///              delta = 2^-10
    ///              pm = 0
    ///              ps = 1
    ///              p0 = 1
    ///              kernelHeight = kernelWidth = kernelSize
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnlocalcontrastnormalizationnode?language=objc)
    #[unsafe(super(MPSCNNNormalizationNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNLocalContrastNormalizationNode;
);

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

impl MPSCNNLocalContrastNormalizationNode {
    extern_methods!(
        #[unsafe(method(pm))]
        #[unsafe(method_family = none)]
        pub unsafe fn pm(&self) -> c_float;

        /// Setter for [`pm`][Self::pm].
        #[unsafe(method(setPm:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPm(&self, pm: c_float);

        #[unsafe(method(ps))]
        #[unsafe(method_family = none)]
        pub unsafe fn ps(&self) -> c_float;

        /// Setter for [`ps`][Self::ps].
        #[unsafe(method(setPs:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPs(&self, ps: c_float);

        #[unsafe(method(p0))]
        #[unsafe(method_family = none)]
        pub unsafe fn p0(&self) -> c_float;

        /// Setter for [`p0`][Self::p0].
        #[unsafe(method(setP0:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setP0(&self, p0: c_float);

        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        /// Setter for [`kernelWidth`][Self::kernelWidth].
        #[unsafe(method(setKernelWidth:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelWidth(&self, kernel_width: NSUInteger);

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;

        /// Setter for [`kernelHeight`][Self::kernelHeight].
        #[unsafe(method(setKernelHeight:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelHeight(&self, kernel_height: NSUInteger);

        #[unsafe(method(nodeWithSource:kernelSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_kernelSize(
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:kernelSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNormalizationNode`.
impl MPSCNNLocalContrastNormalizationNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNLocalContrastNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNLocalContrastNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelWidth:kernelHeight:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelWidth_kernelHeight(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_width: NSUInteger,
            kernel_height: NSUInteger,
        ) -> Retained<Self>;

        /// The value of alpha.  Default is 0.0
        ///
        /// The default value 0.0 is not recommended and is
        /// preserved for backwards compatibility. With alpha 0,
        /// it performs a local mean subtraction. The
        /// MPSCNNLocalContrastNormalizationNode used with
        /// the MPSNNGraph uses 1.0 as a default.
        #[unsafe(method(alpha))]
        #[unsafe(method_family = none)]
        pub unsafe fn alpha(&self) -> c_float;

        /// Setter for [`alpha`][Self::alpha].
        #[unsafe(method(setAlpha:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAlpha(&self, alpha: c_float);

        /// The value of beta.  Default is 0.5
        #[unsafe(method(beta))]
        #[unsafe(method_family = none)]
        pub unsafe fn beta(&self) -> c_float;

        /// Setter for [`beta`][Self::beta].
        #[unsafe(method(setBeta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBeta(&self, beta: c_float);

        /// The value of delta.  Default is 1/1024
        #[unsafe(method(delta))]
        #[unsafe(method_family = none)]
        pub unsafe fn delta(&self) -> c_float;

        /// Setter for [`delta`][Self::delta].
        #[unsafe(method(setDelta:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelta(&self, delta: c_float);

        /// The value of p0.  Default is 1.0
        #[unsafe(method(p0))]
        #[unsafe(method_family = none)]
        pub unsafe fn p0(&self) -> c_float;

        /// Setter for [`p0`][Self::p0].
        #[unsafe(method(setP0:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setP0(&self, p0: c_float);

        /// The value of pm.  Default is 0.0
        #[unsafe(method(pm))]
        #[unsafe(method_family = none)]
        pub unsafe fn pm(&self) -> c_float;

        /// Setter for [`pm`][Self::pm].
        #[unsafe(method(setPm:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPm(&self, pm: c_float);

        /// The value of ps.  Default is 1.0
        #[unsafe(method(ps))]
        #[unsafe(method_family = none)]
        pub unsafe fn ps(&self) -> c_float;

        /// Setter for [`ps`][Self::ps].
        #[unsafe(method(setPs:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPs(&self, ps: c_float);

        #[unsafe(method(kernelWidth))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelWidth(&self) -> NSUInteger;

        #[unsafe(method(kernelHeight))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelHeight(&self) -> NSUInteger;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNLocalContrastNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing MPSCNNCrossChannelNormalization
    ///
    /// The normalized output is given by:
    /// Y(i,j,k) = X(i,j,k) / L(i,j,k)^beta,
    /// where the normalizing factor is:
    /// L(i,j,k) = delta + alpha/N * (sum_{q in Q(k)} X(i,j,q)^2, where
    /// N is the kernel size. The window Q(k) itself is defined as:
    /// Q(k) = [max(0, k-floor(N/2)), min(D-1, k+floor((N-1)/2)], where
    ///
    /// k is the feature channel index (running from 0 to D-1) and
    /// D is the number of feature channels, and alpha, beta and delta are paremeters.
    ///
    /// ```text
    ///         Defaults:
    ///              alpha = 1.0f
    ///              beta  = 5.0f
    ///              delta = 1.0f
    ///              kernelHeight = kernelWidth = kernelSize
    /// ```
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnncrosschannelnormalizationnode?language=objc)
    #[unsafe(super(MPSCNNNormalizationNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNCrossChannelNormalizationNode;
);

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

impl MPSCNNCrossChannelNormalizationNode {
    extern_methods!(
        #[unsafe(method(kernelSizeInFeatureChannels))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelSizeInFeatureChannels(&self) -> NSUInteger;

        /// Setter for [`kernelSizeInFeatureChannels`][Self::kernelSizeInFeatureChannels].
        #[unsafe(method(setKernelSizeInFeatureChannels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKernelSizeInFeatureChannels(
            &self,
            kernel_size_in_feature_channels: NSUInteger,
        );

        #[unsafe(method(nodeWithSource:kernelSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_kernelSize(
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:kernelSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_kernelSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `MPSCNNNormalizationNode`.
impl MPSCNNCrossChannelNormalizationNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNCrossChannelNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNCrossChannelNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:kernelSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_kernelSize(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:kernelSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_kernelSize(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            kernel_size: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(kernelSize))]
        #[unsafe(method_family = none)]
        pub unsafe fn kernelSize(&self) -> NSUInteger;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNCrossChannelNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNInstanceNormalizationNode {}
);

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

impl MPSCNNInstanceNormalizationNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// The training style of the forward node will be propagated to gradient nodes made from it
        #[unsafe(method(trainingStyle))]
        #[unsafe(method_family = none)]
        pub unsafe fn trainingStyle(&self) -> MPSNNTrainingStyle;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`trainingStyle`][Self::trainingStyle].
        #[unsafe(method(setTrainingStyle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTrainingStyle(&self, training_style: MPSNNTrainingStyle);

        #[cfg(feature = "MPSCNNInstanceNormalization")]
        #[unsafe(method(nodeWithSource:dataSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_dataSource(
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNInstanceNormalizationDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNInstanceNormalization")]
        #[unsafe(method(initWithSource:dataSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_dataSource(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNInstanceNormalizationDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNInstanceNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNInstanceNormalizationGradientNode {}
);

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

impl MPSCNNInstanceNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNInstanceNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNGroupNormalizationNode {}
);

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

impl MPSCNNGroupNormalizationNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// The training style of the forward node will be propagated to gradient nodes made from it
        #[unsafe(method(trainingStyle))]
        #[unsafe(method_family = none)]
        pub unsafe fn trainingStyle(&self) -> MPSNNTrainingStyle;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`trainingStyle`][Self::trainingStyle].
        #[unsafe(method(setTrainingStyle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTrainingStyle(&self, training_style: MPSNNTrainingStyle);

        #[cfg(feature = "MPSCNNGroupNormalization")]
        #[unsafe(method(nodeWithSource:dataSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_dataSource(
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNGroupNormalizationDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNGroupNormalization")]
        #[unsafe(method(initWithSource:dataSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_dataSource(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNGroupNormalizationDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNGroupNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNGroupNormalizationGradientNode {}
);

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

impl MPSCNNGroupNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNGroupNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing batch normalization for inference or training
    ///
    /// Batch normalization operates differently for inference and training.
    /// For inference, the normalization is done according to a static statistical
    /// representation of data saved during training. For training, this representation
    /// is ever evolving.  In the low level MPS batch normalization interface,
    /// during training, the batch normalization is broken up into two steps:
    /// calculation of the statistical representation of input data, followed
    /// by normalization once the statistics are known for the entire batch.
    /// These are MPSCNNBatchNormalizationStatistics and MPSCNNBatchNormalization,
    /// respectively.
    ///
    /// When this node appears in a graph and is not required to produce a
    /// MPSCNNBatchNormalizationState -- that is, MPSCNNBatchNormalizationNode.resultState
    /// is not used within the graph -- then it operates in inference mode
    /// and new batch-only statistics are not calculated. When this state node
    /// is consumed, then the node is assumed to be in training mode and
    /// new statistics will be calculated and written to the MPSCNNBatchNormalizationState
    /// and passed along to the MPSCNNBatchNormalizationGradient and
    /// MPSCNNBatchNormalizationStatisticsGradient as necessary. This should
    /// allow you to construct an identical sequence of nodes for inference
    /// and training and expect the right thing to happen.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnbatchnormalizationnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNBatchNormalizationNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNBatchNormalizationNode {}
);

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

impl MPSCNNBatchNormalizationNode {
    extern_methods!(
        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Options controlling how batch normalization is calculated
        ///
        /// Default: MPSCNNBatchNormalizationFlagsDefault
        #[unsafe(method(flags))]
        #[unsafe(method_family = none)]
        pub unsafe fn flags(&self) -> MPSCNNBatchNormalizationFlags;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`flags`][Self::flags].
        #[unsafe(method(setFlags:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFlags(&self, flags: MPSCNNBatchNormalizationFlags);

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// The training style of the forward node will be propagated to gradient nodes made from it
        #[unsafe(method(trainingStyle))]
        #[unsafe(method_family = none)]
        pub unsafe fn trainingStyle(&self) -> MPSNNTrainingStyle;

        #[cfg(feature = "MPSNeuralNetworkTypes")]
        /// Setter for [`trainingStyle`][Self::trainingStyle].
        #[unsafe(method(setTrainingStyle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTrainingStyle(&self, training_style: MPSNNTrainingStyle);

        #[cfg(feature = "MPSCNNBatchNormalization")]
        #[unsafe(method(nodeWithSource:dataSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_dataSource(
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNBatchNormalizationDataSource>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNBatchNormalization")]
        #[unsafe(method(initWithSource:dataSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_dataSource(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            data_source: &ProtocolObject<dyn MPSCNNBatchNormalizationDataSource>,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNBatchNormalizationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node representing batch normalization gradient for training
    ///
    /// This filter encapsulates the MPSCNNBatchNormalizationStatisticsGradient
    /// and MPSCNNBatchNormalizationGradient low level filters as a single
    /// node. They will be called in sequence: statistics gradient until the
    /// batch is complete, then batch normalization gradient on the result.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnbatchnormalizationgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNBatchNormalizationGradientNode;
);

extern_conformance!(
    unsafe impl MPSNNTrainableNode for MPSCNNBatchNormalizationGradientNode {}
);

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

impl MPSCNNBatchNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNBatchNormalizationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsimagetransformprovider?language=objc)
    pub unsafe trait MPSImageTransformProvider: NSSecureCoding + NSObjectProtocol {
        #[cfg(all(feature = "MPSCore", feature = "MPSCoreTypes", feature = "MPSImage"))]
        #[unsafe(method(transformForSourceImage:handle:))]
        #[unsafe(method_family = none)]
        unsafe fn transformForSourceImage_handle(
            &self,
            image: &MPSImage,
            handle: Option<&ProtocolObject<dyn MPSHandle>>,
        ) -> MPSScaleTransform;
    }
);

extern_class!(
    /// Abstract Node representing a image resampling operation
    ///
    /// Please make a MPSNNBilinearScale or MPSNNLanczosScale object instead
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnscalenode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNScaleNode;
);

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

impl MPSNNScaleNode {
    extern_methods!(
        /// create an autoreleased node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_outputSize(
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// create an autoreleased node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_transformProvider_outputSize(
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_transformProvider_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNScaleNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNScale object that uses bilinear interpolation for resampling
    ///
    /// Caution: bilinear downscaling by more than a factor of
    /// two in any dimension causes loss of information if a
    /// low pass filter is not run over the image first. Details
    /// may be omitted.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnbilinearscalenode?language=objc)
    #[unsafe(super(MPSNNScaleNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNBilinearScaleNode;
);

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

impl MPSNNBilinearScaleNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNScaleNode`.
impl MPSNNBilinearScaleNode {
    extern_methods!(
        /// create an autoreleased node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_outputSize(
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// create an autoreleased node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_transformProvider_outputSize(
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_transformProvider_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNBilinearScaleNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNScale object that uses the Lanczos resampling filter
    ///
    /// This method does not require a low pass filter for downsampling
    /// by more than a factor of two. Caution: may cause ringing, which
    /// could prove distracting to a neural network unused to seeing it.
    /// You should use the resampling method that was used to train the
    /// network.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnlanczosscalenode?language=objc)
    #[unsafe(super(MPSNNScaleNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNLanczosScaleNode;
);

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

impl MPSNNLanczosScaleNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNScaleNode`.
impl MPSNNLanczosScaleNode {
    extern_methods!(
        /// create an autoreleased node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_outputSize(
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// create an autoreleased node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(nodeWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_transformProvider_outputSize(
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            size: MTLSize,
        ) -> Retained<Self>;

        /// init a node to convert a MPSImage to the desired size for a region of interest
        ///
        /// Parameter `sourceNode`: A valid MPSNNImageNode
        ///
        /// Parameter `transformProvider`: If non-nil, a valid MPSImageTransformProvider that provides the region of interest
        ///
        /// Parameter `size`: The size of the output image {width, height, depth}
        #[unsafe(method(initWithSource:transformProvider:outputSize:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_transformProvider_outputSize(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            transform_provider: Option<&ProtocolObject<dyn MPSImageTransformProvider>>,
            size: MTLSize,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNLanczosScaleNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// virtual base class for basic arithmetic nodes
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnbinaryarithmeticnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNBinaryArithmeticNode;
);

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

impl MPSNNBinaryArithmeticNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        #[unsafe(method(gradientClass))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientClass(&self) -> &'static AnyClass;

        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;

        /// create new arithmetic gradient nodes
        ///
        /// Create two new arithmetic gradient nodes - one that computes the gradient for the primary
        /// source image and one that computes the gradient for the secondary sourcefrom the inference pass.
        #[unsafe(method(gradientFiltersWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<NSArray<MPSNNGradientFilterNode>>;

        #[unsafe(method(primaryScale))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryScale(&self) -> c_float;

        /// Setter for [`primaryScale`][Self::primaryScale].
        #[unsafe(method(setPrimaryScale:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPrimaryScale(&self, primary_scale: c_float);

        #[unsafe(method(secondaryScale))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryScale(&self) -> c_float;

        /// Setter for [`secondaryScale`][Self::secondaryScale].
        #[unsafe(method(setSecondaryScale:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryScale(&self, secondary_scale: c_float);

        #[unsafe(method(bias))]
        #[unsafe(method_family = none)]
        pub unsafe fn bias(&self) -> c_float;

        /// Setter for [`bias`][Self::bias].
        #[unsafe(method(setBias:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBias(&self, bias: c_float);

        #[unsafe(method(primaryStrideInPixelsX))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryStrideInPixelsX(&self) -> NSUInteger;

        /// Setter for [`primaryStrideInPixelsX`][Self::primaryStrideInPixelsX].
        #[unsafe(method(setPrimaryStrideInPixelsX:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPrimaryStrideInPixelsX(&self, primary_stride_in_pixels_x: NSUInteger);

        #[unsafe(method(primaryStrideInPixelsY))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryStrideInPixelsY(&self) -> NSUInteger;

        /// Setter for [`primaryStrideInPixelsY`][Self::primaryStrideInPixelsY].
        #[unsafe(method(setPrimaryStrideInPixelsY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPrimaryStrideInPixelsY(&self, primary_stride_in_pixels_y: NSUInteger);

        #[unsafe(method(primaryStrideInFeatureChannels))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryStrideInFeatureChannels(&self) -> NSUInteger;

        /// Setter for [`primaryStrideInFeatureChannels`][Self::primaryStrideInFeatureChannels].
        #[unsafe(method(setPrimaryStrideInFeatureChannels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPrimaryStrideInFeatureChannels(
            &self,
            primary_stride_in_feature_channels: NSUInteger,
        );

        #[unsafe(method(secondaryStrideInPixelsX))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInPixelsX(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInPixelsX`][Self::secondaryStrideInPixelsX].
        #[unsafe(method(setSecondaryStrideInPixelsX:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInPixelsX(&self, secondary_stride_in_pixels_x: NSUInteger);

        #[unsafe(method(secondaryStrideInPixelsY))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInPixelsY(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInPixelsY`][Self::secondaryStrideInPixelsY].
        #[unsafe(method(setSecondaryStrideInPixelsY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInPixelsY(&self, secondary_stride_in_pixels_y: NSUInteger);

        #[unsafe(method(secondaryStrideInFeatureChannels))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInFeatureChannels(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInFeatureChannels`][Self::secondaryStrideInFeatureChannels].
        #[unsafe(method(setSecondaryStrideInFeatureChannels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInFeatureChannels(
            &self,
            secondary_stride_in_feature_channels: NSUInteger,
        );

        #[unsafe(method(minimumValue))]
        #[unsafe(method_family = none)]
        pub unsafe fn minimumValue(&self) -> c_float;

        /// Setter for [`minimumValue`][Self::minimumValue].
        #[unsafe(method(setMinimumValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMinimumValue(&self, minimum_value: c_float);

        #[unsafe(method(maximumValue))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumValue(&self) -> c_float;

        /// Setter for [`maximumValue`][Self::maximumValue].
        #[unsafe(method(setMaximumValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumValue(&self, maximum_value: c_float);
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNBinaryArithmeticNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns elementwise sum of left + right
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnadditionnode?language=objc)
    #[unsafe(super(MPSNNBinaryArithmeticNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNAdditionNode;
);

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

impl MPSNNAdditionNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNBinaryArithmeticNode`.
impl MPSNNAdditionNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNAdditionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns elementwise difference of left - right
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnsubtractionnode?language=objc)
    #[unsafe(super(MPSNNBinaryArithmeticNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNSubtractionNode;
);

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

impl MPSNNSubtractionNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNBinaryArithmeticNode`.
impl MPSNNSubtractionNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNSubtractionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns elementwise product of left * right
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnmultiplicationnode?language=objc)
    #[unsafe(super(MPSNNBinaryArithmeticNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNMultiplicationNode;
);

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

impl MPSNNMultiplicationNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNBinaryArithmeticNode`.
impl MPSNNMultiplicationNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNMultiplicationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns elementwise quotient of left / right
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnndivisionnode?language=objc)
    #[unsafe(super(MPSNNBinaryArithmeticNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNDivisionNode;
);

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

impl MPSNNDivisionNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNBinaryArithmeticNode`.
impl MPSNNDivisionNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNDivisionNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns elementwise comparison of left and right
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnncomparisonnode?language=objc)
    #[unsafe(super(MPSNNBinaryArithmeticNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNComparisonNode;
);

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

impl MPSNNComparisonNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNMath")]
        /// The comparison type to set on the underlying kernel.  Defaults
        /// to MPSNNComparisonTypeEqual.
        #[unsafe(method(comparisonType))]
        #[unsafe(method_family = none)]
        pub unsafe fn comparisonType(&self) -> MPSNNComparisonType;

        #[cfg(feature = "MPSCNNMath")]
        /// Setter for [`comparisonType`][Self::comparisonType].
        #[unsafe(method(setComparisonType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setComparisonType(&self, comparison_type: MPSNNComparisonType);
    );
}

/// Methods declared on superclass `MPSNNBinaryArithmeticNode`.
impl MPSNNComparisonNode {
    extern_methods!(
        /// create an autoreleased arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// create an autoreleased arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(nodeWithLeftSource:rightSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithLeftSource_rightSource(
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// init an arithemtic node with an array of sources
        ///
        /// Parameter `sourceNodes`: A valid NSArray containing two sources
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// init an arithemtic node with two sources
        ///
        /// Parameter `left`: the left operand
        ///
        /// Parameter `right`: the right operand
        #[unsafe(method(initWithLeftSource:rightSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithLeftSource_rightSource(
            this: Allocated<Self>,
            left: &MPSNNImageNode,
            right: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNComparisonNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNArithmeticGradientNode {
    extern_methods!(
        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `gradientImages`: The input gradient from the 'downstream' gradient filter and the source input image
        /// from the forward pass (primary or secondary).
        ///
        /// Parameter `filter`: The matching filter node from the forward pass.
        ///
        /// Parameter `isSecondarySourceFilter`: The isSecondarySourceFilter property is used to indicate whether the arithmetic
        /// gradient filter is operating on the primary or secondary source image from the
        /// forward pass.
        #[unsafe(method(initWithGradientImages:forwardFilter:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithGradientImages_forwardFilter_isSecondarySourceFilter(
            this: Allocated<Self>,
            gradient_images: &NSArray<MPSNNImageNode>,
            filter: &MPSNNFilterNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        #[unsafe(method(primaryScale))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryScale(&self) -> c_float;

        /// Setter for [`primaryScale`][Self::primaryScale].
        #[unsafe(method(setPrimaryScale:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPrimaryScale(&self, primary_scale: c_float);

        #[unsafe(method(secondaryScale))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryScale(&self) -> c_float;

        /// Setter for [`secondaryScale`][Self::secondaryScale].
        #[unsafe(method(setSecondaryScale:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryScale(&self, secondary_scale: c_float);

        #[unsafe(method(bias))]
        #[unsafe(method_family = none)]
        pub unsafe fn bias(&self) -> c_float;

        /// Setter for [`bias`][Self::bias].
        #[unsafe(method(setBias:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBias(&self, bias: c_float);

        #[unsafe(method(secondaryStrideInPixelsX))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInPixelsX(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInPixelsX`][Self::secondaryStrideInPixelsX].
        #[unsafe(method(setSecondaryStrideInPixelsX:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInPixelsX(&self, secondary_stride_in_pixels_x: NSUInteger);

        #[unsafe(method(secondaryStrideInPixelsY))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInPixelsY(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInPixelsY`][Self::secondaryStrideInPixelsY].
        #[unsafe(method(setSecondaryStrideInPixelsY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInPixelsY(&self, secondary_stride_in_pixels_y: NSUInteger);

        #[unsafe(method(secondaryStrideInFeatureChannels))]
        #[unsafe(method_family = none)]
        pub unsafe fn secondaryStrideInFeatureChannels(&self) -> NSUInteger;

        /// Setter for [`secondaryStrideInFeatureChannels`][Self::secondaryStrideInFeatureChannels].
        #[unsafe(method(setSecondaryStrideInFeatureChannels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSecondaryStrideInFeatureChannels(
            &self,
            secondary_stride_in_feature_channels: NSUInteger,
        );

        #[unsafe(method(minimumValue))]
        #[unsafe(method_family = none)]
        pub unsafe fn minimumValue(&self) -> c_float;

        /// Setter for [`minimumValue`][Self::minimumValue].
        #[unsafe(method(setMinimumValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMinimumValue(&self, minimum_value: c_float);

        #[unsafe(method(maximumValue))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumValue(&self) -> c_float;

        /// Setter for [`maximumValue`][Self::maximumValue].
        #[unsafe(method(setMaximumValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumValue(&self, maximum_value: c_float);

        #[unsafe(method(isSecondarySourceFilter))]
        #[unsafe(method_family = none)]
        pub unsafe fn isSecondarySourceFilter(&self) -> bool;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNArithmeticGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns gradient for either primary or secondary source image from the inference pass.
    /// Use the isSecondarySourceFilter property to indicate whether this filter is computing the gradient
    /// for the primary or secondary source image from the inference pass.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnadditiongradientnode?language=objc)
    #[unsafe(super(
        MPSNNArithmeticGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNAdditionGradientNode;
);

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

impl MPSNNAdditionGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNArithmeticGradientNode`.
impl MPSNNAdditionGradientNode {
    extern_methods!(
        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `gradientImages`: The input gradient from the 'downstream' gradient filter and the source input image
        /// from the forward pass (primary or secondary).
        ///
        /// Parameter `filter`: The matching filter node from the forward pass.
        ///
        /// Parameter `isSecondarySourceFilter`: The isSecondarySourceFilter property is used to indicate whether the arithmetic
        /// gradient filter is operating on the primary or secondary source image from the
        /// forward pass.
        #[unsafe(method(initWithGradientImages:forwardFilter:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithGradientImages_forwardFilter_isSecondarySourceFilter(
            this: Allocated<Self>,
            gradient_images: &NSArray<MPSNNImageNode>,
            filter: &MPSNNFilterNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNAdditionGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns gradient for either primary or secondary source image from the inference pass.
    /// Use the isSecondarySourceFilter property to indicate whether this filter is computing the gradient
    /// for the primary or secondary source image from the inference pass.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnsubtractiongradientnode?language=objc)
    #[unsafe(super(
        MPSNNArithmeticGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNSubtractionGradientNode;
);

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

impl MPSNNSubtractionGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNArithmeticGradientNode`.
impl MPSNNSubtractionGradientNode {
    extern_methods!(
        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `gradientImages`: The input gradient from the 'downstream' gradient filter and the source input image
        /// from the forward pass (primary or secondary).
        ///
        /// Parameter `filter`: The matching filter node from the forward pass.
        ///
        /// Parameter `isSecondarySourceFilter`: The isSecondarySourceFilter property is used to indicate whether the arithmetic
        /// gradient filter is operating on the primary or secondary source image from the
        /// forward pass.
        #[unsafe(method(initWithGradientImages:forwardFilter:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithGradientImages_forwardFilter_isSecondarySourceFilter(
            this: Allocated<Self>,
            gradient_images: &NSArray<MPSNNImageNode>,
            filter: &MPSNNFilterNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNSubtractionGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// returns gradient for either primary or secondary source image from the inference pass.
    /// Use the isSecondarySourceFilter property to indicate whether this filter is computing the gradient
    /// for the primary or secondary source image from the inference pass.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnmultiplicationgradientnode?language=objc)
    #[unsafe(super(
        MPSNNArithmeticGradientNode,
        MPSNNGradientFilterNode,
        MPSNNFilterNode,
        NSObject
    ))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNMultiplicationGradientNode;
);

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

impl MPSNNMultiplicationGradientNode {
    extern_methods!();
}

/// Methods declared on superclass `MPSNNArithmeticGradientNode`.
impl MPSNNMultiplicationGradientNode {
    extern_methods!(
        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The source input image from the forward pass (primary or secondary).
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter.
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_isSecondarySourceFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNBinaryGradientStateNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;

        /// create a new arithmetic gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodesWithSources:]
        /// for an easier way to do this.
        ///
        /// Parameter `gradientImages`: The input gradient from the 'downstream' gradient filter and the source input image
        /// from the forward pass (primary or secondary).
        ///
        /// Parameter `filter`: The matching filter node from the forward pass.
        ///
        /// Parameter `isSecondarySourceFilter`: The isSecondarySourceFilter property is used to indicate whether the arithmetic
        /// gradient filter is operating on the primary or secondary source image from the
        /// forward pass.
        #[unsafe(method(initWithGradientImages:forwardFilter:isSecondarySourceFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithGradientImages_forwardFilter_isSecondarySourceFilter(
            this: Allocated<Self>,
            gradient_images: &NSArray<MPSNNImageNode>,
            filter: &MPSNNFilterNode,
            is_secondary_source_filter: bool,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNMultiplicationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNDropoutNode {
    extern_methods!(
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source: &MPSNNImageNode) -> Retained<Self>;

        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
        ) -> Retained<Self>;

        #[unsafe(method(nodeWithSource:keepProbability:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_keepProbability(
            source: &MPSNNImageNode,
            keep_probability: c_float,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:keepProbability:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_keepProbability(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            keep_probability: c_float,
        ) -> Retained<Self>;

        #[unsafe(method(nodeWithSource:keepProbability:seed:maskStrideInPixels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_keepProbability_seed_maskStrideInPixels(
            source: &MPSNNImageNode,
            keep_probability: c_float,
            seed: NSUInteger,
            mask_stride_in_pixels: MTLSize,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSource:keepProbability:seed:maskStrideInPixels:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_keepProbability_seed_maskStrideInPixels(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            keep_probability: c_float,
            seed: NSUInteger,
            mask_stride_in_pixels: MTLSize,
        ) -> Retained<Self>;

        #[unsafe(method(keepProbability))]
        #[unsafe(method_family = none)]
        pub unsafe fn keepProbability(&self) -> c_float;

        #[unsafe(method(seed))]
        #[unsafe(method_family = none)]
        pub unsafe fn seed(&self) -> NSUInteger;

        #[unsafe(method(maskStrideInPixels))]
        #[unsafe(method_family = none)]
        pub unsafe fn maskStrideInPixels(&self) -> MTLSize;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNDropoutNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSCNNDropoutGradientNode {
    extern_methods!(
        /// create a new dropout gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodeWithSources:]
        /// for an easier way to do this
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:keepProbability:seed:maskStrideInPixels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_keepProbability_seed_maskStrideInPixels(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            keep_probability: c_float,
            seed: NSUInteger,
            mask_stride_in_pixels: MTLSize,
        ) -> Retained<Self>;

        /// create a new dropout gradient node
        ///
        /// See also -[MPSCNNNeuronNode gradientFilterNodeWithSources:]
        /// for an easier way to do this
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:keepProbability:seed:maskStrideInPixels:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_keepProbability_seed_maskStrideInPixels(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            keep_probability: c_float,
            seed: NSUInteger,
            mask_stride_in_pixels: MTLSize,
        ) -> Retained<Self>;

        #[unsafe(method(keepProbability))]
        #[unsafe(method_family = none)]
        pub unsafe fn keepProbability(&self) -> c_float;

        #[unsafe(method(seed))]
        #[unsafe(method_family = none)]
        pub unsafe fn seed(&self) -> NSUInteger;

        #[unsafe(method(maskStrideInPixels))]
        #[unsafe(method_family = none)]
        pub unsafe fn maskStrideInPixels(&self) -> MTLSize;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNDropoutGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// The labels and weights for each MPSImage are passed in
    /// separately to the graph in a MPSNNLabels object. If
    /// the batch interface is used then there will be a
    /// MPSStateBatch of these of the same size as the MPSImageBatch
    /// that holds the images.  The MPSNNLabelsNode is a place
    /// holder in the graph for these nodes. The MPSNNLabels node
    /// is taken as an input to the Loss node
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnlabelsnode?language=objc)
    #[unsafe(super(MPSNNStateNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNLabelsNode;
);

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

impl MPSNNLabelsNode {
    extern_methods!();
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNLabelsNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// This node calculates loss information during training
    /// typically immediately after the inference portion
    /// of network evaluation is performed. The result image
    /// of the loss operations is typically the first gradient
    /// image to be comsumed by the gradient passes that work
    /// their way back up the graph. In addition, the node will
    /// update the loss image in the MPSNNLabels with the
    /// desired estimate of correctness.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnlossnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNLossNode;
);

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

impl MPSCNNLossNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSource:lossDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_lossDescriptor(
            source: &MPSNNImageNode,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSource:lossDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_lossDescriptor(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        /// Get the input node for labes and weights, for example to set the handle
        #[unsafe(method(inputLabels))]
        #[unsafe(method_family = none)]
        pub unsafe fn inputLabels(&self) -> Retained<MPSNNLabelsNode>;

        /// The loss filter is its own gradient filter and doesn't provide a corresponding gradient node.
        ///
        /// The image returned by the loss filter is the gradient image to be consumed by
        /// the gradient filters corresponding to preceeding inference nodes.
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNLossNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// This node calculates loss information during training
    /// typically immediately after the inference portion
    /// of network evaluation is performed. The result image
    /// of the loss operations is typically the first gradient
    /// image to be comsumed by the gradient passes that work
    /// their way back up the graph. In addition, the node will
    /// update the loss image in the MPSNNLabels with the
    /// desired estimate of correctness.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnyololossnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNYOLOLossNode;
);

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

impl MPSCNNYOLOLossNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSource:lossDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_lossDescriptor(
            source: &MPSNNImageNode,
            descriptor: &MPSCNNYOLOLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSource:lossDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_lossDescriptor(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            descriptor: &MPSCNNYOLOLossDescriptor,
        ) -> Retained<Self>;

        /// Get the input node for labes and weights, for example to set the handle
        #[unsafe(method(inputLabels))]
        #[unsafe(method_family = none)]
        pub unsafe fn inputLabels(&self) -> Retained<MPSNNLabelsNode>;

        /// The loss filter is its own gradient filter and doesn't provide a corresponding gradient node.
        ///
        /// The image returned by the loss filter is the gradient image to be consumed by
        /// the gradient filters corresponding to preceeding inference nodes.
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNYOLOLossNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a the concatenation (in the feature channel dimension) of the results from one or more kernels
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnconcatenationnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNConcatenationNode;
);

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

impl MPSNNConcatenationNode {
    extern_methods!(
        /// Init a autoreleased node that concatenates feature channels from multiple images
        ///
        /// In some neural network designs, it is necessary to append feature channels
        /// from one neural network filter to the results of another. If we have three
        /// image nodes with M, N and O feature channels in them, passed to -initWithSources:
        /// as
        /// @
        /// [imageM, imageN, imageO], then feature channels [0,M-1] will be drawn from
        /// image M,  feature channels [M, M+N-1] will be drawn from image N and feature channels
        /// [M+N, M+N+O-1] will be drawn from image O.
        ///
        /// As all images are padded out to a multiple of four feature channels,
        /// M, N and O here are also multiples of four, even when the MPSImages
        /// are not. That is, if the image is 23 feature channels and one channel
        /// of padding, it takes up 24 feature channels worth of space in the
        /// concatenated result.
        ///
        /// Performance Note:  Generally, concatenation is free as long as all
        /// of the sourceNodes are produced by filters in the same MPSNNGraph.
        /// Most MPSCNNKernels have the ability to write their results  at a
        /// feature channel offset within a target MPSImage. However, if the
        /// MPSNNImageNode source nodes come from images external to the MPSNNGraph,
        /// then we have to do a copy operation to assemble the concatenated node.
        /// As a result, when deciding where to break a large logical graph into
        /// multiple smaller MPSNNGraphs, it is better for concatenations to
        /// appear at the ends of subgraphs when possible rather than at the start,
        /// to the extent that all the images used in the concatenation are
        /// produced by that subgraph.
        ///
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        ///
        /// Returns: A new MPSNNFilter node that concatenates its inputs.
        #[unsafe(method(nodeWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources(source_nodes: &NSArray<MPSNNImageNode>) -> Retained<Self>;

        /// Init a node that concatenates feature channels from multiple images
        ///
        /// In some neural network designs, it is necessary to append feature channels
        /// from one neural network filter to the results of another. If we have three
        /// image nodes with M, N and O feature channels in them, passed to -initWithSources:
        /// as
        /// @
        /// [imageM, imageN, imageO], then feature channels [0,M-1] will be drawn from
        /// image M,  feature channels [M, M+N-1] will be drawn from image N and feature channels
        /// [M+N, M+N+O-1] will be drawn from image O.
        ///
        /// As all images are padded out to a multiple of four feature channels,
        /// M, N and O here are also multiples of four, even when the MPSImages
        /// are not. That is, if the image is 23 feature channels and one channel
        /// of padding, it takes up 24 feature channels worth of space in the
        /// concatenated result.
        ///
        /// Performance Note:  Generally, concatenation is free as long as all
        /// of the sourceNodes are produced by filters in the same MPSNNGraph.
        /// Most MPSCNNKernels have the ability to write their results  at a
        /// feature channel offset within a target MPSImage. However, if the
        /// MPSNNImageNode source nodes come from images external to the MPSNNGraph,
        /// then we have to do a copy operation to assemble the concatenated node.
        /// As a result, when deciding where to break a large logical graph into
        /// multiple smaller MPSNNGraphs, it is better for concatenations to
        /// appear at the ends of subgraphs when possible rather than at the start,
        /// to the extent that all the images used in the concatenation are
        /// produced by that subgraph.
        ///
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        ///
        /// Returns: A new MPSNNFilter node that concatenates its inputs.
        #[unsafe(method(initWithSources:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
        ) -> Retained<Self>;

        /// Concatenation returns multiple gradient filters. Use -gradientFiltersWithSources: instead.
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNConcatenationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A MPSNNSlice filter that operates as the conjugate computation for concatentation operators during training
    ///
    /// As concatenation is formally just a copy and not a computation, there isn't a lot of arithmetic for
    /// the slice operator to do, but we still need to extract out the relevant portion
    /// of the gradient of the input signal that went into the corresponding concatenation
    /// destination image.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnconcatenationgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNConcatenationGradientNode;
);

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

impl MPSNNConcatenationGradientNode {
    extern_methods!(
        /// create a MPSNNConcatenationGradientNode
        ///
        /// Generally you should use [MPSNNConcatenationNode gradientFiltersWithSources:] instead.
        ///
        /// Parameter `gradientSourceNode`: The gradient image functioning as input for the operator
        ///
        /// Parameter `sourceImage`: The particular input image to the concatentation, if any, that the slice corresponds with
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            gradient_source_node: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        /// Init a MPSNNConcatenationGradientNode
        ///
        /// Generally you should use [MPSNNConcatenationNode gradientFiltersWithSources:] instead.
        ///
        /// Parameter `gradientSourceNode`: The gradient image functioning as input for the operator
        ///
        /// Parameter `sourceImage`: The particular input image to the concatentation, if any, that the slice corresponds with
        ///
        /// Parameter `gradientState`: The gradient state produced by the concatenation filter, consumed by this filter
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            gradient_source_node: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNConcatenationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a MPSNNReshape kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnreshapenode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNReshapeNode;
);

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

impl MPSNNReshapeNode {
    extern_methods!(
        /// Init a node representing a autoreleased MPSNNReshape kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `resultWidth`: The width of the reshaped image.
        ///
        /// Parameter `resultHeight`: The height of the reshaped image.
        ///
        /// Parameter `resultFeatureChannels`: The number of feature channels in the reshaped image.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNReshape kernel.
        #[unsafe(method(nodeWithSource:resultWidth:resultHeight:resultFeatureChannels:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_resultWidth_resultHeight_resultFeatureChannels(
            source: &MPSNNImageNode,
            result_width: NSUInteger,
            result_height: NSUInteger,
            result_feature_channels: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSNNReshape kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `resultWidth`: The width of the reshaped image.
        ///
        /// Parameter `resultHeight`: The height of the reshaped image.
        ///
        /// Parameter `resultFeatureChannels`: The number of feature channels in the reshaped image.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNReshape kernel.
        #[unsafe(method(initWithSource:resultWidth:resultHeight:resultFeatureChannels:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_resultWidth_resultHeight_resultFeatureChannels(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            result_width: NSUInteger,
            result_height: NSUInteger,
            result_feature_channels: NSUInteger,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReshapeNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReshapeGradientNode {
    extern_methods!(
        /// A node to represent the gradient of a reshape node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward reshape node.
        ///
        /// Returns: A MPSNNReshapeGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        /// A node to represent the gradient of a reshape node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward reshape node.
        ///
        /// Returns: A MPSCNNConvolutionGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReshapeGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNReductionSpatialMeanGradientNode {
    extern_methods!(
        /// A node to represent the gradient of a spatial mean reduction node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward spatial mean reduction node.
        ///
        /// Returns: A MPSNNReductionSpatialMeanGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        /// A node to represent the gradient of a spatial mean reduction node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward spatial mean reduction node.
        ///
        /// Returns: A MPSNNReductionSpatialMeanGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNReductionSpatialMeanGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a MPSNNPad kernel
    ///
    /// You should not use this node to zero pad your data in the XY-plane.
    /// This node copies the input image and therefore should only be used in
    /// special circumstances where the normal padding operation, defined for most
    /// filters and nodes through
    /// MPSNNPadding,cannot achieve the necessary padding.
    /// Therefore use this node only when you need one of the special edge modes:
    /// MPSImageEdgeModeConstant,MPSImageEdgeModeMirror,MPSImageEdgeModeMirrorWithEdgeor, if you need padding in the
    /// feature-channel dimesion.
    /// In other cases use to
    /// MPSNNPaddingto get best performance.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnpadnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNPadNode;
);

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

impl MPSNNPadNode {
    extern_methods!(
        /// Determines the constant value to apply when using
        /// MPSImageEdgeModeConstant.Default: 0.0f.
        #[unsafe(method(fillValue))]
        #[unsafe(method_family = none)]
        pub unsafe fn fillValue(&self) -> c_float;

        /// Setter for [`fillValue`][Self::fillValue].
        #[unsafe(method(setFillValue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFillValue(&self, fill_value: c_float);

        #[cfg(all(feature = "MPSCore", feature = "MPSCoreTypes"))]
        /// Init a node representing a autoreleased MPSNNPad kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `paddingSizeBefore`: The amount of padding to apply before the image in each dimension.
        ///
        /// Parameter `paddingSizeAfter`: The amount of padding to apply after the image in each dimension.
        ///
        /// Parameter `edgeMode`: The
        /// MPSImageEdgeModefor the padding node - Note that for now
        /// the pad-node and its gradient are the only nodes that support
        /// the extended edge-modes, ie. the ones beyond MPSImageEdgeModeClamp.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNPad kernel.
        #[unsafe(method(nodeWithSource:paddingSizeBefore:paddingSizeAfter:edgeMode:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_paddingSizeBefore_paddingSizeAfter_edgeMode(
            source: &MPSNNImageNode,
            padding_size_before: MPSImageCoordinate,
            padding_size_after: MPSImageCoordinate,
            edge_mode: MPSImageEdgeMode,
        ) -> Retained<Self>;

        #[cfg(all(feature = "MPSCore", feature = "MPSCoreTypes"))]
        /// Init a node representing a MPSNNPad kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `paddingSizeBefore`: The amount of padding to apply before the image in each dimension.
        ///
        /// Parameter `paddingSizeAfter`: The amount of padding to apply after the image in each dimension.
        ///
        /// Parameter `edgeMode`: The
        /// MPSImageEdgeModefor the padding node - Note that for now
        /// the pad-node and its gradient are the only nodes that support
        /// the extended edge-modes, ie. the ones beyond MPSImageEdgeModeClamp.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNPad kernel.
        #[unsafe(method(initWithSource:paddingSizeBefore:paddingSizeAfter:edgeMode:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_paddingSizeBefore_paddingSizeAfter_edgeMode(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            padding_size_before: MPSImageCoordinate,
            padding_size_after: MPSImageCoordinate,
            edge_mode: MPSImageEdgeMode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNPadNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

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

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

impl MPSNNPadGradientNode {
    extern_methods!(
        /// A node to represent the gradient of a padding node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward padding node.
        ///
        /// Returns: A MPSNNPadGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        /// A node to represent the gradient of a padding node.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward reshape node.
        ///
        /// Returns: A MPSNNPadGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNPadGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNSoftMax kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnsoftmaxnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNSoftMaxNode;
);

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

impl MPSCNNSoftMaxNode {
    extern_methods!(
        /// Init a node representing a autoreleased MPSCNNSoftMax kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNSoftMax kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing a MPSCNNSoftMax kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNSoftMax kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNSoftMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNSoftMaxGradient kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnsoftmaxgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNSoftMaxGradientNode;
);

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

impl MPSCNNSoftMaxGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNSoftMaxGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNLogSoftMax kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnlogsoftmaxnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNLogSoftMaxNode;
);

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

impl MPSCNNLogSoftMaxNode {
    extern_methods!(
        /// Init a node representing a autoreleased MPSCNNLogSoftMax kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNLogSoftMax kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing a MPSCNNLogSoftMax kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNLogSoftMax kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNLogSoftMaxNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNLogSoftMaxGradient kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnlogsoftmaxgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNLogSoftMaxGradientNode;
);

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

impl MPSCNNLogSoftMaxGradientNode {
    extern_methods!(
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNLogSoftMaxGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNUpsamplingNearest kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnupsamplingnearestnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNUpsamplingNearestNode;
);

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

impl MPSCNNUpsamplingNearestNode {
    extern_methods!(
        /// Convenience initializer for an autoreleased MPSCNNUpsamplingNearest nodes
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingNearest kernel.
        #[unsafe(method(nodeWithSource:integerScaleFactorX:integerScaleFactorY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_integerScaleFactorX_integerScaleFactorY(
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNUpsamplingNearest kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingNearest kernel.
        #[unsafe(method(initWithSource:integerScaleFactorX:integerScaleFactorY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_integerScaleFactorX_integerScaleFactorY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
        ) -> Retained<Self>;

        #[unsafe(method(scaleFactorX))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorX(&self) -> c_double;

        #[unsafe(method(scaleFactorY))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorY(&self) -> c_double;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNUpsamplingNearestNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNUpsamplingBilinear kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnupsamplingbilinearnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNUpsamplingBilinearNode;
);

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

impl MPSCNNUpsamplingBilinearNode {
    extern_methods!(
        /// Init a autoreleased node representing a MPSCNNUpsamplingBilinear kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingBilinear kernel.
        #[unsafe(method(nodeWithSource:integerScaleFactorX:integerScaleFactorY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_integerScaleFactorX_integerScaleFactorY(
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
        ) -> Retained<Self>;

        /// Init a autoreleased node representing a MPSCNNUpsamplingBilinear kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Parameter `alignCorners`: Specifier whether the centers of the 4 corner pixels of the input and output regions are aligned,
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingBilinear kernel.
        #[unsafe(method(nodeWithSource:integerScaleFactorX:integerScaleFactorY:alignCorners:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_integerScaleFactorX_integerScaleFactorY_alignCorners(
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
            align_corners: bool,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNUpsamplingBilinear kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingBilinear kernel.
        #[unsafe(method(initWithSource:integerScaleFactorX:integerScaleFactorY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_integerScaleFactorX_integerScaleFactorY(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
        ) -> Retained<Self>;

        /// Init a node representing a MPSCNNUpsamplingBilinear kernel
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Parameter `integerScaleFactorX`: The upsampling factor for the x dimension.
        ///
        /// Parameter `integerScaleFactorY`: The upsampling factor for the y dimension.
        ///
        /// Parameter `alignCorners`: Specifier whether the centers of the 4 corner pixels of the input and output regions are aligned,
        ///
        /// Returns: A new MPSNNFilter node for a MPSCNNUpsamplingBilinear kernel.
        #[unsafe(method(initWithSource:integerScaleFactorX:integerScaleFactorY:alignCorners:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_integerScaleFactorX_integerScaleFactorY_alignCorners(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            integer_scale_factor_x: NSUInteger,
            integer_scale_factor_y: NSUInteger,
            align_corners: bool,
        ) -> Retained<Self>;

        #[unsafe(method(scaleFactorX))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorX(&self) -> c_double;

        #[unsafe(method(scaleFactorY))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorY(&self) -> c_double;

        #[unsafe(method(alignCorners))]
        #[unsafe(method_family = none)]
        pub unsafe fn alignCorners(&self) -> bool;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNUpsamplingBilinearNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNUpsamplingNearest kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnupsamplingnearestgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNUpsamplingNearestGradientNode;
);

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

impl MPSCNNUpsamplingNearestGradientNode {
    extern_methods!(
        /// A node to represent the gradient calculation for nearest upsampling training.
        ///
        /// [forwardFilter gradientFilterWithSources:] is a more convient way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward filter node
        ///
        /// Parameter `gradientState`: The gradient state from the forward filter
        ///
        /// Parameter `scaleFactorX`: The X scale factor from the forward pass
        ///
        /// Parameter `scaleFactorY`: The Y scale factor from the forward pass
        ///
        /// Returns: A MPSCNNUpsamplingNearestGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:scaleFactorX:scaleFactorY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_scaleFactorX_scaleFactorY(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            scale_factor_x: c_double,
            scale_factor_y: c_double,
        ) -> Retained<Self>;

        /// A node to represent the gradient calculation for nearest upsampling training.
        ///
        /// [forwardFilter gradientFilterWithSources:] is a more convient way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward filter node
        ///
        /// Parameter `gradientState`: The gradient state from the forward filter
        ///
        /// Parameter `scaleFactorX`: The X scale factor from the forward pass
        ///
        /// Parameter `scaleFactorY`: The Y scale factor from the forward pass
        ///
        /// Returns: A MPSCNNUpsamplingNearestGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:scaleFactorX:scaleFactorY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_scaleFactorX_scaleFactorY(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            scale_factor_x: c_double,
            scale_factor_y: c_double,
        ) -> Retained<Self>;

        #[unsafe(method(scaleFactorX))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorX(&self) -> c_double;

        #[unsafe(method(scaleFactorY))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorY(&self) -> c_double;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNUpsamplingNearestGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a MPSCNNUpsamplingBilinear kernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpscnnupsamplingbilineargradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSCNNUpsamplingBilinearGradientNode;
);

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

impl MPSCNNUpsamplingBilinearGradientNode {
    extern_methods!(
        /// A node to represent the gradient calculation for nearest upsampling training.
        ///
        /// [forwardFilter gradientFilterWithSources:] is a more convient way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward filter node
        ///
        /// Parameter `gradientState`: The gradient state from the forward filter
        ///
        /// Parameter `scaleFactorX`: The X scale factor from the forward pass
        ///
        /// Parameter `scaleFactorY`: The Y scale factor from the forward pass
        ///
        /// Returns: A MPSCNNUpsamplingBilinearGradientNode
        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:scaleFactorX:scaleFactorY:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_scaleFactorX_scaleFactorY(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            scale_factor_x: c_double,
            scale_factor_y: c_double,
        ) -> Retained<Self>;

        /// A node to represent the gradient calculation for nearest upsampling training.
        ///
        /// [forwardFilter gradientFilterWithSources:] is a more convient way to do this.
        ///
        /// Parameter `sourceGradient`: The input gradient from the 'downstream' gradient filter.
        ///
        /// Parameter `sourceImage`: The input image from the forward filter node
        ///
        /// Parameter `gradientState`: The gradient state from the forward filter
        ///
        /// Parameter `scaleFactorX`: The X scale factor from the forward pass
        ///
        /// Parameter `scaleFactorY`: The Y scale factor from the forward pass
        ///
        /// Returns: A MPSCNNUpsamplingBilinearGradientNode
        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:scaleFactorX:scaleFactorY:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_scaleFactorX_scaleFactorY(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            scale_factor_x: c_double,
            scale_factor_y: c_double,
        ) -> Retained<Self>;

        #[unsafe(method(scaleFactorX))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorX(&self) -> c_double;

        #[unsafe(method(scaleFactorY))]
        #[unsafe(method_family = none)]
        pub unsafe fn scaleFactorY(&self) -> c_double;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSCNNUpsamplingBilinearGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// MPSNNGramMatrixCallback Defines a callback protocol for
    /// MPSNNGramMatrixCalculationNodeto set the 'alpha'
    /// scaling value dynamically just before encoding the underlying MPSNNGramMatrixCalculation kernel.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnngrammatrixcallback?language=objc)
    pub unsafe trait MPSNNGramMatrixCallback:
        NSObjectProtocol + NSSecureCoding + NSCopying
    {
        #[cfg(all(feature = "MPSCore", feature = "MPSImage"))]
        /// Returns the desired alpha scaling value.
        ///
        /// Parameter `sourceImage`: One of the source images in the batch given as a reference for the alpha computation.
        ///
        /// Parameter `destinationImage`: One of the destination images in the batch given as a reference for the alpha computation.
        ///
        /// Returns: The desired alpha value.
        #[unsafe(method(alphaForSourceImage:destinationImage:))]
        #[unsafe(method_family = none)]
        unsafe fn alphaForSourceImage_destinationImage(
            &self,
            source_image: &MPSImage,
            destination_image: &MPSImage,
        ) -> c_float;
    }
);

extern_class!(
    /// Node representing a
    /// MPSNNGramMatrixCalculationkernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnngrammatrixcalculationnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNGramMatrixCalculationNode;
);

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

impl MPSNNGramMatrixCalculationNode {
    extern_methods!(
        /// Scaling factor for the output. Default: 1.0f.
        #[unsafe(method(alpha))]
        #[unsafe(method_family = none)]
        pub unsafe fn alpha(&self) -> c_float;

        /// Optional callback option - setting this allows the alpha value to be changed dynamically at encode time.
        /// Default value: nil.
        #[unsafe(method(propertyCallBack))]
        #[unsafe(method_family = none)]
        pub unsafe fn propertyCallBack(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn MPSNNGramMatrixCallback>>>;

        /// Setter for [`propertyCallBack`][Self::propertyCallBack].
        #[unsafe(method(setPropertyCallBack:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPropertyCallBack(
            &self,
            property_call_back: Option<&ProtocolObject<dyn MPSNNGramMatrixCallback>>,
        );

        /// Init a node representing a autoreleased MPSNNGramMatrixCalculationNode kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNGramMatrixCalculationNode kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source_node: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing a MPSNNGramMatrixCalculationNode kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNGramMatrixCalculationNode kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// Init a node representing a autoreleased MPSNNGramMatrixCalculationNode kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter.
        ///
        /// Parameter `alpha`: Scaling factor for the output.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNGramMatrixCalculationNode kernel.
        #[unsafe(method(nodeWithSource:alpha:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_alpha(
            source_node: &MPSNNImageNode,
            alpha: c_float,
        ) -> Retained<Self>;

        /// Init a node representing a MPSNNGramMatrixCalculationNode kernel.
        ///
        /// Parameter `sourceNode`: The MPSNNImageNode representing the source MPSImage for the filter.
        ///
        /// Parameter `alpha`: Scaling factor for the output.
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNGramMatrixCalculationNode kernel.
        #[unsafe(method(initWithSource:alpha:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_alpha(
            this: Allocated<Self>,
            source_node: &MPSNNImageNode,
            alpha: c_float,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNGramMatrixCalculationNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a
    /// MPSNNGramMatrixCalculationGradientkernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnngrammatrixcalculationgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNGramMatrixCalculationGradientNode;
);

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

impl MPSNNGramMatrixCalculationGradientNode {
    extern_methods!(
        /// Scaling factor for the output. Default: 1.0f.
        #[unsafe(method(alpha))]
        #[unsafe(method_family = none)]
        pub unsafe fn alpha(&self) -> c_float;

        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
        ) -> Retained<Self>;

        #[unsafe(method(nodeWithSourceGradient:sourceImage:gradientState:alpha:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_gradientState_alpha(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            alpha: c_float,
        ) -> Retained<Self>;

        #[unsafe(method(initWithSourceGradient:sourceImage:gradientState:alpha:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_gradientState_alpha(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            gradient_state: &MPSNNGradientStateNode,
            alpha: c_float,
        ) -> Retained<Self>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNGramMatrixCalculationGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// MPSNNLossCallback Defines a callback protocol for
    /// MPSNNForwardLossNodeand
    /// MPSNNLossGradientNodeto set the scalar weight value just before encoding the underlying kernels.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnlosscallback?language=objc)
    pub unsafe trait MPSNNLossCallback:
        NSObjectProtocol + NSSecureCoding + NSCopying
    {
        #[cfg(all(feature = "MPSCore", feature = "MPSImage"))]
        /// Returns the desired loss scaling weight value.
        ///
        /// Parameter `sourceImage`: One of the source images in the batch given as a reference.
        ///
        /// Parameter `destinationImage`: One of the destination images in the batch given as a reference.
        ///
        /// Returns: The desired scalar weight value.
        #[unsafe(method(scalarWeightForSourceImage:destinationImage:))]
        #[unsafe(method_family = none)]
        unsafe fn scalarWeightForSourceImage_destinationImage(
            &self,
            source_image: &MPSImage,
            destination_image: &MPSImage,
        ) -> c_float;
    }
);

extern_class!(
    /// Node representing a
    /// MPSNNForwardLosskernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnforwardlossnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNForwardLossNode;
);

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

impl MPSNNForwardLossNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNTypes")]
        #[unsafe(method(lossType))]
        #[unsafe(method_family = none)]
        pub unsafe fn lossType(&self) -> MPSCNNLossType;

        #[cfg(feature = "MPSCNNTypes")]
        #[unsafe(method(reductionType))]
        #[unsafe(method_family = none)]
        pub unsafe fn reductionType(&self) -> MPSCNNReductionType;

        #[unsafe(method(numberOfClasses))]
        #[unsafe(method_family = none)]
        pub unsafe fn numberOfClasses(&self) -> NSUInteger;

        #[unsafe(method(reduceAcrossBatch))]
        #[unsafe(method_family = none)]
        pub unsafe fn reduceAcrossBatch(&self) -> bool;

        #[unsafe(method(weight))]
        #[unsafe(method_family = none)]
        pub unsafe fn weight(&self) -> c_float;

        #[unsafe(method(labelSmoothing))]
        #[unsafe(method_family = none)]
        pub unsafe fn labelSmoothing(&self) -> c_float;

        #[unsafe(method(epsilon))]
        #[unsafe(method_family = none)]
        pub unsafe fn epsilon(&self) -> c_float;

        #[unsafe(method(delta))]
        #[unsafe(method_family = none)]
        pub unsafe fn delta(&self) -> c_float;

        /// Optional callback option - setting this allows the scalar weight value to be changed dynamically at encode time.
        /// Default value: nil.
        #[unsafe(method(propertyCallBack))]
        #[unsafe(method_family = none)]
        pub unsafe fn propertyCallBack(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn MPSNNLossCallback>>>;

        /// Setter for [`propertyCallBack`][Self::propertyCallBack].
        #[unsafe(method(setPropertyCallBack:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPropertyCallBack(
            &self,
            property_call_back: Option<&ProtocolObject<dyn MPSNNLossCallback>>,
        );

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSource:labels:weights:lossDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_labels_weights_lossDescriptor(
            source: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            weights: &MPSNNImageNode,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSource:labels:lossDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource_labels_lossDescriptor(
            source: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        /// Init a forward loss node from multiple images
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        /// Node0: logits, Node1: labels, Node2: weights
        ///
        /// Returns: A new MPSNNFilter node.
        #[unsafe(method(nodeWithSources:lossDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources_lossDescriptor(
            source_nodes: &NSArray<MPSNNImageNode>,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSource:labels:weights:lossDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_labels_weights_lossDescriptor(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            weights: Option<&MPSNNImageNode>,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSource:labels:lossDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource_labels_lossDescriptor(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        /// Init a forward loss node from multiple images
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        /// Node0: logits, Node1: labels, Node2: weights
        ///
        /// Returns: A new MPSNNFilter node.
        #[unsafe(method(initWithSources:lossDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources_lossDescriptor(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
            descriptor: &MPSCNNLossDescriptor,
        ) -> Retained<Self>;

        /// Returns the gradient filter for predictions, if you want also gradients for labels then use -gradientFiltersWithSource(s):
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            source_gradient: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNLossGradientNode>;

        #[unsafe(method(gradientFiltersWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSources(
            &self,
            source_gradient: &NSArray<MPSNNImageNode>,
        ) -> Retained<NSArray<MPSNNLossGradientNode>>;

        #[unsafe(method(gradientFilterWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSource(
            &self,
            source_gradient: &MPSNNImageNode,
        ) -> Retained<MPSNNLossGradientNode>;

        #[unsafe(method(gradientFiltersWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFiltersWithSource(
            &self,
            source_gradient: &MPSNNImageNode,
        ) -> Retained<NSArray<MPSNNLossGradientNode>>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNForwardLossNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Node representing a
    /// MPSNNLossGradientkernel
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnnlossgradientnode?language=objc)
    #[unsafe(super(MPSNNGradientFilterNode, MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNLossGradientNode;
);

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

impl MPSNNLossGradientNode {
    extern_methods!(
        #[cfg(feature = "MPSCNNTypes")]
        #[unsafe(method(lossType))]
        #[unsafe(method_family = none)]
        pub unsafe fn lossType(&self) -> MPSCNNLossType;

        #[cfg(feature = "MPSCNNTypes")]
        #[unsafe(method(reductionType))]
        #[unsafe(method_family = none)]
        pub unsafe fn reductionType(&self) -> MPSCNNReductionType;

        #[unsafe(method(numberOfClasses))]
        #[unsafe(method_family = none)]
        pub unsafe fn numberOfClasses(&self) -> NSUInteger;

        #[unsafe(method(reduceAcrossBatch))]
        #[unsafe(method_family = none)]
        pub unsafe fn reduceAcrossBatch(&self) -> bool;

        #[unsafe(method(weight))]
        #[unsafe(method_family = none)]
        pub unsafe fn weight(&self) -> c_float;

        #[unsafe(method(labelSmoothing))]
        #[unsafe(method_family = none)]
        pub unsafe fn labelSmoothing(&self) -> c_float;

        #[unsafe(method(epsilon))]
        #[unsafe(method_family = none)]
        pub unsafe fn epsilon(&self) -> c_float;

        #[unsafe(method(delta))]
        #[unsafe(method_family = none)]
        pub unsafe fn delta(&self) -> c_float;

        #[unsafe(method(isLabelsGradientFilter))]
        #[unsafe(method_family = none)]
        pub unsafe fn isLabelsGradientFilter(&self) -> bool;

        /// Optional callback option - setting this allows the scalar weight value to be changed dynamically at encode time.
        /// Default value: nil.
        #[unsafe(method(propertyCallBack))]
        #[unsafe(method_family = none)]
        pub unsafe fn propertyCallBack(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn MPSNNLossCallback>>>;

        /// Setter for [`propertyCallBack`][Self::propertyCallBack].
        #[unsafe(method(setPropertyCallBack:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPropertyCallBack(
            &self,
            property_call_back: Option<&ProtocolObject<dyn MPSNNLossCallback>>,
        );

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSourceGradient:sourceImage:labels:weights:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_labels_weights_gradientState_lossDescriptor_isLabelsGradientFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            weights: &MPSNNImageNode,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(nodeWithSourceGradient:sourceImage:labels:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSourceGradient_sourceImage_labels_gradientState_lossDescriptor_isLabelsGradientFilter(
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        /// Init a gradient loss node from multiple images
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        /// Node0: logits, Node1: labels, Node2: weights
        ///
        /// Returns: A new MPSNNFilter node.
        #[unsafe(method(nodeWithSources:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSources_gradientState_lossDescriptor_isLabelsGradientFilter(
            source_nodes: &NSArray<MPSNNImageNode>,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSourceGradient:sourceImage:labels:weights:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_labels_weights_gradientState_lossDescriptor_isLabelsGradientFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            weights: Option<&MPSNNImageNode>,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        #[unsafe(method(initWithSourceGradient:sourceImage:labels:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSourceGradient_sourceImage_labels_gradientState_lossDescriptor_isLabelsGradientFilter(
            this: Allocated<Self>,
            source_gradient: &MPSNNImageNode,
            source_image: &MPSNNImageNode,
            labels: &MPSNNImageNode,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSCNNLoss")]
        /// Init a gradient loss node from multiple images
        ///
        /// Parameter `sourceNodes`: The MPSNNImageNode representing the source MPSImages for the filter
        /// Node0: input gradients, Node1: logits, Node2: labels, Node3: weights
        ///
        /// Returns: A new MPSNNFilter node.
        #[unsafe(method(initWithSources:gradientState:lossDescriptor:isLabelsGradientFilter:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSources_gradientState_lossDescriptor_isLabelsGradientFilter(
            this: Allocated<Self>,
            source_nodes: &NSArray<MPSNNImageNode>,
            gradient_state: Option<&MPSNNGradientStateNode>,
            descriptor: &MPSCNNLossDescriptor,
            is_labels_gradient_filter: bool,
        ) -> Retained<Self>;

        /// This is a gradient filter - there is no support gradients of gradients currently.
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNLossGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A node for a MPSNNInitialGradient kernel
    ///
    /// This node can be used to generate a starting point for an arbitrary gradient computation.
    /// Simply add this node after the node for which you want to compute gradients and then
    /// call the function
    /// trainingGraphWithSourceGradient:of this node to automatically
    /// generate the nodes needed for gradient computations or add the desired nodes manually.
    /// This is generally used with MPSNNLossGradientNode and MPSNNForwardLossNode
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshaders/mpsnninitialgradientnode?language=objc)
    #[unsafe(super(MPSNNFilterNode, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct MPSNNInitialGradientNode;
);

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

impl MPSNNInitialGradientNode {
    extern_methods!(
        /// Init a node representing a MPSNNInitialGradient MPSNNPad kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNInitialGradient kernel.
        #[unsafe(method(nodeWithSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn nodeWithSource(source: &MPSNNImageNode) -> Retained<Self>;

        /// Init a node representing a MPSNNInitialGradient MPSNNPad kernel
        ///
        /// Parameter `source`: The MPSNNImageNode representing the source MPSImage for the filter
        ///
        /// Returns: A new MPSNNFilter node for a MPSNNInitialGradient kernel.
        #[unsafe(method(initWithSource:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSource(
            this: Allocated<Self>,
            source: &MPSNNImageNode,
        ) -> Retained<Self>;

        /// The initial gradient filter is a gradient filter and we don't provide support for gradients of gradients currently.
        #[unsafe(method(gradientFilterWithSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn gradientFilterWithSources(
            &self,
            gradient_images: &NSArray<MPSNNImageNode>,
        ) -> Retained<MPSNNGradientFilterNode>;
    );
}

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

/// Methods declared on superclass `NSObject`.
impl MPSNNInitialGradientNode {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}