Xamarin.TVOS SDK API diff: 12.2.1 vs 12.4.0

Xamarin.TVOS.dll

Namespace AVFoundation

Type Changed: AVFoundation.AVAudioSession

Added property:

public virtual AVAudioSessionPromptStyle PromptStyle { get; }

Type Changed: AVFoundation.AVContentKeyRequest

Added property:

public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> Options { get; }

Type Changed: AVFoundation.AVSampleBufferDisplayLayer

Added property:

public virtual bool PreventsCapture { get; set; }

New Type: AVFoundation.AVAudioSessionPromptStyle

[Serializable]
public enum AVAudioSessionPromptStyle {
	None = 1852796517,
	Normal = 1852992876,
	Short = 1936224884,
}

Namespace CoreMedia

Type Changed: CoreMedia.CMMetadataFormatType

Added value:

Emsg = 1701671783,

Type Changed: CoreMedia.CMSampleBuffer

Obsoleted methods:

 [Obsolete ("Use the 'CreateReadyWithImageBuffer' overload with a single ref, not array, 'CMSampleTimingInfo' parameter.")]
 public static CMSampleBuffer CreateReadyWithImageBuffer (CoreVideo.CVImageBuffer imageBuffer, CMFormatDescription formatDescription, CMSampleTimingInfo[] sampleTiming, out CMSampleBufferError error);

Added method:

public static CMSampleBuffer CreateReadyWithImageBuffer (CoreVideo.CVImageBuffer imageBuffer, CMFormatDescription formatDescription, ref CMSampleTimingInfo sampleTiming, out CMSampleBufferError error);

Namespace GameController

Type Changed: GameController.GCExtendedGamepadSnapshot

Added property:

public static GCExtendedGamepadSnapshotDataVersion DataVersion { get; }

Added method:

public static bool TryGetExtendedSnapShotData (Foundation.NSData data, out GCExtendedGamepadSnapshotData snapshotData);

Type Changed: GameController.GCMicroGamepadSnapshot

Added property:

public static GCMicroGamepadSnapshotDataVersion DataVersion { get; }

Added method:

public static bool TryGetSnapshotData (Foundation.NSData data, out GCMicroGamepadSnapshotData snapshotData);

New Type: GameController.GCExtendedGamepadSnapshotData

public struct GCExtendedGamepadSnapshotData {
	// fields
	public float ButtonA;
	public float ButtonB;
	public float ButtonX;
	public float ButtonY;
	public float DPadX;
	public float DPadY;
	public float LeftShoulder;
	public float LeftThumbstickX;
	public float LeftThumbstickY;
	public float LeftTrigger;
	public float RightShoulder;
	public float RightThumbstickX;
	public float RightThumbstickY;
	public float RightTrigger;
	public ushort Size;
	public ushort Version;
	// methods
	public Foundation.NSData ToNSData ();
}

New Type: GameController.GCExtendedGamepadSnapshotDataVersion

[Serializable]
public enum GCExtendedGamepadSnapshotDataVersion {
	Version1 = 256,
	Version2 = 257,
}

New Type: GameController.GCMicroGamepadSnapshotData

public struct GCMicroGamepadSnapshotData {
	// fields
	public float ButtonA;
	public float ButtonX;
	public float DPadX;
	public float DPadY;
	public ushort Size;
	public ushort Version;
	// methods
	public Foundation.NSData ToNSData ();
}

New Type: GameController.GCMicroGamepadSnapshotDataVersion

[Serializable]
public enum GCMicroGamepadSnapshotDataVersion {
	Version1 = 256,
}

Namespace MetalPerformanceShaders

Type Changed: MetalPerformanceShaders.MPSCnnBinaryConvolutionNode

Added constructor:

public MPSCnnBinaryConvolutionNode (MPSNNImageNode sourceNode, IMPSCnnConvolutionDataSource weights, float[] outputBiasTerms, float[] outputScaleTerms, float[] inputBiasTerms, float[] inputScaleTerms, MPSCnnBinaryConvolutionType type, MPSCnnBinaryConvolutionFlags flags);

Added method:

public static MPSCnnBinaryConvolutionNode Create (MPSNNImageNode sourceNode, IMPSCnnConvolutionDataSource weights, float[] outputBiasTerms, float[] outputScaleTerms, float[] inputBiasTerms, float[] inputScaleTerms, MPSCnnBinaryConvolutionType type, MPSCnnBinaryConvolutionFlags flags);

Type Changed: MetalPerformanceShaders.MPSCnnBinaryFullyConnectedNode

Added constructor:

public MPSCnnBinaryFullyConnectedNode (MPSNNImageNode sourceNode, IMPSCnnConvolutionDataSource weights, float[] outputBiasTerms, float[] outputScaleTerms, float[] inputBiasTerms, float[] inputScaleTerms, MPSCnnBinaryConvolutionType type, MPSCnnBinaryConvolutionFlags flags);

Added method:

public static MPSCnnBinaryFullyConnectedNode Create (MPSNNImageNode sourceNode, IMPSCnnConvolutionDataSource weights, float[] outputBiasTerms, float[] outputScaleTerms, float[] inputBiasTerms, float[] inputScaleTerms, MPSCnnBinaryConvolutionType type, MPSCnnBinaryConvolutionFlags flags);

Type Changed: MetalPerformanceShaders.MPSCnnBinaryKernel

Obsoleted properties:

 [Obsolete ("This was exposed by mistake, it will be removed in a future release.")]
 public virtual uint KernelHeight { get; }
 [Obsolete ("This was exposed by mistake, it will be removed in a future release.")]
 public virtual uint KernelWidth { get; }

Modified properties:

-public virtual uint PrimaryStrideInPixelsX { get; set; }
+public virtual uint PrimaryStrideInPixelsX { get; }
-public virtual uint PrimaryStrideInPixelsY { get; set; }
+public virtual uint PrimaryStrideInPixelsY { get; }
-public virtual uint SecondaryStrideInPixelsX { get; set; }
+public virtual uint SecondaryStrideInPixelsX { get; }
-public virtual uint SecondaryStrideInPixelsY { get; set; }
+public virtual uint SecondaryStrideInPixelsY { get; }

Added properties:

public virtual bool AppendBatchBarrier { get; }
public virtual bool IsResultStateReusedAcrossBatch { get; }
public virtual bool IsStateModified { get; }
public virtual uint PrimaryDilationRateX { get; }
public virtual uint PrimaryDilationRateY { get; }
public virtual uint PrimaryKernelHeight { get; }
public virtual uint PrimaryKernelWidth { get; }
public virtual uint PrimarySourceFeatureChannelMaxCount { get; set; }
public virtual uint PrimarySourceFeatureChannelOffset { get; set; }
public virtual uint SecondaryDilationRateX { get; }
public virtual uint SecondaryDilationRateY { get; }
public virtual uint SecondaryKernelHeight { get; }
public virtual uint SecondaryKernelWidth { get; }
public virtual uint SecondarySourceFeatureChannelMaxCount { get; set; }
public virtual uint SecondarySourceFeatureChannelOffset { get; set; }

Added methods:

public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> primaryImage, Foundation.NSArray<MPSImage> secondaryImage);
public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> primaryImages, Foundation.NSArray<MPSImage> secondaryImages, Foundation.NSArray<MPSImage> destinationImages);
public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> primaryImages, Foundation.NSArray<MPSImage> secondaryImages, out MPSState[] outState, bool isTemporary);
public virtual MPSImage EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSImage primaryImage, MPSImage secondaryImage, out MPSState outState, bool isTemporary);
public virtual MPSImageDescriptor GetDestinationImageDescriptor (Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> sourceStates);
public virtual MPSState GetResultState (MPSImage primaryImage, MPSImage secondaryImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual Foundation.NSArray<MPSState> GetResultStateBatch (Foundation.NSArray<MPSImage> primaryImage, Foundation.NSArray<MPSImage> secondaryImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);
public virtual MPSState GetTemporaryResultState (Metal.IMTLCommandBuffer commandBuffer, MPSImage primaryImage, MPSImage secondaryImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual Foundation.NSArray<MPSState> GetTemporaryResultStateBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> primaryImage, Foundation.NSArray<MPSImage> secondaryImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);

Type Changed: MetalPerformanceShaders.MPSCnnConvolution

Added properties:

public virtual MPSNNConvolutionAccumulatorPrecisionOption AccumulatorPrecisionOption { get; set; }
public virtual IMPSCnnConvolutionDataSource DataSource { get; }
public virtual MPSNNNeuronDescriptor FusedNeuronDescriptor { get; }

Added methods:

public virtual MPSCnnConvolutionWeightsAndBiasesState ExportWeightsAndBiases (Metal.IMTLCommandBuffer commandBuffer, bool resultStateCanBeTemporary);
public virtual MPSCnnConvolutionGradientState GetResultState (MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual MPSCnnConvolutionGradientState[] GetResultStateBatch (Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);
public virtual MPSCnnConvolutionGradientState GetTemporaryResultState (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual MPSCnnConvolutionGradientState[] GetTemporaryResultStateBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);
public virtual void ReloadWeightsAndBiases (IMPSCnnConvolutionDataSource dataSource);
public virtual void ReloadWeightsAndBiases (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionWeightsAndBiasesState state);
public virtual void ReloadWeightsAndBiasesFromDataSource ();

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionDataSource

Added methods:

public virtual IMPSCnnConvolutionDataSource Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
public virtual MPSCnnWeightsQuantizationType GetWeightsQuantizationType ();
public virtual bool Update (MPSCnnConvolutionGradientState gradientState, MPSCnnConvolutionWeightsAndBiasesState sourceState);
public virtual MPSCnnConvolutionWeightsAndBiasesState Update (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionGradientState gradientState, MPSCnnConvolutionWeightsAndBiasesState sourceState);

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionDataSource_Extensions

Added methods:

public static IMPSCnnConvolutionDataSource Copy (this IMPSCnnConvolutionDataSource This, Foundation.NSZone zone, Metal.IMTLDevice device);
public static MPSCnnWeightsQuantizationType GetWeightsQuantizationType (this IMPSCnnConvolutionDataSource This);
public static bool Update (this IMPSCnnConvolutionDataSource This, MPSCnnConvolutionGradientState gradientState, MPSCnnConvolutionWeightsAndBiasesState sourceState);
public static MPSCnnConvolutionWeightsAndBiasesState Update (this IMPSCnnConvolutionDataSource This, Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionGradientState gradientState, MPSCnnConvolutionWeightsAndBiasesState sourceState);

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionDescriptor

Added property:

public virtual MPSNNNeuronDescriptor FusedNeuronDescriptor { get; set; }

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionNode

Added properties:

public virtual MPSNNConvolutionAccumulatorPrecisionOption AccumulatorPrecision { get; set; }
public virtual MPSCnnConvolutionGradientStateNode ConvolutionGradientState { get; }

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionTranspose

Added property:

public virtual MPSNNConvolutionAccumulatorPrecisionOption AccumulatorPrecisionOption { get; set; }

Added methods:

public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, MPSCnnConvolutionGradientState[] convolutionGradientState);
public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, MPSCnnConvolutionGradientState[] convolutionGradientState, Foundation.NSArray<MPSImage> destinationImage);
public virtual MPSImage EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnConvolutionGradientState convolutionGradientState);
public virtual void EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnConvolutionGradientState convolutionGradientState, MPSImage destinationImage);

Type Changed: MetalPerformanceShaders.MPSCnnConvolutionTransposeNode

Added constructor:

public MPSCnnConvolutionTransposeNode (MPSNNImageNode sourceNode, MPSCnnConvolutionGradientStateNode convolutionGradientState, IMPSCnnConvolutionDataSource weights);

Added method:

public static MPSCnnConvolutionTransposeNode Create (MPSNNImageNode sourceNode, MPSCnnConvolutionGradientStateNode convolutionGradientState, IMPSCnnConvolutionDataSource weights);

Type Changed: MetalPerformanceShaders.MPSCnnKernel

Added properties:

public virtual bool AppendBatchBarrier { get; }
public virtual uint DilationRateX { get; }
public virtual uint DilationRateY { get; }
public virtual bool IsResultStateReusedAcrossBatch { get; }
public virtual bool IsStateModified { get; }
public virtual uint SourceFeatureChannelMaxCount { get; set; }
public virtual uint SourceFeatureChannelOffset { get; set; }

Added methods:

public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages);
public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSImage> destinationImages);
public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> destinationStates, Foundation.NSArray<MPSImage> destinationImages);
public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, out Foundation.NSArray<MPSState> outStates, bool isTemporary);
public virtual void EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSState destinationState, MPSImage destinationImage);
public virtual MPSImage EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, out MPSState outState, bool isTemporary);
public virtual MPSImageDescriptor GetDestinationImageDescriptor (Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> sourceStates);
public virtual MPSState GetResultState (MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual Foundation.NSArray<MPSState> GetResultStateBatch (Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);
public virtual MPSState GetTemporaryResultState (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
public virtual Foundation.NSArray<MPSState> GetTemporaryResultStateBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSArray<MPSImage> destinationImage);

Type Changed: MetalPerformanceShaders.MPSCnnNeuron

Added constructor:

public MPSCnnNeuron (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Added properties:

public virtual float A { get; }
public virtual float B { get; }
public virtual float C { get; }
public virtual Foundation.NSData Data { get; }
public virtual MPSCnnNeuronType NeuronType { get; }

Type Changed: MetalPerformanceShaders.MPSCnnNeuronAbsolute

Added constructor:

public MPSCnnNeuronAbsolute (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronElu

Added constructor:

public MPSCnnNeuronElu (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronHardSigmoid

Added constructor:

public MPSCnnNeuronHardSigmoid (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronLinear

Added constructor:

public MPSCnnNeuronLinear (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronNode

Added method:

public static MPSCnnNeuronNode Create (MPSNNImageNode sourceNode, MPSNNNeuronDescriptor descriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronPReLU

Added constructor:

public MPSCnnNeuronPReLU (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronReLU

Added constructor:

public MPSCnnNeuronReLU (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronReLun

Added constructor:

public MPSCnnNeuronReLun (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronSigmoid

Added constructor:

public MPSCnnNeuronSigmoid (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronSoftPlus

Added constructor:

public MPSCnnNeuronSoftPlus (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronSoftSign

Added constructor:

public MPSCnnNeuronSoftSign (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronTanH

Added constructor:

public MPSCnnNeuronTanH (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);

Type Changed: MetalPerformanceShaders.MPSCnnNeuronType

Obsoleted fields:

 [Obsolete ("The value changes when newer versions are released. It will be removed in the future.")]
 Count = 15,

Modified fields:

-Count = 12
+Count = 15

Added values:

Exponential = 13,
Logarithm = 14,
Power = 12,

Type Changed: MetalPerformanceShaders.MPSCnnPoolingNode

Added properties:

public virtual uint KernelHeight { get; }
public virtual uint KernelWidth { get; }
public virtual uint StrideInPixelsX { get; }
public virtual uint StrideInPixelsY { get; }

Type Changed: MetalPerformanceShaders.MPSCnnUpsampling

Added property:

public virtual bool AlignCorners { get; }

Type Changed: MetalPerformanceShaders.MPSCnnUpsamplingBilinear

Added constructor:

public MPSCnnUpsamplingBilinear (Metal.IMTLDevice device, uint integerScaleFactorX, uint integerScaleFactorY, bool alignCorners);

Type Changed: MetalPerformanceShaders.MPSCnnUpsamplingBilinearNode

Added constructor:

public MPSCnnUpsamplingBilinearNode (MPSNNImageNode sourceNode, uint integerScaleFactorX, uint integerScaleFactorY, bool alignCorners);

Added property:

public virtual bool AlignCorners { get; }

Added method:

public static MPSCnnUpsamplingBilinearNode Create (MPSNNImageNode sourceNode, uint integerScaleFactorX, uint integerScaleFactorY, bool alignCorners);

Type Changed: MetalPerformanceShaders.MPSDataType

Added values:

Int16 = 536870928,
Int8 = 536870920,
Invalid = 0,
SignedBit = 536870912,
UInt16 = 16,
UInt32 = 32,
UInt8 = 8,

Type Changed: MetalPerformanceShaders.MPSImage

Added constructor:

public MPSImage (MPSImage parent, Foundation.NSRange sliceRange, uint featureChannels);

Added properties:

public virtual Foundation.NSArray<MPSImage> BatchRepresentation { get; }
public static IMPSImageAllocator DefaultAllocator { get; }
public virtual MPSImage Parent { get; }
public virtual uint ResourceSize { get; }

Added methods:

public virtual Foundation.NSArray<MPSImage> GetBatchRepresentation (Foundation.NSRange subRange);
public virtual MPSImage GetSubImage (Foundation.NSRange featureChannelRange);
public virtual void ReadBytes (IntPtr dataBytes, MPSDataLayout dataLayout, uint bytesPerRow, uint bytesPerImage, Metal.MTLRegion region, MPSImageReadWriteParams featureChannelInfo, uint imageIndex);
public virtual void Synchronize (Metal.IMTLCommandBuffer commandBuffer);
public virtual void WriteBytes (IntPtr dataBytes, MPSDataLayout dataLayout, uint bytesPerRow, uint bytesPerImage, Metal.MTLRegion region, MPSImageReadWriteParams featureChannelInfo, uint imageIndex);

Type Changed: MetalPerformanceShaders.MPSImageArithmetic

Added properties:

public virtual float MaximumValue { get; set; }
public virtual float MinimumValue { get; set; }

Type Changed: MetalPerformanceShaders.MPSImageCopyToMatrix

Added method:

public virtual void EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, MPSMatrix destinationMatrix);

Type Changed: MetalPerformanceShaders.MPSImageEdgeMode

Added values:

Constant = 4,
Mirror = 2,
MirrorWithEdge = 3,

Type Changed: MetalPerformanceShaders.MPSKernel

Added methods:

public static void HintTemporaryMemoryHighWaterMark (Metal.IMTLCommandBuffer commandBuffer, uint sizeInBytes);
public static void SetHeapCacheDuration (Metal.IMTLCommandBuffer commandBuffer, double seconds);

Type Changed: MetalPerformanceShaders.MPSKernelOptions

Obsoleted fields:

 [Obsolete ("Use 'AllowReducedPrecision' instead.")]
 MPSKernelOptionsAllowReducedPrecision = 2,

Added values:

AllowReducedPrecision = 2,
DisableInternalTiling = 4,
InsertDebugGroups = 8,

Type Changed: MetalPerformanceShaders.MPSMatrix

Added constructor:

public MPSMatrix (Metal.IMTLDevice device, MPSMatrixDescriptor descriptor);

Added property:

public virtual uint ResourceSize { get; }

Added method:

public virtual void Synchronize (Metal.IMTLCommandBuffer commandBuffer);

Type Changed: MetalPerformanceShaders.MPSNNBinaryArithmeticNode

Added properties:

public virtual float Bias { get; set; }
public virtual ObjCRuntime.Class GradientClass { get; }
public virtual float MaximumValue { get; set; }
public virtual float MinimumValue { get; set; }
public virtual float PrimaryScale { get; set; }
public virtual uint PrimaryStrideInFeatureChannels { get; set; }
public virtual uint PrimaryStrideInPixelsX { get; set; }
public virtual uint PrimaryStrideInPixelsY { get; set; }
public virtual float SecondaryScale { get; set; }
public virtual uint SecondaryStrideInFeatureChannels { get; set; }
public virtual uint SecondaryStrideInPixelsX { get; set; }
public virtual uint SecondaryStrideInPixelsY { get; set; }

Added method:

public virtual MPSNNGradientFilterNode[] GetGradientFilters (MPSNNImageNode[] gradientImages);

Type Changed: MetalPerformanceShaders.MPSNNDefaultPadding

Added methods:

public static MPSNNDefaultPadding CreatePaddingForTensorflowAveragePoolingValidOnly ();
public virtual IMPSNNPadding GetInverse ();

Type Changed: MetalPerformanceShaders.MPSNNFilterNode

Added methods:

public virtual MPSNNGradientFilterNode GetFilter (MPSNNImageNode gradientImageSource);
public virtual MPSNNGradientFilterNode GetFilter (MPSNNImageNode[] gradientImagesSources);
public virtual MPSNNGradientFilterNode[] GetFilters (MPSNNImageNode gradientImageSource);
public virtual MPSNNGradientFilterNode[] GetFilters (MPSNNImageNode[] gradientImagesSources);
public virtual MPSNNFilterNode[] GetTrainingGraph (MPSNNImageNode gradientImageSource, MPSGradientNodeHandler nodeHandler);

Type Changed: MetalPerformanceShaders.MPSNNGraph

Added constructor:

public MPSNNGraph (Metal.IMTLDevice device, MPSNNImageNode resultImage, bool resultIsNeeded);

Added properties:

public virtual MPSImageFeatureChannelFormat Format { get; set; }
public virtual bool ResultImageIsNeeded { get; }

Added methods:

public static MPSNNGraph Create (Metal.IMTLDevice device, MPSNNImageNode resultImage, bool resultIsNeeded);
public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage>[] sourceImages, Foundation.NSArray<MPSState>[] sourceStates);
public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage>[] sourceImages, Foundation.NSArray<MPSState>[] sourceStates, Foundation.NSMutableArray<Foundation.NSArray<MPSImage>> intermediateImages, Foundation.NSMutableArray<Foundation.NSArray<MPSState>> destinationStates);
public virtual uint GetReadCountForSourceImage (uint index);
public virtual uint GetReadCountForSourceState (uint index);
public virtual void ReloadFromDataSources ();

Type Changed: MetalPerformanceShaders.MPSNNImageNode

Added properties:

public virtual bool StopGradient { get; set; }
public virtual bool SynchronizeResource { get; set; }

Type Changed: MetalPerformanceShaders.MPSNNPaddingMethod

Added value:

CustomWhitelistForNodeFusion = 8192,

Type Changed: MetalPerformanceShaders.MPSNNPadding_Extensions

Added method:

public static IMPSNNPadding GetInverse (this IMPSNNPadding This);

Type Changed: MetalPerformanceShaders.MPSNNStateNode

Added properties:

public virtual bool ExportFromGraph { get; set; }
public virtual bool SynchronizeResource { get; set; }

Type Changed: MetalPerformanceShaders.MPSRnnMatrixInferenceLayer

Added method:

public virtual void EncodeSequence (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] sourceMatrices, IntPtr sourceOffsets, MPSMatrix[] destinationMatrices, IntPtr destinationOffsets, MPSRnnRecurrentMatrixState recurrentInputState, Foundation.NSMutableArray<MPSRnnRecurrentMatrixState> recurrentOutputStates);

Type Changed: MetalPerformanceShaders.MPSState

Added constructors:

public MPSState (Metal.IMTLResource resource);
public MPSState (Metal.IMTLResource[] resources);
public MPSState (Metal.IMTLDevice device, Metal.MTLTextureDescriptor descriptor);
public MPSState (Metal.IMTLDevice device, MPSStateResourceList resourceList);
public MPSState (Metal.IMTLDevice device, uint bufferSize);

Added properties:

public virtual Metal.IMTLResource Resource { get; }
public virtual uint ResourceCount { get; }
public virtual uint ResourceSize { get; }

Added methods:

public static MPSState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer);
public static MPSState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, Metal.MTLTextureDescriptor descriptor);
public static MPSState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, MPSStateResourceList resourceList);
public static MPSState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint bufferSize);
public virtual uint GetBufferSize (uint index);
public virtual MPSImageDescriptor GetDestinationImageDescriptor (Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> sourceStates, MPSKernel kernel, MPSImageDescriptor inDescriptor);
public virtual Metal.IMTLResource GetResource (uint index, bool allocateMemory);
public virtual MPSStateResourceType GetResourceType (uint index);
public virtual MPSStateTextureInfo GetTextureInfo (uint index);
public virtual void Synchronize (Metal.IMTLCommandBuffer commandBuffer);

Type Changed: MetalPerformanceShaders.MPSTemporaryImage

Added constructor:

public MPSTemporaryImage (MPSImage parent, Foundation.NSRange sliceRange, uint featureChannels);

Added property:

public static IMPSImageAllocator DefaultAllocator { get; }

Added method:

public static MPSTemporaryImage GetTemporaryImage (Metal.IMTLCommandBuffer commandBuffer, Metal.MTLTextureDescriptor textureDescriptor, uint featureChannels);

Type Changed: MetalPerformanceShaders.MPSVector

Added constructor:

public MPSVector (Metal.IMTLDevice device, MPSVectorDescriptor descriptor);

Added property:

public virtual uint ResourceSize { get; }

Added method:

public virtual void Synchronize (Metal.IMTLCommandBuffer commandBuffer);

New Type: MetalPerformanceShaders.IMPSCnnBatchNormalizationDataSource

public interface IMPSCnnBatchNormalizationDataSource : Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual IntPtr Beta { get; }
	public virtual IntPtr Gamma { get; }
	public virtual string Label { get; }
	public virtual bool Load { get; }
	public virtual IntPtr Mean { get; }
	public virtual uint NumberOfFeatureChannels { get; }
	public virtual IntPtr Variance { get; }
	// methods
	public virtual void Purge ();
}

New Type: MetalPerformanceShaders.IMPSCnnInstanceNormalizationDataSource

public interface IMPSCnnInstanceNormalizationDataSource : Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual IntPtr Beta { get; }
	public virtual IntPtr Gamma { get; }
	public virtual string Label { get; }
	public virtual uint NumberOfFeatureChannels { get; }
}

New Type: MetalPerformanceShaders.IMPSNNTrainableNode

public interface IMPSNNTrainableNode : ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual MPSNNTrainingStyle TrainingStyle { get; set; }
}

New Type: MetalPerformanceShaders.MPSAccelerationStructure

public class MPSAccelerationStructure : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSAccelerationStructure (Foundation.NSCoder coder);
	protected MPSAccelerationStructure (Foundation.NSObjectFlag t);
	public MPSAccelerationStructure (Metal.IMTLDevice device);
	public MPSAccelerationStructure (MPSAccelerationStructureGroup group);
	protected MPSAccelerationStructure (IntPtr handle);
	public MPSAccelerationStructure (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSAccelerationStructure (Foundation.NSCoder aDecoder, MPSAccelerationStructureGroup group);
	// properties
	public virtual MPSAxisAlignedBoundingBox BoundingBox { get; }
	public override IntPtr ClassHandle { get; }
	public virtual MPSAccelerationStructureGroup Group { get; }
	public virtual MPSAccelerationStructureStatus Status { get; }
	public virtual MPSAccelerationStructureUsage Usage { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual MPSAccelerationStructure Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual MPSAccelerationStructure Copy (Foundation.NSZone zone, MPSAccelerationStructureGroup group);
	public virtual void Encode (Foundation.NSCoder coder);
	public virtual void EncodeRefit (Metal.IMTLCommandBuffer commandBuffer);
	public virtual void Rebuild ();
	public virtual void Rebuild (MPSAccelerationStructureCompletionHandler completionHandler);
	public virtual System.Threading.Tasks.Task<MPSAccelerationStructure> RebuildAsync ();
}

New Type: MetalPerformanceShaders.MPSAccelerationStructureCompletionHandler

public sealed delegate MPSAccelerationStructureCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public MPSAccelerationStructureCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (MPSAccelerationStructure structure, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (MPSAccelerationStructure structure);
}

New Type: MetalPerformanceShaders.MPSAccelerationStructureGroup

public class MPSAccelerationStructureGroup : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSAccelerationStructureGroup (Foundation.NSObjectFlag t);
	public MPSAccelerationStructureGroup (Metal.IMTLDevice device);
	protected MPSAccelerationStructureGroup (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLDevice Device { get; }
}

New Type: MetalPerformanceShaders.MPSAccelerationStructureStatus

[Serializable]
public enum MPSAccelerationStructureStatus {
	Built = 1,
	Unbuilt = 0,
}

New Type: MetalPerformanceShaders.MPSAccelerationStructureUsage

[Serializable]
[Flags]
public enum MPSAccelerationStructureUsage {
	FrequentRebuild = 2,
	None = 0,
	Refit = 1,
}

New Type: MetalPerformanceShaders.MPSAxisAlignedBoundingBox

public struct MPSAxisAlignedBoundingBox {
	// fields
	public OpenTK.Vector3 Max;
	public OpenTK.Vector3 Min;
}

New Type: MetalPerformanceShaders.MPSBoundingBoxIntersectionTestType

[Serializable]
public enum MPSBoundingBoxIntersectionTestType {
	AxisAligned = 1,
	Default = 0,
}

New Type: MetalPerformanceShaders.MPSCnnAdd

public class MPSCnnAdd : MetalPerformanceShaders.MPSCnnArithmetic, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnAdd (Foundation.NSCoder coder);
	protected MPSCnnAdd (Foundation.NSObjectFlag t);
	public MPSCnnAdd (Metal.IMTLDevice device);
	protected MPSCnnAdd (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnAddGradient

public class MPSCnnAddGradient : MetalPerformanceShaders.MPSCnnArithmeticGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnAddGradient (Foundation.NSCoder coder);
	protected MPSCnnAddGradient (Foundation.NSObjectFlag t);
	protected MPSCnnAddGradient (IntPtr handle);
	public MPSCnnAddGradient (Metal.IMTLDevice device, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnArithmetic

public class MPSCnnArithmetic : MetalPerformanceShaders.MPSCnnBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnArithmetic (Foundation.NSCoder coder);
	protected MPSCnnArithmetic (Foundation.NSObjectFlag t);
	protected MPSCnnArithmetic (IntPtr handle);
	// properties
	public virtual float Bias { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float MaximumValue { get; set; }
	public virtual float MinimumValue { get; set; }
	public virtual float PrimaryScale { get; set; }
	public virtual uint PrimaryStrideInFeatureChannels { get; set; }
	public virtual float SecondaryScale { get; set; }
	public virtual uint SecondaryStrideInFeatureChannels { get; set; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage primaryImage, MPSImage secondaryImage, MPSCnnArithmeticGradientState destinationState, MPSImage destinationImage);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> primaryImages, Foundation.NSArray<MPSImage> secondaryImages, MPSCnnArithmeticGradientState[] destinationStates, Foundation.NSArray<MPSImage> destinationImages);
}

New Type: MetalPerformanceShaders.MPSCnnArithmeticGradient

public class MPSCnnArithmeticGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnArithmeticGradient (Foundation.NSCoder coder);
	protected MPSCnnArithmeticGradient (Foundation.NSObjectFlag t);
	protected MPSCnnArithmeticGradient (IntPtr handle);
	// properties
	public virtual float Bias { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual bool IsSecondarySourceFilter { get; }
	public virtual float MaximumValue { get; set; }
	public virtual float MinimumValue { get; set; }
	public virtual float PrimaryScale { get; set; }
	public virtual float SecondaryScale { get; set; }
	public virtual uint SecondaryStrideInFeatureChannels { get; set; }
}

New Type: MetalPerformanceShaders.MPSCnnArithmeticGradientState

public class MPSCnnArithmeticGradientState : MetalPerformanceShaders.MPSNNBinaryGradientState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnArithmeticGradientState (Foundation.NSObjectFlag t);
	protected MPSCnnArithmeticGradientState (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalization

public class MPSCnnBatchNormalization : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnBatchNormalization (Foundation.NSCoder coder);
	protected MPSCnnBatchNormalization (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalization (IntPtr handle);
	public MPSCnnBatchNormalization (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnBatchNormalization (Metal.IMTLDevice device, IMPSCnnBatchNormalizationDataSource dataSource);
	public MPSCnnBatchNormalization (Metal.IMTLDevice device, IMPSCnnBatchNormalizationDataSource dataSource, MPSNNNeuronDescriptor fusedNeuronDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual IMPSCnnBatchNormalizationDataSource DataSource { get; }
	public virtual float Epsilon { get; set; }
	public virtual uint NumberOfFeatureChannels { get; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnBatchNormalizationState batchNormalizationState, MPSImage destinationImage);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, MPSCnnBatchNormalizationState batchNormalizationState, Foundation.NSArray<MPSImage> destinationImages);
	public virtual MPSCnnBatchNormalizationState GetResultState (MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
	public virtual MPSCnnBatchNormalizationState GetTemporaryResultState (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
	public virtual void ReloadGammaAndBeta (Metal.IMTLCommandBuffer commandBuffer, MPSCnnNormalizationGammaAndBetaState gammaAndBetaState);
	public virtual void ReloadGammaAndBetaFromDataSource ();
	public virtual void ReloadMeanAndVariance (Metal.IMTLCommandBuffer commandBuffer, MPSCnnNormalizationMeanAndVarianceState meanAndVarianceState);
	public virtual void ReloadMeanAndVarianceFromDataSource ();
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationDataSource

public abstract class MPSCnnBatchNormalizationDataSource : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, IMPSCnnBatchNormalizationDataSource, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnBatchNormalizationDataSource ();
	public MPSCnnBatchNormalizationDataSource (Foundation.NSCoder decoder);
	protected MPSCnnBatchNormalizationDataSource (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationDataSource (IntPtr handle);
	// properties
	public virtual IntPtr Beta { get; }
	public virtual float Epsilon { get; }
	public virtual IntPtr Gamma { get; }
	public virtual string Label { get; }
	public virtual bool Load { get; }
	public virtual IntPtr Mean { get; }
	public virtual uint NumberOfFeatureChannels { get; }
	public static bool SupportsSecureCoding { get; }
	public virtual IntPtr Variance { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual IMPSCnnBatchNormalizationDataSource Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Foundation.NSCoder coder);
	public virtual void Purge ();
	public virtual bool UpdateGammaAndBeta (MPSCnnBatchNormalizationState batchNormalizationState);
	public virtual MPSCnnNormalizationGammaAndBetaState UpdateGammaAndBeta (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState);
	public virtual bool UpdateMeanAndVariance (MPSCnnBatchNormalizationState batchNormalizationState);
	public virtual MPSCnnNormalizationMeanAndVarianceState UpdateMeanAndVariance (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationDataSource_Extensions

public static class MPSCnnBatchNormalizationDataSource_Extensions {
	// methods
	public static IMPSCnnBatchNormalizationDataSource Copy (this IMPSCnnBatchNormalizationDataSource This, Foundation.NSZone zone, Metal.IMTLDevice device);
	public static void Encode (this IMPSCnnBatchNormalizationDataSource This, Foundation.NSCoder coder);
	public static float GetEpsilon (this IMPSCnnBatchNormalizationDataSource This);
	public static bool UpdateGammaAndBeta (this IMPSCnnBatchNormalizationDataSource This, MPSCnnBatchNormalizationState batchNormalizationState);
	public static MPSCnnNormalizationGammaAndBetaState UpdateGammaAndBeta (this IMPSCnnBatchNormalizationDataSource This, Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState);
	public static bool UpdateMeanAndVariance (this IMPSCnnBatchNormalizationDataSource This, MPSCnnBatchNormalizationState batchNormalizationState);
	public static MPSCnnNormalizationMeanAndVarianceState UpdateMeanAndVariance (this IMPSCnnBatchNormalizationDataSource This, Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationFlags

[Serializable]
[Flags]
public enum MPSCnnBatchNormalizationFlags {
	CalculateStatisticsAlways = 1,
	CalculateStatisticsAutomatic = 0,
	CalculateStatisticsMask = 3,
	CalculateStatisticsNever = 2,
	Default = 0,
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationGradient

public class MPSCnnBatchNormalizationGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnBatchNormalizationGradient (Foundation.NSCoder coder);
	protected MPSCnnBatchNormalizationGradient (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationGradient (IntPtr handle);
	public MPSCnnBatchNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnBatchNormalizationGradient (Metal.IMTLDevice device, MPSNNNeuronDescriptor fusedNeuronDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual MPSImage Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceGradient, MPSImage sourceImage, MPSCnnBatchNormalizationState batchNormalizationState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceGradient, MPSImage sourceImage, MPSCnnBatchNormalizationState batchNormalizationState, MPSImage destinationGradient);
	public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceGradients, Foundation.NSArray<MPSImage> sourceImages, MPSCnnBatchNormalizationState batchNormalizationState);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceGradients, Foundation.NSArray<MPSImage> sourceImages, MPSCnnBatchNormalizationState batchNormalizationState, Foundation.NSArray<MPSImage> destinationGradients);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationGradientNode

public class MPSCnnBatchNormalizationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, IMPSNNTrainableNode, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnBatchNormalizationGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationGradientNode (IntPtr handle);
	public MPSCnnBatchNormalizationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNTrainingStyle TrainingStyle { get; set; }
	// methods
	public static MPSCnnBatchNormalizationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationNode

public class MPSCnnBatchNormalizationNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnBatchNormalizationNode (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationNode (IntPtr handle);
	public MPSCnnBatchNormalizationNode (MPSNNImageNode source, IMPSCnnBatchNormalizationDataSource dataSource);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSCnnBatchNormalizationFlags Flags { get; set; }
	// methods
	public static MPSCnnBatchNormalizationNode Create (MPSNNImageNode source, IMPSCnnBatchNormalizationDataSource dataSource);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationState

public class MPSCnnBatchNormalizationState : MetalPerformanceShaders.MPSNNGradientState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnBatchNormalizationState (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationState (IntPtr handle);
	// properties
	public virtual MPSCnnBatchNormalization BatchNormalization { get; }
	public virtual Metal.IMTLBuffer Beta { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer Gamma { get; }
	public virtual Metal.IMTLBuffer GradientForBeta { get; }
	public virtual Metal.IMTLBuffer GradientForGamma { get; }
	public virtual Metal.IMTLBuffer Mean { get; }
	public virtual Metal.IMTLBuffer Variance { get; }
	// methods
	public virtual void Reset ();
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationStatistics

public class MPSCnnBatchNormalizationStatistics : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnBatchNormalizationStatistics (Foundation.NSCoder coder);
	protected MPSCnnBatchNormalizationStatistics (Foundation.NSObjectFlag t);
	public MPSCnnBatchNormalizationStatistics (Metal.IMTLDevice device);
	protected MPSCnnBatchNormalizationStatistics (IntPtr handle);
	public MPSCnnBatchNormalizationStatistics (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImages, MPSCnnBatchNormalizationState batchNormalizationState);
}

New Type: MetalPerformanceShaders.MPSCnnBatchNormalizationStatisticsGradient

public class MPSCnnBatchNormalizationStatisticsGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnBatchNormalizationStatisticsGradient (Foundation.NSCoder coder);
	protected MPSCnnBatchNormalizationStatisticsGradient (Foundation.NSObjectFlag t);
	protected MPSCnnBatchNormalizationStatisticsGradient (IntPtr handle);
	public MPSCnnBatchNormalizationStatisticsGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSCnnBatchNormalizationStatisticsGradient (Metal.IMTLDevice device, MPSNNNeuronDescriptor fusedNeuronDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceGradients, Foundation.NSArray<MPSImage> sourceImages, MPSCnnBatchNormalizationState batchNormalizationState);
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionGradient

public class MPSCnnConvolutionGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnConvolutionGradient (Foundation.NSCoder coder);
	protected MPSCnnConvolutionGradient (Foundation.NSObjectFlag t);
	protected MPSCnnConvolutionGradient (IntPtr handle);
	public MPSCnnConvolutionGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnConvolutionGradient (Metal.IMTLDevice device, IMPSCnnConvolutionDataSource weights);
	// properties
	public virtual uint ChannelMultiplier { get; }
	public override IntPtr ClassHandle { get; }
	public virtual IMPSCnnConvolutionDataSource DataSource { get; }
	public virtual MPSCnnConvolutionGradientOption GradientOption { get; set; }
	public virtual uint Groups { get; }
	public virtual uint SourceGradientFeatureChannels { get; }
	public virtual uint SourceImageFeatureChannels { get; }
	// methods
	public virtual void ReloadWeightsAndBiases (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionWeightsAndBiasesState state);
	public virtual void ReloadWeightsAndBiasesFromDataSource ();
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionGradientNode

public class MPSCnnConvolutionGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, IMPSNNTrainableNode, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnConvolutionGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnConvolutionGradientNode (IntPtr handle);
	public MPSCnnConvolutionGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSCnnConvolutionGradientStateNode gradientState, IMPSCnnConvolutionDataSource weights);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNTrainingStyle TrainingStyle { get; set; }
	// methods
	public static MPSCnnConvolutionGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSCnnConvolutionGradientStateNode gradientState, IMPSCnnConvolutionDataSource weights);
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionGradientOption

[Serializable]
[Flags]
public enum MPSCnnConvolutionGradientOption {
	All = 3,
	GradientWithData = 1,
	GradientWithWeightsAndBias = 2,
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionGradientState

public class MPSCnnConvolutionGradientState : MetalPerformanceShaders.MPSNNGradientState, Foundation.INSObjectProtocol, IMPSImageSizeEncodingState, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnConvolutionGradientState (Foundation.NSObjectFlag t);
	protected MPSCnnConvolutionGradientState (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSCnnConvolution Convolution { get; }
	public virtual Metal.IMTLBuffer GradientForBiases { get; }
	public virtual Metal.IMTLBuffer GradientForWeights { get; }
	public virtual uint SourceHeight { get; }
	public virtual uint SourceWidth { get; }
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionGradientStateNode

public class MPSCnnConvolutionGradientStateNode : MetalPerformanceShaders.MPSNNGradientStateNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnConvolutionGradientStateNode (Foundation.NSObjectFlag t);
	protected MPSCnnConvolutionGradientStateNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnConvolutionWeightsAndBiasesState

public class MPSCnnConvolutionWeightsAndBiasesState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnConvolutionWeightsAndBiasesState (Foundation.NSObjectFlag t);
	protected MPSCnnConvolutionWeightsAndBiasesState (IntPtr handle);
	public MPSCnnConvolutionWeightsAndBiasesState (Metal.IMTLBuffer weights, Metal.IMTLBuffer biases);
	public MPSCnnConvolutionWeightsAndBiasesState (Metal.IMTLDevice device, MPSCnnConvolutionDescriptor descriptor);
	// properties
	public virtual Metal.IMTLBuffer Biases { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer Weights { get; }
	// methods
	public static MPSCnnConvolutionWeightsAndBiasesState GetTemporaryCnnConvolutionWeightsAndBiasesState (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionDescriptor descriptor);
}

New Type: MetalPerformanceShaders.MPSCnnCrossChannelNormalizationGradient

public class MPSCnnCrossChannelNormalizationGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnCrossChannelNormalizationGradient (Foundation.NSCoder coder);
	protected MPSCnnCrossChannelNormalizationGradient (Foundation.NSObjectFlag t);
	protected MPSCnnCrossChannelNormalizationGradient (IntPtr handle);
	public MPSCnnCrossChannelNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnCrossChannelNormalizationGradient (Metal.IMTLDevice device, uint kernelSize);
	// properties
	public virtual float Alpha { get; set; }
	public virtual float Beta { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
	public virtual uint KernelSize { get; }
}

New Type: MetalPerformanceShaders.MPSCnnCrossChannelNormalizationGradientNode

public class MPSCnnCrossChannelNormalizationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnCrossChannelNormalizationGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnCrossChannelNormalizationGradientNode (IntPtr handle);
	public MPSCnnCrossChannelNormalizationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelSize);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint KernelSize { get; }
	// methods
	public static MPSCnnCrossChannelNormalizationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelSize);
}

New Type: MetalPerformanceShaders.MPSCnnDilatedPoolingMaxGradient

public class MPSCnnDilatedPoolingMaxGradient : MetalPerformanceShaders.MPSCnnPoolingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnDilatedPoolingMaxGradient (Foundation.NSCoder coder);
	protected MPSCnnDilatedPoolingMaxGradient (Foundation.NSObjectFlag t);
	protected MPSCnnDilatedPoolingMaxGradient (IntPtr handle);
	public MPSCnnDilatedPoolingMaxGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnDilatedPoolingMaxGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, uint dilationRateX, uint dilationRateY, uint strideInPixelsX, uint strideInPixelsY);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnDilatedPoolingMaxGradientNode

public class MPSCnnDilatedPoolingMaxGradientNode : MetalPerformanceShaders.MPSCnnPoolingGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnDilatedPoolingMaxGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnDilatedPoolingMaxGradientNode (IntPtr handle);
	public MPSCnnDilatedPoolingMaxGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, uint dilationRateX, uint dilationRateY);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint DilationRateX { get; }
	public virtual uint DilationRateY { get; }
	// methods
	public static MPSCnnDilatedPoolingMaxGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, uint dilationRateX, uint dilationRateY);
}

New Type: MetalPerformanceShaders.MPSCnnDivide

public class MPSCnnDivide : MetalPerformanceShaders.MPSCnnArithmetic, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnDivide (Foundation.NSCoder coder);
	protected MPSCnnDivide (Foundation.NSObjectFlag t);
	public MPSCnnDivide (Metal.IMTLDevice device);
	protected MPSCnnDivide (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnDropout

public class MPSCnnDropout : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnDropout (Foundation.NSCoder coder);
	protected MPSCnnDropout (Foundation.NSObjectFlag t);
	protected MPSCnnDropout (IntPtr handle);
	public MPSCnnDropout (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnDropout (Metal.IMTLDevice device, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float KeepProbability { get; }
	public virtual Metal.MTLSize MaskStrideInPixels { get; }
	public virtual uint Seed { get; }
}

New Type: MetalPerformanceShaders.MPSCnnDropoutGradient

public class MPSCnnDropoutGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnDropoutGradient (Foundation.NSCoder coder);
	protected MPSCnnDropoutGradient (Foundation.NSObjectFlag t);
	protected MPSCnnDropoutGradient (IntPtr handle);
	public MPSCnnDropoutGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnDropoutGradient (Metal.IMTLDevice device, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float KeepProbability { get; }
	public virtual Metal.MTLSize MaskStrideInPixels { get; }
	public virtual uint Seed { get; }
}

New Type: MetalPerformanceShaders.MPSCnnDropoutGradientNode

public class MPSCnnDropoutGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnDropoutGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnDropoutGradientNode (IntPtr handle);
	public MPSCnnDropoutGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float KeepProbability { get; }
	public virtual Metal.MTLSize MaskStrideInPixels { get; }
	public virtual uint Seed { get; }
	// methods
	public static MPSCnnDropoutGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
}

New Type: MetalPerformanceShaders.MPSCnnDropoutGradientState

public class MPSCnnDropoutGradientState : MetalPerformanceShaders.MPSNNGradientState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnDropoutGradientState (Foundation.NSObjectFlag t);
	protected MPSCnnDropoutGradientState (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSData MaskData { get; }
}

New Type: MetalPerformanceShaders.MPSCnnDropoutNode

public class MPSCnnDropoutNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnDropoutNode (Foundation.NSObjectFlag t);
	public MPSCnnDropoutNode (MPSNNImageNode source);
	protected MPSCnnDropoutNode (IntPtr handle);
	public MPSCnnDropoutNode (MPSNNImageNode source, float keepProbability);
	public MPSCnnDropoutNode (MPSNNImageNode source, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float KeepProbability { get; }
	public virtual Metal.MTLSize MaskStrideInPixels { get; }
	public virtual uint Seed { get; }
	// methods
	public static MPSCnnDropoutNode Create (MPSNNImageNode source);
	public static MPSCnnDropoutNode Create (MPSNNImageNode source, float keepProbability);
	public static MPSCnnDropoutNode Create (MPSNNImageNode source, float keepProbability, uint seed, Metal.MTLSize maskStrideInPixels);
}

New Type: MetalPerformanceShaders.MPSCnnFullyConnectedGradient

public class MPSCnnFullyConnectedGradient : MetalPerformanceShaders.MPSCnnConvolutionGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnFullyConnectedGradient (Foundation.NSCoder coder);
	protected MPSCnnFullyConnectedGradient (Foundation.NSObjectFlag t);
	protected MPSCnnFullyConnectedGradient (IntPtr handle);
	public MPSCnnFullyConnectedGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnFullyConnectedGradient (Metal.IMTLDevice device, IMPSCnnConvolutionDataSource weights);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnGradientKernel

public class MPSCnnGradientKernel : MetalPerformanceShaders.MPSCnnBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnGradientKernel (Foundation.NSCoder coder);
	protected MPSCnnGradientKernel (Foundation.NSObjectFlag t);
	public MPSCnnGradientKernel (Metal.IMTLDevice device);
	protected MPSCnnGradientKernel (IntPtr handle);
	public MPSCnnGradientKernel (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual nint KernelOffsetX { get; set; }
	public virtual nint KernelOffsetY { get; set; }
	// methods
	public virtual MPSImage Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceGradient, MPSImage sourceImage, MPSState gradientState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceGradient, MPSImage sourceImage, MPSState gradientState, MPSImage destinationGradient);
	public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceGradients, Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> gradientStates);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceGradients, Foundation.NSArray<MPSImage> sourceImages, Foundation.NSArray<MPSState> gradientStates, Foundation.NSArray<MPSImage> destinationGradients);
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalization

public class MPSCnnInstanceNormalization : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnInstanceNormalization (Foundation.NSCoder coder);
	protected MPSCnnInstanceNormalization (Foundation.NSObjectFlag t);
	protected MPSCnnInstanceNormalization (IntPtr handle);
	public MPSCnnInstanceNormalization (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnInstanceNormalization (Metal.IMTLDevice device, IMPSCnnInstanceNormalizationDataSource dataSource);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual IMPSCnnInstanceNormalizationDataSource DataSource { get; }
	public virtual float Epsilon { get; set; }
	// methods
	public virtual MPSCnnInstanceNormalizationGradientState GetResultState (MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
	public virtual MPSCnnInstanceNormalizationGradientState GetTemporaryResultState (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, Foundation.NSArray<MPSState> sourceStates, MPSImage destinationImage);
	public virtual void ReloadDataSource (IMPSCnnInstanceNormalizationDataSource dataSource);
	public virtual void ReloadGammaAndBeta (Metal.IMTLCommandBuffer commandBuffer, MPSCnnNormalizationGammaAndBetaState gammaAndBetaState);
	public virtual void ReloadGammaAndBetaFromDataSource ();
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationDataSource

public abstract class MPSCnnInstanceNormalizationDataSource : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, IMPSCnnInstanceNormalizationDataSource, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnInstanceNormalizationDataSource ();
	public MPSCnnInstanceNormalizationDataSource (Foundation.NSCoder decoder);
	protected MPSCnnInstanceNormalizationDataSource (Foundation.NSObjectFlag t);
	protected MPSCnnInstanceNormalizationDataSource (IntPtr handle);
	// properties
	public virtual IntPtr Beta { get; }
	public virtual IntPtr Gamma { get; }
	public virtual string Label { get; }
	public virtual uint NumberOfFeatureChannels { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual IMPSCnnInstanceNormalizationDataSource Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Foundation.NSCoder coder);
	public virtual float GetEpsilon ();
	public virtual bool UpdateGammaAndBeta (MPSCnnInstanceNormalizationGradientState[] instanceNormalizationStateBatch);
	public virtual MPSCnnNormalizationGammaAndBetaState UpdateGammaAndBeta (Metal.IMTLCommandBuffer commandBuffer, MPSCnnInstanceNormalizationGradientState[] instanceNormalizationStateBatch);
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationDataSource_Extensions

public static class MPSCnnInstanceNormalizationDataSource_Extensions {
	// methods
	public static IMPSCnnInstanceNormalizationDataSource Copy (this IMPSCnnInstanceNormalizationDataSource This, Foundation.NSZone zone, Metal.IMTLDevice device);
	public static void Encode (this IMPSCnnInstanceNormalizationDataSource This, Foundation.NSCoder coder);
	public static float GetEpsilon (this IMPSCnnInstanceNormalizationDataSource This);
	public static bool UpdateGammaAndBeta (this IMPSCnnInstanceNormalizationDataSource This, MPSCnnInstanceNormalizationGradientState[] instanceNormalizationStateBatch);
	public static MPSCnnNormalizationGammaAndBetaState UpdateGammaAndBeta (this IMPSCnnInstanceNormalizationDataSource This, Metal.IMTLCommandBuffer commandBuffer, MPSCnnInstanceNormalizationGradientState[] instanceNormalizationStateBatch);
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationGradient

public class MPSCnnInstanceNormalizationGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnInstanceNormalizationGradient (Foundation.NSCoder coder);
	protected MPSCnnInstanceNormalizationGradient (Foundation.NSObjectFlag t);
	public MPSCnnInstanceNormalizationGradient (Metal.IMTLDevice device);
	protected MPSCnnInstanceNormalizationGradient (IntPtr handle);
	public MPSCnnInstanceNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationGradientNode

public class MPSCnnInstanceNormalizationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, IMPSNNTrainableNode, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnInstanceNormalizationGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnInstanceNormalizationGradientNode (IntPtr handle);
	public MPSCnnInstanceNormalizationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNTrainingStyle TrainingStyle { get; set; }
	// methods
	public static MPSCnnInstanceNormalizationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationGradientState

public class MPSCnnInstanceNormalizationGradientState : MetalPerformanceShaders.MPSNNGradientState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnInstanceNormalizationGradientState (Foundation.NSObjectFlag t);
	protected MPSCnnInstanceNormalizationGradientState (IntPtr handle);
	// properties
	public virtual Metal.IMTLBuffer Beta { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer Gamma { get; }
	public virtual Metal.IMTLBuffer GradientForBeta { get; }
	public virtual Metal.IMTLBuffer GradientForGamma { get; }
	public virtual MPSCnnInstanceNormalization InstanceNormalization { get; }
}

New Type: MetalPerformanceShaders.MPSCnnInstanceNormalizationNode

public class MPSCnnInstanceNormalizationNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnInstanceNormalizationNode (Foundation.NSObjectFlag t);
	protected MPSCnnInstanceNormalizationNode (IntPtr handle);
	public MPSCnnInstanceNormalizationNode (MPSNNImageNode source, IMPSCnnInstanceNormalizationDataSource dataSource);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnInstanceNormalizationNode Create (MPSNNImageNode source, IMPSCnnInstanceNormalizationDataSource dataSource);
}

New Type: MetalPerformanceShaders.MPSCnnLocalContrastNormalizationGradient

public class MPSCnnLocalContrastNormalizationGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnLocalContrastNormalizationGradient (Foundation.NSCoder coder);
	protected MPSCnnLocalContrastNormalizationGradient (Foundation.NSObjectFlag t);
	protected MPSCnnLocalContrastNormalizationGradient (IntPtr handle);
	public MPSCnnLocalContrastNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnLocalContrastNormalizationGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight);
	// properties
	public virtual float Alpha { get; set; }
	public virtual float Beta { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
	public virtual float P0 { get; set; }
	public virtual float Pm { get; set; }
	public virtual float Ps { get; set; }
}

New Type: MetalPerformanceShaders.MPSCnnLocalContrastNormalizationGradientNode

public class MPSCnnLocalContrastNormalizationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLocalContrastNormalizationGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnLocalContrastNormalizationGradientNode (IntPtr handle);
	public MPSCnnLocalContrastNormalizationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight);
	// properties
	public virtual float Alpha { get; set; }
	public virtual float Beta { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
	public virtual uint KernelHeight { get; }
	public virtual uint KernelWidth { get; }
	public virtual float P0 { get; set; }
	public virtual float Pm { get; set; }
	public virtual float Ps { get; set; }
	// methods
	public static MPSCnnLocalContrastNormalizationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight);
}

New Type: MetalPerformanceShaders.MPSCnnLogSoftMaxGradient

public class MPSCnnLogSoftMaxGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnLogSoftMaxGradient (Foundation.NSCoder coder);
	protected MPSCnnLogSoftMaxGradient (Foundation.NSObjectFlag t);
	public MPSCnnLogSoftMaxGradient (Metal.IMTLDevice device);
	protected MPSCnnLogSoftMaxGradient (IntPtr handle);
	public MPSCnnLogSoftMaxGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnLogSoftMaxGradientNode

public class MPSCnnLogSoftMaxGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLogSoftMaxGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnLogSoftMaxGradientNode (IntPtr handle);
	public MPSCnnLogSoftMaxGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnLogSoftMaxGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSCnnLoss

public class MPSCnnLoss : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnLoss (Foundation.NSCoder coder);
	protected MPSCnnLoss (Foundation.NSObjectFlag t);
	protected MPSCnnLoss (IntPtr handle);
	public MPSCnnLoss (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnLoss (Metal.IMTLDevice device, MPSCnnLossDescriptor lossDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; }
	public virtual float Epsilon { get; }
	public virtual float LabelSmoothing { get; }
	public virtual MPSCnnLossType LossType { get; }
	public virtual uint NumberOfClasses { get; }
	public virtual MPSCnnReductionType ReductionType { get; }
	public virtual float Weight { get; }
	// methods
	public virtual MPSImage Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnLossLabels labels);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnLossLabels labels, MPSImage destinationImage);
	public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSCnnLossLabels> labels);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSCnnLossLabels> labels, Foundation.NSArray<MPSImage> destinationImage);
}

New Type: MetalPerformanceShaders.MPSCnnLossDataDescriptor

public class MPSCnnLossDataDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLossDataDescriptor (Foundation.NSObjectFlag t);
	protected MPSCnnLossDataDescriptor (IntPtr handle);
	// properties
	public virtual uint BytesPerImage { get; set; }
	public virtual uint BytesPerRow { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual MPSDataLayout Layout { get; }
	public virtual Metal.MTLSize Size { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static MPSCnnLossDataDescriptor Create (Foundation.NSData data, MPSDataLayout layout, Metal.MTLSize size);
}

New Type: MetalPerformanceShaders.MPSCnnLossDescriptor

public class MPSCnnLossDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLossDescriptor (Foundation.NSObjectFlag t);
	protected MPSCnnLossDescriptor (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
	public virtual float Epsilon { get; set; }
	public virtual float LabelSmoothing { get; set; }
	public virtual MPSCnnLossType LossType { get; set; }
	public virtual uint NumberOfClasses { get; set; }
	public virtual MPSCnnReductionType ReductionType { get; set; }
	public virtual float Weight { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static MPSCnnLossDescriptor Create (MPSCnnLossType lossType, MPSCnnReductionType reductionType);
}

New Type: MetalPerformanceShaders.MPSCnnLossLabels

public class MPSCnnLossLabels : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLossLabels (Foundation.NSObjectFlag t);
	protected MPSCnnLossLabels (IntPtr handle);
	public MPSCnnLossLabels (Metal.IMTLDevice device, MPSCnnLossDataDescriptor labelsDescriptor);
	public MPSCnnLossLabels (Metal.IMTLDevice device, Metal.MTLSize lossImageSize, MPSCnnLossDataDescriptor labelsDescriptor, MPSCnnLossDataDescriptor weightsDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSImage LabelsImage { get; }
	public virtual MPSImage LossImage { get; }
	public virtual MPSImage WeightsImage { get; }
}

New Type: MetalPerformanceShaders.MPSCnnLossNode

public class MPSCnnLossNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnLossNode (Foundation.NSObjectFlag t);
	protected MPSCnnLossNode (IntPtr handle);
	public MPSCnnLossNode (MPSNNImageNode source, MPSCnnLossDescriptor descriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNLabelsNode InputLabels { get; }
	// methods
	public static MPSCnnLossNode Create (MPSNNImageNode source, MPSCnnLossDescriptor descriptor);
}

New Type: MetalPerformanceShaders.MPSCnnLossType

[Serializable]
public enum MPSCnnLossType {
	CategoricalCrossEntropy = 4,
	CosineDistance = 7,
	Hinge = 5,
	Huber = 6,
	KullbackLeiblerDivergence = 9,
	Log = 8,
	MeanAbsoluteError = 0,
	MeanSquaredError = 1,
	SigmoidCrossEntropy = 3,
	SoftMaxCrossEntropy = 2,
}

New Type: MetalPerformanceShaders.MPSCnnMultiply

public class MPSCnnMultiply : MetalPerformanceShaders.MPSCnnArithmetic, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnMultiply (Foundation.NSCoder coder);
	protected MPSCnnMultiply (Foundation.NSObjectFlag t);
	public MPSCnnMultiply (Metal.IMTLDevice device);
	protected MPSCnnMultiply (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnMultiplyGradient

public class MPSCnnMultiplyGradient : MetalPerformanceShaders.MPSCnnArithmeticGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnMultiplyGradient (Foundation.NSCoder coder);
	protected MPSCnnMultiplyGradient (Foundation.NSObjectFlag t);
	protected MPSCnnMultiplyGradient (IntPtr handle);
	public MPSCnnMultiplyGradient (Metal.IMTLDevice device, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnNeuronExponential

public class MPSCnnNeuronExponential : MetalPerformanceShaders.MPSCnnNeuron, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnNeuronExponential (Foundation.NSCoder coder);
	protected MPSCnnNeuronExponential (Foundation.NSObjectFlag t);
	protected MPSCnnNeuronExponential (IntPtr handle);
	public MPSCnnNeuronExponential (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);
	public MPSCnnNeuronExponential (Metal.IMTLDevice device, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnNeuronExponentialNode

public class MPSCnnNeuronExponentialNode : MetalPerformanceShaders.MPSCnnNeuronNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNeuronExponentialNode (Foundation.NSObjectFlag t);
	public MPSCnnNeuronExponentialNode (MPSNNImageNode sourceNode);
	protected MPSCnnNeuronExponentialNode (IntPtr handle);
	public MPSCnnNeuronExponentialNode (MPSNNImageNode sourceNode, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnNeuronExponentialNode Create (MPSNNImageNode sourceNode);
	public static MPSCnnNeuronExponentialNode Create (MPSNNImageNode sourceNode, float a, float b, float c);
}

New Type: MetalPerformanceShaders.MPSCnnNeuronGradient

public class MPSCnnNeuronGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnNeuronGradient (Foundation.NSCoder coder);
	protected MPSCnnNeuronGradient (Foundation.NSObjectFlag t);
	protected MPSCnnNeuronGradient (IntPtr handle);
	public MPSCnnNeuronGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnNeuronGradient (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);
	// properties
	public virtual float A { get; }
	public virtual float B { get; }
	public virtual float C { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSData Data { get; }
	public virtual MPSCnnNeuronType NeuronType { get; }
}

New Type: MetalPerformanceShaders.MPSCnnNeuronGradientNode

public class MPSCnnNeuronGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNeuronGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnNeuronGradientNode (IntPtr handle);
	public MPSCnnNeuronGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, MPSNNNeuronDescriptor descriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNNeuronDescriptor Descriptor { get; }
	// methods
	public static MPSCnnNeuronGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, MPSNNNeuronDescriptor descriptor);
}

New Type: MetalPerformanceShaders.MPSCnnNeuronLogarithm

public class MPSCnnNeuronLogarithm : MetalPerformanceShaders.MPSCnnNeuron, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnNeuronLogarithm (Foundation.NSCoder coder);
	protected MPSCnnNeuronLogarithm (Foundation.NSObjectFlag t);
	protected MPSCnnNeuronLogarithm (IntPtr handle);
	public MPSCnnNeuronLogarithm (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);
	public MPSCnnNeuronLogarithm (Metal.IMTLDevice device, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnNeuronLogarithmNode

public class MPSCnnNeuronLogarithmNode : MetalPerformanceShaders.MPSCnnNeuronNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNeuronLogarithmNode (Foundation.NSObjectFlag t);
	public MPSCnnNeuronLogarithmNode (MPSNNImageNode sourceNode);
	protected MPSCnnNeuronLogarithmNode (IntPtr handle);
	public MPSCnnNeuronLogarithmNode (MPSNNImageNode sourceNode, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnNeuronLogarithmNode Create (MPSNNImageNode sourceNode);
	public static MPSCnnNeuronLogarithmNode Create (MPSNNImageNode sourceNode, float a, float b, float c);
}

New Type: MetalPerformanceShaders.MPSCnnNeuronPower

public class MPSCnnNeuronPower : MetalPerformanceShaders.MPSCnnNeuron, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnNeuronPower (Foundation.NSCoder coder);
	protected MPSCnnNeuronPower (Foundation.NSObjectFlag t);
	protected MPSCnnNeuronPower (IntPtr handle);
	public MPSCnnNeuronPower (Metal.IMTLDevice device, MPSNNNeuronDescriptor neuronDescriptor);
	public MPSCnnNeuronPower (Metal.IMTLDevice device, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnNeuronPowerNode

public class MPSCnnNeuronPowerNode : MetalPerformanceShaders.MPSCnnNeuronNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNeuronPowerNode (Foundation.NSObjectFlag t);
	public MPSCnnNeuronPowerNode (MPSNNImageNode sourceNode);
	protected MPSCnnNeuronPowerNode (IntPtr handle);
	public MPSCnnNeuronPowerNode (MPSNNImageNode sourceNode, float a, float b, float c);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnNeuronPowerNode Create (MPSNNImageNode sourceNode);
	public static MPSCnnNeuronPowerNode Create (MPSNNImageNode sourceNode, float a, float b, float c);
}

New Type: MetalPerformanceShaders.MPSCnnNormalizationGammaAndBetaState

public class MPSCnnNormalizationGammaAndBetaState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNormalizationGammaAndBetaState (Foundation.NSObjectFlag t);
	protected MPSCnnNormalizationGammaAndBetaState (IntPtr handle);
	public MPSCnnNormalizationGammaAndBetaState (Metal.IMTLBuffer gamma, Metal.IMTLBuffer beta);
	// properties
	public virtual Metal.IMTLBuffer Beta { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer Gamma { get; }
	// methods
	public static MPSCnnNormalizationGammaAndBetaState GetTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint numberOfFeatureChannels);
}

New Type: MetalPerformanceShaders.MPSCnnNormalizationMeanAndVarianceState

public class MPSCnnNormalizationMeanAndVarianceState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnNormalizationMeanAndVarianceState (Foundation.NSObjectFlag t);
	protected MPSCnnNormalizationMeanAndVarianceState (IntPtr handle);
	public MPSCnnNormalizationMeanAndVarianceState (Metal.IMTLBuffer mean, Metal.IMTLBuffer variance);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer Mean { get; }
	public virtual Metal.IMTLBuffer Variance { get; }
	// methods
	public static MPSCnnNormalizationMeanAndVarianceState GetTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint numberOfFeatureChannels);
}

New Type: MetalPerformanceShaders.MPSCnnPoolingAverageGradient

public class MPSCnnPoolingAverageGradient : MetalPerformanceShaders.MPSCnnPoolingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnPoolingAverageGradient (Foundation.NSCoder coder);
	protected MPSCnnPoolingAverageGradient (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingAverageGradient (IntPtr handle);
	public MPSCnnPoolingAverageGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnPoolingAverageGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint ZeroPadSizeX { get; set; }
	public virtual uint ZeroPadSizeY { get; set; }
}

New Type: MetalPerformanceShaders.MPSCnnPoolingAverageGradientNode

public class MPSCnnPoolingAverageGradientNode : MetalPerformanceShaders.MPSCnnPoolingGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnPoolingAverageGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingAverageGradientNode (IntPtr handle);
	public MPSCnnPoolingAverageGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnPoolingAverageGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
}

New Type: MetalPerformanceShaders.MPSCnnPoolingGradient

public class MPSCnnPoolingGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnPoolingGradient (Foundation.NSCoder coder);
	protected MPSCnnPoolingGradient (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingGradient (IntPtr handle);
	public MPSCnnPoolingGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnPoolingGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight);
	public MPSCnnPoolingGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLSize SourceSize { get; set; }
}

New Type: MetalPerformanceShaders.MPSCnnPoolingGradientNode

public class MPSCnnPoolingGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnPoolingGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingGradientNode (IntPtr handle);
	public MPSCnnPoolingGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint KernelHeight { get; }
	public virtual uint KernelWidth { get; }
	public virtual uint StrideInPixelsX { get; }
	public virtual uint StrideInPixelsY { get; }
	// methods
	public static MPSCnnPoolingGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
}

New Type: MetalPerformanceShaders.MPSCnnPoolingL2NormGradient

public class MPSCnnPoolingL2NormGradient : MetalPerformanceShaders.MPSCnnPoolingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnPoolingL2NormGradient (Foundation.NSCoder coder);
	protected MPSCnnPoolingL2NormGradient (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingL2NormGradient (IntPtr handle);
	public MPSCnnPoolingL2NormGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnPoolingL2NormGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnPoolingL2NormGradientNode

public class MPSCnnPoolingL2NormGradientNode : MetalPerformanceShaders.MPSCnnPoolingGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnPoolingL2NormGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingL2NormGradientNode (IntPtr handle);
	public MPSCnnPoolingL2NormGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnPoolingL2NormGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
}

New Type: MetalPerformanceShaders.MPSCnnPoolingMaxGradient

public class MPSCnnPoolingMaxGradient : MetalPerformanceShaders.MPSCnnPoolingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnPoolingMaxGradient (Foundation.NSCoder coder);
	protected MPSCnnPoolingMaxGradient (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingMaxGradient (IntPtr handle);
	public MPSCnnPoolingMaxGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnPoolingMaxGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnPoolingMaxGradientNode

public class MPSCnnPoolingMaxGradientNode : MetalPerformanceShaders.MPSCnnPoolingGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnPoolingMaxGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnPoolingMaxGradientNode (IntPtr handle);
	public MPSCnnPoolingMaxGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnPoolingMaxGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelWidth, uint kernelHeight, uint strideInPixelsX, uint strideInPixelsY, IMPSNNPadding paddingPolicy);
}

New Type: MetalPerformanceShaders.MPSCnnReductionType

[Serializable]
public enum MPSCnnReductionType {
	Mean = 2,
	None = 0,
	Sum = 1,
	SumByNonZeroWeights = 3,
}

New Type: MetalPerformanceShaders.MPSCnnSoftMaxGradient

public class MPSCnnSoftMaxGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnSoftMaxGradient (Foundation.NSCoder coder);
	protected MPSCnnSoftMaxGradient (Foundation.NSObjectFlag t);
	public MPSCnnSoftMaxGradient (Metal.IMTLDevice device);
	protected MPSCnnSoftMaxGradient (IntPtr handle);
	public MPSCnnSoftMaxGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnSoftMaxGradientNode

public class MPSCnnSoftMaxGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnSoftMaxGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnSoftMaxGradientNode (IntPtr handle);
	public MPSCnnSoftMaxGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSCnnSoftMaxGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSCnnSpatialNormalizationGradient

public class MPSCnnSpatialNormalizationGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnSpatialNormalizationGradient (Foundation.NSCoder coder);
	protected MPSCnnSpatialNormalizationGradient (Foundation.NSObjectFlag t);
	protected MPSCnnSpatialNormalizationGradient (IntPtr handle);
	public MPSCnnSpatialNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnSpatialNormalizationGradient (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight);
	// properties
	public virtual float Alpha { get; set; }
	public virtual float Beta { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
}

New Type: MetalPerformanceShaders.MPSCnnSpatialNormalizationGradientNode

public class MPSCnnSpatialNormalizationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnSpatialNormalizationGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnSpatialNormalizationGradientNode (IntPtr handle);
	public MPSCnnSpatialNormalizationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelSize);
	// properties
	public virtual float Alpha { get; set; }
	public virtual float Beta { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float Delta { get; set; }
	public virtual uint KernelHeight { get; set; }
	public virtual uint KernelWidth { get; set; }
	// methods
	public static MPSCnnSpatialNormalizationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, uint kernelSize);
}

New Type: MetalPerformanceShaders.MPSCnnSubtract

public class MPSCnnSubtract : MetalPerformanceShaders.MPSCnnArithmetic, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnSubtract (Foundation.NSCoder coder);
	protected MPSCnnSubtract (Foundation.NSObjectFlag t);
	public MPSCnnSubtract (Metal.IMTLDevice device);
	protected MPSCnnSubtract (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnSubtractGradient

public class MPSCnnSubtractGradient : MetalPerformanceShaders.MPSCnnArithmeticGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnSubtractGradient (Foundation.NSCoder coder);
	protected MPSCnnSubtractGradient (Foundation.NSObjectFlag t);
	protected MPSCnnSubtractGradient (IntPtr handle);
	public MPSCnnSubtractGradient (Metal.IMTLDevice device, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnUpsamplingBilinearGradient

public class MPSCnnUpsamplingBilinearGradient : MetalPerformanceShaders.MPSCnnUpsamplingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnUpsamplingBilinearGradient (Foundation.NSCoder coder);
	protected MPSCnnUpsamplingBilinearGradient (Foundation.NSObjectFlag t);
	protected MPSCnnUpsamplingBilinearGradient (IntPtr handle);
	public MPSCnnUpsamplingBilinearGradient (Metal.IMTLDevice device, uint integerScaleFactorX, uint integerScaleFactorY);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnUpsamplingBilinearGradientNode

public class MPSCnnUpsamplingBilinearGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnUpsamplingBilinearGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnUpsamplingBilinearGradientNode (IntPtr handle);
	public MPSCnnUpsamplingBilinearGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, double scaleFactorX, double scaleFactorY);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual double ScaleFactorX { get; }
	public virtual double ScaleFactorY { get; }
	// methods
	public static MPSCnnUpsamplingBilinearGradientNode NodeWithSourceGradient (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, double scaleFactorX, double scaleFactorY);
}

New Type: MetalPerformanceShaders.MPSCnnUpsamplingGradient

public class MPSCnnUpsamplingGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnUpsamplingGradient (Foundation.NSCoder coder);
	protected MPSCnnUpsamplingGradient (Foundation.NSObjectFlag t);
	public MPSCnnUpsamplingGradient (Metal.IMTLDevice device);
	protected MPSCnnUpsamplingGradient (IntPtr handle);
	public MPSCnnUpsamplingGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual double ScaleFactorX { get; }
	public virtual double ScaleFactorY { get; }
}

New Type: MetalPerformanceShaders.MPSCnnUpsamplingNearestGradient

public class MPSCnnUpsamplingNearestGradient : MetalPerformanceShaders.MPSCnnUpsamplingGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnUpsamplingNearestGradient (Foundation.NSCoder coder);
	protected MPSCnnUpsamplingNearestGradient (Foundation.NSObjectFlag t);
	protected MPSCnnUpsamplingNearestGradient (IntPtr handle);
	public MPSCnnUpsamplingNearestGradient (Metal.IMTLDevice device, uint integerScaleFactorX, uint integerScaleFactorY);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSCnnUpsamplingNearestGradientNode

public class MPSCnnUpsamplingNearestGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnUpsamplingNearestGradientNode (Foundation.NSObjectFlag t);
	protected MPSCnnUpsamplingNearestGradientNode (IntPtr handle);
	public MPSCnnUpsamplingNearestGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, double scaleFactorX, double scaleFactorY);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual double ScaleFactorX { get; }
	public virtual double ScaleFactorY { get; }
	// methods
	public static MPSCnnUpsamplingNearestGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState, double scaleFactorX, double scaleFactorY);
}

New Type: MetalPerformanceShaders.MPSCnnWeightsQuantizationType

[Serializable]
public enum MPSCnnWeightsQuantizationType {
	Linear = 1,
	LookupTable = 2,
	None = 0,
}

New Type: MetalPerformanceShaders.MPSCnnYoloLoss

public class MPSCnnYoloLoss : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSCnnYoloLoss (Foundation.NSCoder coder);
	protected MPSCnnYoloLoss (Foundation.NSObjectFlag t);
	protected MPSCnnYoloLoss (IntPtr handle);
	public MPSCnnYoloLoss (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSCnnYoloLoss (Metal.IMTLDevice device, MPSCnnYoloLossDescriptor lossDescriptor);
	// properties
	public virtual Foundation.NSData AnchorBoxes { get; }
	public override IntPtr ClassHandle { get; }
	public virtual MPSCnnLoss LossClasses { get; }
	public virtual MPSCnnLoss LossConfidence { get; }
	public virtual MPSCnnLoss LossWH { get; }
	public virtual MPSCnnLoss LossXY { get; }
	public virtual float MaxIouForObjectAbsence { get; }
	public virtual float MinIouForObjectPresence { get; }
	public virtual uint NumberOfAnchorBoxes { get; }
	public virtual MPSCnnReductionType ReductionType { get; }
	public virtual float ScaleClass { get; }
	public virtual float ScaleNoObject { get; }
	public virtual float ScaleObject { get; }
	public virtual float ScaleWH { get; }
	public virtual float ScaleXY { get; }
	// methods
	public virtual MPSImage Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnLossLabels labels);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSImage sourceImage, MPSCnnLossLabels labels, MPSImage destinationImage);
	public virtual Foundation.NSArray<MPSImage> EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSCnnLossLabels> labels);
	public virtual void EncodeBatch (Metal.IMTLCommandBuffer commandBuffer, Foundation.NSArray<MPSImage> sourceImage, Foundation.NSArray<MPSCnnLossLabels> labels, Foundation.NSArray<MPSImage> destinationImage);
}

New Type: MetalPerformanceShaders.MPSCnnYoloLossDescriptor

public class MPSCnnYoloLossDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnYoloLossDescriptor (Foundation.NSObjectFlag t);
	protected MPSCnnYoloLossDescriptor (IntPtr handle);
	// properties
	public virtual Foundation.NSData AnchorBoxes { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual MPSCnnLossDescriptor ClassesLossDescriptor { get; set; }
	public virtual MPSCnnLossDescriptor ConfidenceLossDescriptor { get; set; }
	public virtual float MaxIouForObjectAbsence { get; set; }
	public virtual float MinIouForObjectPresence { get; set; }
	public virtual uint NumberOfAnchorBoxes { get; set; }
	public virtual MPSCnnReductionType ReductionType { get; set; }
	public virtual bool Rescore { get; set; }
	public virtual float ScaleClass { get; set; }
	public virtual float ScaleNoObject { get; set; }
	public virtual float ScaleObject { get; set; }
	public virtual float ScaleWH { get; set; }
	public virtual float ScaleXY { get; set; }
	public virtual MPSCnnLossDescriptor WHLossDescriptor { get; set; }
	public virtual MPSCnnLossDescriptor XYLossDescriptor { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static MPSCnnYoloLossDescriptor Create (MPSCnnLossType xyLossType, MPSCnnLossType whLossType, MPSCnnLossType confidenceLossType, MPSCnnLossType classesLossType, MPSCnnReductionType reductionType, Foundation.NSData anchorBoxes, uint numberOfAnchorBoxes);
}

New Type: MetalPerformanceShaders.MPSCnnYoloLossNode

public class MPSCnnYoloLossNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSCnnYoloLossNode (Foundation.NSObjectFlag t);
	protected MPSCnnYoloLossNode (IntPtr handle);
	public MPSCnnYoloLossNode (MPSNNImageNode source, MPSCnnYoloLossDescriptor descriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNLabelsNode InputLabels { get; }
	// methods
	public static MPSCnnYoloLossNode Create (MPSNNImageNode source, MPSCnnYoloLossDescriptor descriptor);
}

New Type: MetalPerformanceShaders.MPSGradientNodeHandler

public sealed delegate MPSGradientNodeHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public MPSGradientNodeHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (MPSNNFilterNode gradientNode, MPSNNFilterNode inferenceNode, MPSNNImageNode inferenceSource, MPSNNImageNode gradientSource, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (MPSNNFilterNode gradientNode, MPSNNFilterNode inferenceNode, MPSNNImageNode inferenceSource, MPSNNImageNode gradientSource);
}

New Type: MetalPerformanceShaders.MPSImageAllocator_Extensions

public static class MPSImageAllocator_Extensions {
	// methods
	public static Foundation.NSArray<MPSImage> GetImageBatch (this IMPSImageAllocator This, Metal.IMTLCommandBuffer commandBuffer, MPSImageDescriptor descriptor, MPSKernel kernel, uint count);
}

New Type: MetalPerformanceShaders.MPSImageBatch

public static class MPSImageBatch {
	// methods
	public static uint GetResourceSize (Foundation.NSArray<MPSImage> imageBatch);
	public static uint IncrementReadCount (Foundation.NSArray<MPSImage> imageBatch, nint amount);
	public static void Synchronize (Foundation.NSArray<MPSImage> imageBatch, Metal.IMTLCommandBuffer commandBuffer);
}

New Type: MetalPerformanceShaders.MPSImageCoordinate

public struct MPSImageCoordinate {
	// fields
	public uint Channel;
	public uint X;
	public uint Y;
}

New Type: MetalPerformanceShaders.MPSImageEuclideanDistanceTransform

public class MPSImageEuclideanDistanceTransform : MetalPerformanceShaders.MPSUnaryImageKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageEuclideanDistanceTransform (Foundation.NSCoder coder);
	protected MPSImageEuclideanDistanceTransform (Foundation.NSObjectFlag t);
	public MPSImageEuclideanDistanceTransform (Metal.IMTLDevice device);
	protected MPSImageEuclideanDistanceTransform (IntPtr handle);
	public MPSImageEuclideanDistanceTransform (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageGuidedFilter

public class MPSImageGuidedFilter : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageGuidedFilter (Foundation.NSCoder coder);
	protected MPSImageGuidedFilter (Foundation.NSObjectFlag t);
	protected MPSImageGuidedFilter (IntPtr handle);
	public MPSImageGuidedFilter (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSImageGuidedFilter (Metal.IMTLDevice device, uint kernelDiameter);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Epsilon { get; set; }
	public virtual uint KernelDiameter { get; }
	public virtual float ReconstructOffset { get; set; }
	public virtual float ReconstructScale { get; set; }
	// methods
	public virtual void EncodeReconstruction (Metal.IMTLCommandBuffer commandBuffer, Metal.IMTLTexture guidanceTexture, Metal.IMTLTexture coefficientsTexture, Metal.IMTLTexture destinationTexture);
	public virtual void EncodeRegression (Metal.IMTLCommandBuffer commandBuffer, Metal.IMTLTexture sourceTexture, Metal.IMTLTexture guidanceTexture, Metal.IMTLTexture weightsTexture, Metal.IMTLTexture destinationCoefficientsTexture);
}

New Type: MetalPerformanceShaders.MPSImageLaplacianPyramid

public class MPSImageLaplacianPyramid : MetalPerformanceShaders.MPSImagePyramid, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageLaplacianPyramid (Foundation.NSCoder coder);
	protected MPSImageLaplacianPyramid (Foundation.NSObjectFlag t);
	public MPSImageLaplacianPyramid (Metal.IMTLDevice device);
	protected MPSImageLaplacianPyramid (IntPtr handle);
	public MPSImageLaplacianPyramid (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSImageLaplacianPyramid (Metal.IMTLDevice device, float centerWeight);
	public MPSImageLaplacianPyramid (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, float[] kernelWeights);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float LaplacianBias { get; set; }
	public virtual float LaplacianScale { get; set; }
}

New Type: MetalPerformanceShaders.MPSImageLaplacianPyramidAdd

public class MPSImageLaplacianPyramidAdd : MetalPerformanceShaders.MPSImageLaplacianPyramid, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageLaplacianPyramidAdd (Foundation.NSCoder coder);
	protected MPSImageLaplacianPyramidAdd (Foundation.NSObjectFlag t);
	public MPSImageLaplacianPyramidAdd (Metal.IMTLDevice device);
	protected MPSImageLaplacianPyramidAdd (IntPtr handle);
	public MPSImageLaplacianPyramidAdd (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSImageLaplacianPyramidAdd (Metal.IMTLDevice device, float centerWeight);
	public MPSImageLaplacianPyramidAdd (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, float[] kernelWeights);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageLaplacianPyramidSubtract

public class MPSImageLaplacianPyramidSubtract : MetalPerformanceShaders.MPSImageLaplacianPyramid, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageLaplacianPyramidSubtract (Foundation.NSCoder coder);
	protected MPSImageLaplacianPyramidSubtract (Foundation.NSObjectFlag t);
	public MPSImageLaplacianPyramidSubtract (Metal.IMTLDevice device);
	protected MPSImageLaplacianPyramidSubtract (IntPtr handle);
	public MPSImageLaplacianPyramidSubtract (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSImageLaplacianPyramidSubtract (Metal.IMTLDevice device, float centerWeight);
	public MPSImageLaplacianPyramidSubtract (Metal.IMTLDevice device, uint kernelWidth, uint kernelHeight, float[] kernelWeights);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageNormalizedHistogram

public class MPSImageNormalizedHistogram : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageNormalizedHistogram (Foundation.NSCoder coder);
	protected MPSImageNormalizedHistogram (Foundation.NSObjectFlag t);
	protected MPSImageNormalizedHistogram (IntPtr handle);
	public MPSImageNormalizedHistogram (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSImageNormalizedHistogram (Metal.IMTLDevice device, ref MPSImageHistogramInfo histogramInfo);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLRegion ClipRectSource { get; set; }
	public virtual MPSImageHistogramInfo HistogramInfo { get; }
	public virtual bool ZeroHistogram { get; set; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, Metal.IMTLTexture source, Metal.IMTLTexture minmaxTexture, Metal.IMTLBuffer histogram, uint histogramOffset);
	public virtual uint GetHistogramSize (Metal.MTLPixelFormat sourceFormat);
}

New Type: MetalPerformanceShaders.MPSImageReduceColumnMax

public class MPSImageReduceColumnMax : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceColumnMax (Foundation.NSCoder coder);
	protected MPSImageReduceColumnMax (Foundation.NSObjectFlag t);
	public MPSImageReduceColumnMax (Metal.IMTLDevice device);
	protected MPSImageReduceColumnMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceColumnMean

public class MPSImageReduceColumnMean : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceColumnMean (Foundation.NSCoder coder);
	protected MPSImageReduceColumnMean (Foundation.NSObjectFlag t);
	public MPSImageReduceColumnMean (Metal.IMTLDevice device);
	protected MPSImageReduceColumnMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceColumnMin

public class MPSImageReduceColumnMin : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceColumnMin (Foundation.NSCoder coder);
	protected MPSImageReduceColumnMin (Foundation.NSObjectFlag t);
	public MPSImageReduceColumnMin (Metal.IMTLDevice device);
	protected MPSImageReduceColumnMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceColumnSum

public class MPSImageReduceColumnSum : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceColumnSum (Foundation.NSCoder coder);
	protected MPSImageReduceColumnSum (Foundation.NSObjectFlag t);
	public MPSImageReduceColumnSum (Metal.IMTLDevice device);
	protected MPSImageReduceColumnSum (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceRowMax

public class MPSImageReduceRowMax : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceRowMax (Foundation.NSCoder coder);
	protected MPSImageReduceRowMax (Foundation.NSObjectFlag t);
	public MPSImageReduceRowMax (Metal.IMTLDevice device);
	protected MPSImageReduceRowMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceRowMean

public class MPSImageReduceRowMean : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceRowMean (Foundation.NSCoder coder);
	protected MPSImageReduceRowMean (Foundation.NSObjectFlag t);
	public MPSImageReduceRowMean (Metal.IMTLDevice device);
	protected MPSImageReduceRowMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceRowMin

public class MPSImageReduceRowMin : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceRowMin (Foundation.NSCoder coder);
	protected MPSImageReduceRowMin (Foundation.NSObjectFlag t);
	public MPSImageReduceRowMin (Metal.IMTLDevice device);
	protected MPSImageReduceRowMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceRowSum

public class MPSImageReduceRowSum : MetalPerformanceShaders.MPSImageReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceRowSum (Foundation.NSCoder coder);
	protected MPSImageReduceRowSum (Foundation.NSObjectFlag t);
	public MPSImageReduceRowSum (Metal.IMTLDevice device);
	protected MPSImageReduceRowSum (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSImageReduceUnary

public class MPSImageReduceUnary : MetalPerformanceShaders.MPSUnaryImageKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSImageReduceUnary (Foundation.NSCoder coder);
	protected MPSImageReduceUnary (Foundation.NSObjectFlag t);
	protected MPSImageReduceUnary (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLRegion ClipRectSource { get; set; }
}

New Type: MetalPerformanceShaders.MPSImageRegion

public struct MPSImageRegion {
	// fields
	public MPSImageCoordinate Offset;
	public MPSImageCoordinate Size;
}

New Type: MetalPerformanceShaders.MPSInstanceAccelerationStructure

public class MPSInstanceAccelerationStructure : MetalPerformanceShaders.MPSAccelerationStructure, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSInstanceAccelerationStructure (Foundation.NSCoder coder);
	protected MPSInstanceAccelerationStructure (Foundation.NSObjectFlag t);
	public MPSInstanceAccelerationStructure (Metal.IMTLDevice device);
	public MPSInstanceAccelerationStructure (MPSAccelerationStructureGroup group);
	protected MPSInstanceAccelerationStructure (IntPtr handle);
	public MPSInstanceAccelerationStructure (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSInstanceAccelerationStructure (Foundation.NSCoder aDecoder, MPSAccelerationStructureGroup group);
	// properties
	public virtual MPSTriangleAccelerationStructure[] AccelerationStructures { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer InstanceBuffer { get; set; }
	public virtual uint InstanceBufferOffset { get; set; }
	public virtual uint InstanceCount { get; set; }
	public virtual Metal.IMTLBuffer MaskBuffer { get; set; }
	public virtual uint MaskBufferOffset { get; set; }
	public virtual Metal.IMTLBuffer TransformBuffer { get; set; }
	public virtual uint TransformBufferOffset { get; set; }
	public virtual MPSTransformType TransformType { get; set; }
}

New Type: MetalPerformanceShaders.MPSIntersectionDataType

[Serializable]
public enum MPSIntersectionDataType {
	Distance = 0,
	PrimitiveIndex = 1,
	PrimitiveIndexCoordinates = 2,
	PrimitiveIndexInstanceIndex = 3,
	PrimitiveIndexInstanceIndexCoordinates = 4,
}

New Type: MetalPerformanceShaders.MPSIntersectionType

[Serializable]
public enum MPSIntersectionType {
	Any = 1,
	Nearest = 0,
}

New Type: MetalPerformanceShaders.MPSKeyedUnarchiver

public class MPSKeyedUnarchiver : Foundation.NSKeyedUnarchiver, Foundation.INSObjectProtocol, IMPSDeviceProvider, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSKeyedUnarchiver (Foundation.NSObjectFlag t);
	protected MPSKeyedUnarchiver (IntPtr handle);
	public MPSKeyedUnarchiver (Foundation.NSData data, Metal.IMTLDevice device, out Foundation.NSError error);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual Metal.IMTLDevice GetMTLDevice ();
	public static Foundation.NSObject GetUnarchivedObject (Foundation.NSSet<ObjCRuntime.Class> classes, Foundation.NSData data, Metal.IMTLDevice device, out Foundation.NSError error);
	public static Foundation.NSObject GetUnarchivedObject (ObjCRuntime.Class class, Foundation.NSData data, Metal.IMTLDevice device, out Foundation.NSError error);
}

New Type: MetalPerformanceShaders.MPSMatrixBatchNormalization

public class MPSMatrixBatchNormalization : MetalPerformanceShaders.MPSMatrixUnaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixBatchNormalization (Foundation.NSCoder coder);
	protected MPSMatrixBatchNormalization (Foundation.NSObjectFlag t);
	public MPSMatrixBatchNormalization (Metal.IMTLDevice device);
	protected MPSMatrixBatchNormalization (IntPtr handle);
	public MPSMatrixBatchNormalization (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual bool ComputeStatistics { get; set; }
	public virtual float Epsilon { get; set; }
	public virtual float NeuronParameterA { get; }
	public virtual float NeuronParameterB { get; }
	public virtual float NeuronParameterC { get; }
	public virtual MPSCnnNeuronType NeuronType { get; }
	public virtual uint SourceInputFeatureChannels { get; set; }
	public virtual uint SourceNumberOfFeatureVectors { get; set; }
	// methods
	public virtual MPSMatrixBatchNormalization Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix inputMatrix, MPSVector meanVector, MPSVector varianceVector, MPSVector gammaVector, MPSVector betaVector, MPSMatrix resultMatrix);
	public virtual void SetNeuronType (MPSCnnNeuronType neuronType, float parameterA, float parameterB, float parameterC);
}

New Type: MetalPerformanceShaders.MPSMatrixBatchNormalizationGradient

public class MPSMatrixBatchNormalizationGradient : MetalPerformanceShaders.MPSMatrixBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixBatchNormalizationGradient (Foundation.NSCoder coder);
	protected MPSMatrixBatchNormalizationGradient (Foundation.NSObjectFlag t);
	public MPSMatrixBatchNormalizationGradient (Metal.IMTLDevice device);
	protected MPSMatrixBatchNormalizationGradient (IntPtr handle);
	public MPSMatrixBatchNormalizationGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Epsilon { get; set; }
	public virtual float NeuronParameterA { get; }
	public virtual float NeuronParameterB { get; }
	public virtual float NeuronParameterC { get; }
	public virtual MPSCnnNeuronType NeuronType { get; }
	public virtual uint SourceInputFeatureChannels { get; set; }
	public virtual uint SourceNumberOfFeatureVectors { get; set; }
	// methods
	public virtual MPSMatrixBatchNormalizationGradient Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix gradientMatrix, MPSMatrix inputMatrix, MPSVector meanVector, MPSVector varianceVector, MPSVector gammaVector, MPSVector betaVector, MPSMatrix resultGradientForDataMatrix, MPSVector resultGradientForGammaVector, MPSVector resultGradientForBetaVector);
	public virtual void SetNeuronType (MPSCnnNeuronType neuronType, float parameterA, float parameterB, float parameterC);
}

New Type: MetalPerformanceShaders.MPSMatrixCopyToImage

public class MPSMatrixCopyToImage : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixCopyToImage (Foundation.NSCoder coder);
	protected MPSMatrixCopyToImage (Foundation.NSObjectFlag t);
	protected MPSMatrixCopyToImage (IntPtr handle);
	public MPSMatrixCopyToImage (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSMatrixCopyToImage (Metal.IMTLDevice device, MPSDataLayout dataLayout);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSDataLayout DataLayout { get; }
	public virtual uint SourceMatrixBatchIndex { get; set; }
	public virtual Metal.MTLOrigin SourceMatrixOrigin { get; set; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix sourceMatrix, Foundation.NSArray<MPSImage> destinationImages);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix sourceMatrix, MPSImage destinationImage);
}

New Type: MetalPerformanceShaders.MPSMatrixFullyConnectedGradient

public class MPSMatrixFullyConnectedGradient : MetalPerformanceShaders.MPSMatrixBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixFullyConnectedGradient (Foundation.NSCoder coder);
	protected MPSMatrixFullyConnectedGradient (Foundation.NSObjectFlag t);
	public MPSMatrixFullyConnectedGradient (Metal.IMTLDevice device);
	protected MPSMatrixFullyConnectedGradient (IntPtr handle);
	public MPSMatrixFullyConnectedGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public virtual double Alpha { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual uint SourceInputFeatureChannels { get; set; }
	public virtual uint SourceNumberOfFeatureVectors { get; set; }
	public virtual uint SourceOutputFeatureChannels { get; set; }
	// methods
	public virtual MPSMatrixFullyConnectedGradient Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void EncodeGradientForData (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix gradientMatrix, MPSMatrix weightMatrix, MPSMatrix resultGradientForDataMatrix);
	public virtual void EncodeGradientForWeightsAndBias (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix gradientMatrix, MPSMatrix inputMatrix, MPSMatrix resultGradientForWeightMatrix, MPSVector resultGradientForBiasVector);
}

New Type: MetalPerformanceShaders.MPSMatrixLogSoftMaxGradient

public class MPSMatrixLogSoftMaxGradient : MetalPerformanceShaders.MPSMatrixSoftMaxGradient, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixLogSoftMaxGradient (Foundation.NSCoder coder);
	protected MPSMatrixLogSoftMaxGradient (Foundation.NSObjectFlag t);
	public MPSMatrixLogSoftMaxGradient (Metal.IMTLDevice device);
	protected MPSMatrixLogSoftMaxGradient (IntPtr handle);
	public MPSMatrixLogSoftMaxGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSMatrixNeuronGradient

public class MPSMatrixNeuronGradient : MetalPerformanceShaders.MPSMatrixBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixNeuronGradient (Foundation.NSCoder coder);
	protected MPSMatrixNeuronGradient (Foundation.NSObjectFlag t);
	public MPSMatrixNeuronGradient (Metal.IMTLDevice device);
	protected MPSMatrixNeuronGradient (IntPtr handle);
	public MPSMatrixNeuronGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public virtual double Alpha { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float NeuronParameterA { get; }
	public virtual float NeuronParameterB { get; }
	public virtual float NeuronParameterC { get; }
	public virtual MPSCnnNeuronType NeuronType { get; }
	public virtual uint SourceInputFeatureChannels { get; set; }
	public virtual uint SourceNumberOfFeatureVectors { get; set; }
	// methods
	public virtual MPSMatrixNeuronGradient Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix gradientMatrix, MPSMatrix inputMatrix, MPSVector biasVector, MPSMatrix resultGradientForDataMatrix, MPSVector resultGradientForBiasVector);
	public virtual void SetNeuronToPReLU (Foundation.NSData a);
	public virtual void SetNeuronType (MPSCnnNeuronType neuronType, float parameterA, float parameterB, float parameterC);
}

New Type: MetalPerformanceShaders.MPSMatrixSoftMaxGradient

public class MPSMatrixSoftMaxGradient : MetalPerformanceShaders.MPSMatrixBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSMatrixSoftMaxGradient (Foundation.NSCoder coder);
	protected MPSMatrixSoftMaxGradient (Foundation.NSObjectFlag t);
	public MPSMatrixSoftMaxGradient (Metal.IMTLDevice device);
	protected MPSMatrixSoftMaxGradient (IntPtr handle);
	public MPSMatrixSoftMaxGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint SourceColumns { get; set; }
	public virtual uint SourceRows { get; set; }
	// methods
	public virtual MPSMatrixSoftMaxGradient Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void EncodeToCommandBuffer (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix gradientMatrix, MPSMatrix forwardOutputMatrix, MPSMatrix resultMatrix);
}

New Type: MetalPerformanceShaders.MPSNNAdditionGradientNode

public class MPSNNAdditionGradientNode : MetalPerformanceShaders.MPSNNArithmeticGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNAdditionGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNAdditionGradientNode (IntPtr handle);
	public MPSNNAdditionGradientNode (MPSNNImageNode[] gradientImages, MPSNNFilterNode filter, bool isSecondarySourceFilter);
	public MPSNNAdditionGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNAdditionGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
}

New Type: MetalPerformanceShaders.MPSNNArithmeticGradientNode

public class MPSNNArithmeticGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNArithmeticGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNArithmeticGradientNode (IntPtr handle);
	public MPSNNArithmeticGradientNode (MPSNNImageNode[] gradientImages, MPSNNFilterNode filter, bool isSecondarySourceFilter);
	public MPSNNArithmeticGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
	// properties
	public virtual float Bias { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual bool IsSecondarySourceFilter { get; }
	public virtual float MaximumValue { get; set; }
	public virtual float MinimumValue { get; set; }
	public virtual float PrimaryScale { get; set; }
	public virtual float SecondaryScale { get; set; }
	public virtual uint SecondaryStrideInFeatureChannels { get; set; }
	public virtual uint SecondaryStrideInPixelsX { get; set; }
	public virtual uint SecondaryStrideInPixelsY { get; set; }
	// methods
	public static MPSNNArithmeticGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
}

New Type: MetalPerformanceShaders.MPSNNArithmeticGradientStateNode

public class MPSNNArithmeticGradientStateNode : MetalPerformanceShaders.MPSNNBinaryGradientStateNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNArithmeticGradientStateNode (Foundation.NSObjectFlag t);
	protected MPSNNArithmeticGradientStateNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNBinaryGradientState

public class MPSNNBinaryGradientState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNBinaryGradientState (Foundation.NSObjectFlag t);
	public MPSNNBinaryGradientState (Metal.IMTLResource resource);
	public MPSNNBinaryGradientState (Metal.IMTLResource[] resources);
	protected MPSNNBinaryGradientState (IntPtr handle);
	public MPSNNBinaryGradientState (Metal.IMTLDevice device, Metal.MTLTextureDescriptor descriptor);
	public MPSNNBinaryGradientState (Metal.IMTLDevice device, MPSStateResourceList resourceList);
	public MPSNNBinaryGradientState (Metal.IMTLDevice device, uint bufferSize);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNBinaryGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer);
	public static MPSNNBinaryGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, Metal.MTLTextureDescriptor descriptor);
	public static MPSNNBinaryGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, MPSStateResourceList resourceList);
	public static MPSNNBinaryGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint bufferSize);
}

New Type: MetalPerformanceShaders.MPSNNBinaryGradientStateNode

public class MPSNNBinaryGradientStateNode : MetalPerformanceShaders.MPSNNStateNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNBinaryGradientStateNode (Foundation.NSObjectFlag t);
	protected MPSNNBinaryGradientStateNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNCompare

public class MPSNNCompare : MetalPerformanceShaders.MPSCnnArithmetic, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNCompare (Foundation.NSCoder coder);
	protected MPSNNCompare (Foundation.NSObjectFlag t);
	public MPSNNCompare (Metal.IMTLDevice device);
	protected MPSNNCompare (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNComparisonType ComparisonType { get; set; }
	public virtual float Threshold { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNComparisonNode

public class MPSNNComparisonNode : MetalPerformanceShaders.MPSNNBinaryArithmeticNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNComparisonNode (Foundation.NSObjectFlag t);
	protected MPSNNComparisonNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual MPSNNComparisonType ComparisonType { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNComparisonType

[Serializable]
[Flags]
public enum MPSNNComparisonType {
	Equal = 0,
	Greater = 4,
	GreaterOrEqual = 5,
	Less = 2,
	LessOrEqual = 3,
	NotEqual = 1,
}

New Type: MetalPerformanceShaders.MPSNNConcatenationGradientNode

public class MPSNNConcatenationGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNConcatenationGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNConcatenationGradientNode (IntPtr handle);
	public MPSNNConcatenationGradientNode (MPSNNImageNode gradientSourceNode, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNConcatenationGradientNode Create (MPSNNImageNode gradientSourceNode, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSNNConvolutionAccumulatorPrecisionOption

[Serializable]
[Flags]
public enum MPSNNConvolutionAccumulatorPrecisionOption {
	Float = 1,
	Half = 0,
}

New Type: MetalPerformanceShaders.MPSNNCropAndResizeBilinear

public class MPSNNCropAndResizeBilinear : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNCropAndResizeBilinear (Foundation.NSCoder coder);
	protected MPSNNCropAndResizeBilinear (Foundation.NSObjectFlag t);
	protected MPSNNCropAndResizeBilinear (IntPtr handle);
	public MPSNNCropAndResizeBilinear (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSNNCropAndResizeBilinear (Metal.IMTLDevice device, uint resizeWidth, uint resizeHeight, uint numberOfRegions, IntPtr regions);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual uint NumberOfRegions { get; }
	public virtual IntPtr Regions { get; }
	public virtual uint ResizeHeight { get; }
	public virtual uint ResizeWidth { get; }
}

New Type: MetalPerformanceShaders.MPSNNGradientFilterNode

public class MPSNNGradientFilterNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNGradientFilterNode (Foundation.NSObjectFlag t);
	protected MPSNNGradientFilterNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNGradientState

public class MPSNNGradientState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNGradientState (Foundation.NSObjectFlag t);
	public MPSNNGradientState (Metal.IMTLResource resource);
	public MPSNNGradientState (Metal.IMTLResource[] resources);
	protected MPSNNGradientState (IntPtr handle);
	public MPSNNGradientState (Metal.IMTLDevice device, Metal.MTLTextureDescriptor descriptor);
	public MPSNNGradientState (Metal.IMTLDevice device, MPSStateResourceList resourceList);
	public MPSNNGradientState (Metal.IMTLDevice device, uint bufferSize);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer);
	public static MPSNNGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, Metal.MTLTextureDescriptor descriptor);
	public static MPSNNGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, MPSStateResourceList resourceList);
	public static MPSNNGradientState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint bufferSize);
}

New Type: MetalPerformanceShaders.MPSNNGradientStateNode

public class MPSNNGradientStateNode : MetalPerformanceShaders.MPSNNStateNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNGradientStateNode (Foundation.NSObjectFlag t);
	protected MPSNNGradientStateNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNLabelsNode

public class MPSNNLabelsNode : MetalPerformanceShaders.MPSNNStateNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNLabelsNode (Foundation.NSObjectFlag t);
	protected MPSNNLabelsNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNMultiplicationGradientNode

public class MPSNNMultiplicationGradientNode : MetalPerformanceShaders.MPSNNArithmeticGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNMultiplicationGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNMultiplicationGradientNode (IntPtr handle);
	public MPSNNMultiplicationGradientNode (MPSNNImageNode[] gradientImages, MPSNNFilterNode filter, bool isSecondarySourceFilter);
	public MPSNNMultiplicationGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNMultiplicationGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
}

New Type: MetalPerformanceShaders.MPSNNNeuronDescriptor

public class MPSNNNeuronDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNNeuronDescriptor (Foundation.NSObjectFlag t);
	protected MPSNNNeuronDescriptor (IntPtr handle);
	// properties
	public virtual float A { get; set; }
	public virtual float B { get; set; }
	public virtual float C { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSData Data { get; set; }
	public virtual MPSCnnNeuronType NeuronType { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static MPSNNNeuronDescriptor Create (MPSCnnNeuronType neuronType);
	public static MPSNNNeuronDescriptor Create (Foundation.NSData data, bool noCopy);
	public static MPSNNNeuronDescriptor Create (MPSCnnNeuronType neuronType, float a);
	public static MPSNNNeuronDescriptor Create (MPSCnnNeuronType neuronType, float a, float b);
	public static MPSNNNeuronDescriptor Create (MPSCnnNeuronType neuronType, float a, float b, float c);
}

New Type: MetalPerformanceShaders.MPSNNOptimizer

public class MPSNNOptimizer : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNOptimizer (Foundation.NSCoder coder);
	protected MPSNNOptimizer (Foundation.NSObjectFlag t);
	protected MPSNNOptimizer (IntPtr handle);
	// properties
	public virtual bool ApplyGradientClipping { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float GradientClipMax { get; }
	public virtual float GradientClipMin { get; }
	public virtual float GradientRescale { get; }
	public virtual float LearningRate { get; }
	public virtual float RegularizationScale { get; }
	public virtual MPSNNRegularizationType RegularizationType { get; }
	// methods
	public virtual void SetLearningRate (float newLearningRate);
}

New Type: MetalPerformanceShaders.MPSNNOptimizerAdam

public class MPSNNOptimizerAdam : MetalPerformanceShaders.MPSNNOptimizer, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNOptimizerAdam (Foundation.NSCoder coder);
	protected MPSNNOptimizerAdam (Foundation.NSObjectFlag t);
	protected MPSNNOptimizerAdam (IntPtr handle);
	public MPSNNOptimizerAdam (Metal.IMTLDevice device, float learningRate);
	public MPSNNOptimizerAdam (Metal.IMTLDevice device, double beta1, double beta2, float epsilon, uint timeStep, MPSNNOptimizerDescriptor optimizerDescriptor);
	// properties
	public virtual double Beta1 { get; }
	public virtual double Beta2 { get; }
	public override IntPtr ClassHandle { get; }
	public virtual float Epsilon { get; }
	public virtual uint TimeStep { get; set; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState, Foundation.NSArray<MPSVector> inputMomentumVectors, Foundation.NSArray<MPSVector> inputVelocityVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationGradientState, MPSCnnBatchNormalizationState batchNormalizationSourceState, Foundation.NSArray<MPSVector> inputMomentumVectors, Foundation.NSArray<MPSVector> inputVelocityVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionGradientState convolutionGradientState, MPSCnnConvolutionWeightsAndBiasesState convolutionSourceState, Foundation.NSArray<MPSVector> inputMomentumVectors, Foundation.NSArray<MPSVector> inputVelocityVectors, MPSCnnConvolutionWeightsAndBiasesState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSVector inputGradientVector, MPSVector inputValuesVector, MPSVector inputMomentumVector, MPSVector inputVelocityVector, MPSVector resultValuesVector);
}

New Type: MetalPerformanceShaders.MPSNNOptimizerDescriptor

public class MPSNNOptimizerDescriptor : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNOptimizerDescriptor (Foundation.NSObjectFlag t);
	protected MPSNNOptimizerDescriptor (IntPtr handle);
	public MPSNNOptimizerDescriptor (float learningRate, float gradientRescale, MPSNNRegularizationType regularizationType, float regularizationScale);
	public MPSNNOptimizerDescriptor (float learningRate, float gradientRescale, bool applyGradientClipping, float gradientClipMax, float gradientClipMin, MPSNNRegularizationType regularizationType, float regularizationScale);
	// properties
	public virtual bool ApplyGradientClipping { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual float GradientClipMax { get; set; }
	public virtual float GradientClipMin { get; set; }
	public virtual float GradientRescale { get; set; }
	public virtual float LearningRate { get; set; }
	public virtual float RegularizationScale { get; set; }
	public virtual MPSNNRegularizationType RegularizationType { get; set; }
	// methods
	public static MPSNNOptimizerDescriptor Create (float learningRate, float gradientRescale, MPSNNRegularizationType regularizationType, float regularizationScale);
	public static MPSNNOptimizerDescriptor Create (float learningRate, float gradientRescale, bool applyGradientClipping, float gradientClipMax, float gradientClipMin, MPSNNRegularizationType regularizationType, float regularizationScale);
}

New Type: MetalPerformanceShaders.MPSNNOptimizerRmsProp

public class MPSNNOptimizerRmsProp : MetalPerformanceShaders.MPSNNOptimizer, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNOptimizerRmsProp (Foundation.NSCoder coder);
	protected MPSNNOptimizerRmsProp (Foundation.NSObjectFlag t);
	protected MPSNNOptimizerRmsProp (IntPtr handle);
	public MPSNNOptimizerRmsProp (Metal.IMTLDevice device, float learningRate);
	public MPSNNOptimizerRmsProp (Metal.IMTLDevice device, double decay, float epsilon, MPSNNOptimizerDescriptor optimizerDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual double Decay { get; }
	public virtual float Epsilon { get; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState, Foundation.NSArray<MPSVector> inputSumOfSquaresVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationGradientState, MPSCnnBatchNormalizationState batchNormalizationSourceState, Foundation.NSArray<MPSVector> inputSumOfSquaresVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionGradientState convolutionGradientState, MPSCnnConvolutionWeightsAndBiasesState convolutionSourceState, Foundation.NSArray<MPSVector> inputSumOfSquaresVectors, MPSCnnConvolutionWeightsAndBiasesState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSVector inputGradientVector, MPSVector inputValuesVector, MPSVector inputSumOfSquaresVector, MPSVector resultValuesVector);
}

New Type: MetalPerformanceShaders.MPSNNOptimizerStochasticGradientDescent

public class MPSNNOptimizerStochasticGradientDescent : MetalPerformanceShaders.MPSNNOptimizer, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNOptimizerStochasticGradientDescent (Foundation.NSCoder coder);
	protected MPSNNOptimizerStochasticGradientDescent (Foundation.NSObjectFlag t);
	protected MPSNNOptimizerStochasticGradientDescent (IntPtr handle);
	public MPSNNOptimizerStochasticGradientDescent (Metal.IMTLDevice device, float learningRate);
	public MPSNNOptimizerStochasticGradientDescent (Metal.IMTLDevice device, float momentumScale, bool useNestrovMomentum, MPSNNOptimizerDescriptor optimizerDescriptor);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float MomentumScale { get; }
	public virtual bool UseNestrovMomentum { get; }
	// methods
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationState, Foundation.NSArray<MPSVector> inputMomentumVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnBatchNormalizationState batchNormalizationGradientState, MPSCnnBatchNormalizationState batchNormalizationSourceState, Foundation.NSArray<MPSVector> inputMomentumVectors, MPSCnnNormalizationGammaAndBetaState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSCnnConvolutionGradientState convolutionGradientState, MPSCnnConvolutionWeightsAndBiasesState convolutionSourceState, Foundation.NSArray<MPSVector> inputMomentumVectors, MPSCnnConvolutionWeightsAndBiasesState resultState);
	public virtual void Encode (Metal.IMTLCommandBuffer commandBuffer, MPSVector inputGradientVector, MPSVector inputValuesVector, MPSVector inputMomentumVector, MPSVector resultValuesVector);
}

New Type: MetalPerformanceShaders.MPSNNPad

public class MPSNNPad : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNPad (Foundation.NSCoder coder);
	protected MPSNNPad (Foundation.NSObjectFlag t);
	public MPSNNPad (Metal.IMTLDevice device);
	protected MPSNNPad (IntPtr handle);
	public MPSNNPad (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSNNPad (Metal.IMTLDevice device, MPSImageCoordinate paddingSizeBefore, MPSImageCoordinate paddingSizeAfter);
	public MPSNNPad (Metal.IMTLDevice device, MPSImageCoordinate paddingSizeBefore, MPSImageCoordinate paddingSizeAfter, Foundation.NSData fillValueArray);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float FillValue { get; set; }
	public virtual MPSImageCoordinate PaddingSizeAfter { get; set; }
	public virtual MPSImageCoordinate PaddingSizeBefore { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNPadGradient

public class MPSNNPadGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNPadGradient (Foundation.NSCoder coder);
	protected MPSNNPadGradient (Foundation.NSObjectFlag t);
	public MPSNNPadGradient (Metal.IMTLDevice device);
	protected MPSNNPadGradient (IntPtr handle);
	public MPSNNPadGradient (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNPadGradientNode

public class MPSNNPadGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNPadGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNPadGradientNode (IntPtr handle);
	public MPSNNPadGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNPadGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSNNPadNode

public class MPSNNPadNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNPadNode (Foundation.NSObjectFlag t);
	protected MPSNNPadNode (IntPtr handle);
	public MPSNNPadNode (MPSNNImageNode source, MPSImageCoordinate paddingSizeBefore, MPSImageCoordinate paddingSizeAfter, MPSImageEdgeMode edgeMode);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float FillValue { get; set; }
	// methods
	public static MPSNNPadNode Create (MPSNNImageNode source, MPSImageCoordinate paddingSizeBefore, MPSImageCoordinate paddingSizeAfter, MPSImageEdgeMode edgeMode);
}

New Type: MetalPerformanceShaders.MPSNNReduceBinary

public class MPSNNReduceBinary : MetalPerformanceShaders.MPSCnnBinaryKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceBinary (Foundation.NSCoder coder);
	protected MPSNNReduceBinary (Foundation.NSObjectFlag t);
	protected MPSNNReduceBinary (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLRegion PrimarySourceClipRect { get; set; }
	public virtual Metal.MTLRegion SecondarySourceClipRect { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNReduceColumnMax

public class MPSNNReduceColumnMax : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceColumnMax (Foundation.NSCoder coder);
	protected MPSNNReduceColumnMax (Foundation.NSObjectFlag t);
	public MPSNNReduceColumnMax (Metal.IMTLDevice device);
	protected MPSNNReduceColumnMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceColumnMean

public class MPSNNReduceColumnMean : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceColumnMean (Foundation.NSCoder coder);
	protected MPSNNReduceColumnMean (Foundation.NSObjectFlag t);
	public MPSNNReduceColumnMean (Metal.IMTLDevice device);
	protected MPSNNReduceColumnMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceColumnMin

public class MPSNNReduceColumnMin : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceColumnMin (Foundation.NSCoder coder);
	protected MPSNNReduceColumnMin (Foundation.NSObjectFlag t);
	public MPSNNReduceColumnMin (Metal.IMTLDevice device);
	protected MPSNNReduceColumnMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceColumnSum

public class MPSNNReduceColumnSum : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceColumnSum (Foundation.NSCoder coder);
	protected MPSNNReduceColumnSum (Foundation.NSObjectFlag t);
	public MPSNNReduceColumnSum (Metal.IMTLDevice device);
	protected MPSNNReduceColumnSum (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsAndWeightsMean

public class MPSNNReduceFeatureChannelsAndWeightsMean : MetalPerformanceShaders.MPSNNReduceBinary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsAndWeightsMean (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsAndWeightsMean (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsAndWeightsMean (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsAndWeightsMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsAndWeightsSum

public class MPSNNReduceFeatureChannelsAndWeightsSum : MetalPerformanceShaders.MPSNNReduceBinary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsAndWeightsSum (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsAndWeightsSum (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsAndWeightsSum (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsAndWeightsSum (IntPtr handle);
	public MPSNNReduceFeatureChannelsAndWeightsSum (Metal.IMTLDevice device, bool doWeightedSumByNonZeroWeights);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual bool DoWeightedSumByNonZeroWeights { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsArgumentMax

public class MPSNNReduceFeatureChannelsArgumentMax : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsArgumentMax (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsArgumentMax (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsArgumentMax (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsArgumentMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsArgumentMin

public class MPSNNReduceFeatureChannelsArgumentMin : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsArgumentMin (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsArgumentMin (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsArgumentMin (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsArgumentMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsMax

public class MPSNNReduceFeatureChannelsMax : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsMax (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsMax (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsMax (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsMean

public class MPSNNReduceFeatureChannelsMean : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsMean (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsMean (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsMean (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsMin

public class MPSNNReduceFeatureChannelsMin : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsMin (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsMin (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsMin (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceFeatureChannelsSum

public class MPSNNReduceFeatureChannelsSum : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceFeatureChannelsSum (Foundation.NSCoder coder);
	protected MPSNNReduceFeatureChannelsSum (Foundation.NSObjectFlag t);
	public MPSNNReduceFeatureChannelsSum (Metal.IMTLDevice device);
	protected MPSNNReduceFeatureChannelsSum (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Weight { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNReduceRowMax

public class MPSNNReduceRowMax : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceRowMax (Foundation.NSCoder coder);
	protected MPSNNReduceRowMax (Foundation.NSObjectFlag t);
	public MPSNNReduceRowMax (Metal.IMTLDevice device);
	protected MPSNNReduceRowMax (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceRowMean

public class MPSNNReduceRowMean : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceRowMean (Foundation.NSCoder coder);
	protected MPSNNReduceRowMean (Foundation.NSObjectFlag t);
	public MPSNNReduceRowMean (Metal.IMTLDevice device);
	protected MPSNNReduceRowMean (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceRowMin

public class MPSNNReduceRowMin : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceRowMin (Foundation.NSCoder coder);
	protected MPSNNReduceRowMin (Foundation.NSObjectFlag t);
	public MPSNNReduceRowMin (Metal.IMTLDevice device);
	protected MPSNNReduceRowMin (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceRowSum

public class MPSNNReduceRowSum : MetalPerformanceShaders.MPSNNReduceUnary, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceRowSum (Foundation.NSCoder coder);
	protected MPSNNReduceRowSum (Foundation.NSObjectFlag t);
	public MPSNNReduceRowSum (Metal.IMTLDevice device);
	protected MPSNNReduceRowSum (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReduceUnary

public class MPSNNReduceUnary : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReduceUnary (Foundation.NSCoder coder);
	protected MPSNNReduceUnary (Foundation.NSObjectFlag t);
	protected MPSNNReduceUnary (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLRegion ClipRectSource { get; set; }
}

New Type: MetalPerformanceShaders.MPSNNReductionColumnMaxNode

public class MPSNNReductionColumnMaxNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionColumnMaxNode (Foundation.NSObjectFlag t);
	public MPSNNReductionColumnMaxNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionColumnMaxNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionColumnMaxNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionColumnMeanNode

public class MPSNNReductionColumnMeanNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionColumnMeanNode (Foundation.NSObjectFlag t);
	public MPSNNReductionColumnMeanNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionColumnMeanNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionColumnMeanNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionColumnMinNode

public class MPSNNReductionColumnMinNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionColumnMinNode (Foundation.NSObjectFlag t);
	public MPSNNReductionColumnMinNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionColumnMinNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionColumnMinNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionColumnSumNode

public class MPSNNReductionColumnSumNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionColumnSumNode (Foundation.NSObjectFlag t);
	public MPSNNReductionColumnSumNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionColumnSumNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionColumnSumNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsArgumentMaxNode

public class MPSNNReductionFeatureChannelsArgumentMaxNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsArgumentMaxNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsArgumentMaxNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsArgumentMaxNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionFeatureChannelsArgumentMaxNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsArgumentMinNode

public class MPSNNReductionFeatureChannelsArgumentMinNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsArgumentMinNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsArgumentMinNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsArgumentMinNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionFeatureChannelsArgumentMinNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsMaxNode

public class MPSNNReductionFeatureChannelsMaxNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsMaxNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsMaxNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsMaxNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionFeatureChannelsMaxNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsMeanNode

public class MPSNNReductionFeatureChannelsMeanNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsMeanNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsMeanNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsMeanNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionFeatureChannelsMeanNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsMinNode

public class MPSNNReductionFeatureChannelsMinNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsMinNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsMinNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsMinNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionFeatureChannelsMinNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionFeatureChannelsSumNode

public class MPSNNReductionFeatureChannelsSumNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionFeatureChannelsSumNode (Foundation.NSObjectFlag t);
	public MPSNNReductionFeatureChannelsSumNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionFeatureChannelsSumNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual float Weight { get; set; }
	// methods
	public static MPSNNReductionFeatureChannelsSumNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionRowMaxNode

public class MPSNNReductionRowMaxNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionRowMaxNode (Foundation.NSObjectFlag t);
	public MPSNNReductionRowMaxNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionRowMaxNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionRowMaxNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionRowMeanNode

public class MPSNNReductionRowMeanNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionRowMeanNode (Foundation.NSObjectFlag t);
	public MPSNNReductionRowMeanNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionRowMeanNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionRowMeanNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionRowMinNode

public class MPSNNReductionRowMinNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionRowMinNode (Foundation.NSObjectFlag t);
	public MPSNNReductionRowMinNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionRowMinNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionRowMinNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionRowSumNode

public class MPSNNReductionRowSumNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionRowSumNode (Foundation.NSObjectFlag t);
	public MPSNNReductionRowSumNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionRowSumNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionRowSumNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNReductionSpatialMeanGradientNode

public class MPSNNReductionSpatialMeanGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionSpatialMeanGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNReductionSpatialMeanGradientNode (IntPtr handle);
	public MPSNNReductionSpatialMeanGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionSpatialMeanGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSNNReductionSpatialMeanNode

public class MPSNNReductionSpatialMeanNode : MetalPerformanceShaders.MPSNNUnaryReductionNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReductionSpatialMeanNode (Foundation.NSObjectFlag t);
	public MPSNNReductionSpatialMeanNode (MPSNNImageNode sourceNode);
	protected MPSNNReductionSpatialMeanNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReductionSpatialMeanNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSNNRegularizationType

[Serializable]
public enum MPSNNRegularizationType {
	L1 = 1,
	L2 = 2,
	None = 0,
}

New Type: MetalPerformanceShaders.MPSNNReshape

public class MPSNNReshape : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReshape (Foundation.NSCoder coder);
	protected MPSNNReshape (Foundation.NSObjectFlag t);
	public MPSNNReshape (Metal.IMTLDevice device);
	protected MPSNNReshape (IntPtr handle);
	public MPSNNReshape (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReshapeGradient

public class MPSNNReshapeGradient : MetalPerformanceShaders.MPSCnnGradientKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNReshapeGradient (Foundation.NSCoder coder);
	protected MPSNNReshapeGradient (Foundation.NSObjectFlag t);
	public MPSNNReshapeGradient (Metal.IMTLDevice device);
	protected MPSNNReshapeGradient (IntPtr handle);
	public MPSNNReshapeGradient (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNReshapeGradientNode

public class MPSNNReshapeGradientNode : MetalPerformanceShaders.MPSNNGradientFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReshapeGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNReshapeGradientNode (IntPtr handle);
	public MPSNNReshapeGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReshapeGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNGradientStateNode gradientState);
}

New Type: MetalPerformanceShaders.MPSNNReshapeNode

public class MPSNNReshapeNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNReshapeNode (Foundation.NSObjectFlag t);
	protected MPSNNReshapeNode (IntPtr handle);
	public MPSNNReshapeNode (MPSNNImageNode source, uint resultWidth, uint resultHeight, uint resultFeatureChannels);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNReshapeNode Create (MPSNNImageNode source, uint resultWidth, uint resultHeight, uint resultFeatureChannels);
}

New Type: MetalPerformanceShaders.MPSNNResizeBilinear

public class MPSNNResizeBilinear : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNResizeBilinear (Foundation.NSCoder coder);
	protected MPSNNResizeBilinear (Foundation.NSObjectFlag t);
	protected MPSNNResizeBilinear (IntPtr handle);
	public MPSNNResizeBilinear (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSNNResizeBilinear (Metal.IMTLDevice device, uint resizeWidth, uint resizeHeight, bool alignCorners);
	// properties
	public virtual bool AlignCorners { get; }
	public override IntPtr ClassHandle { get; }
	public virtual uint ResizeHeight { get; }
	public virtual uint ResizeWidth { get; }
}

New Type: MetalPerformanceShaders.MPSNNSlice

public class MPSNNSlice : MetalPerformanceShaders.MPSCnnKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSNNSlice (Foundation.NSCoder coder);
	protected MPSNNSlice (Foundation.NSObjectFlag t);
	public MPSNNSlice (Metal.IMTLDevice device);
	protected MPSNNSlice (IntPtr handle);
	public MPSNNSlice (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: MetalPerformanceShaders.MPSNNSubtractionGradientNode

public class MPSNNSubtractionGradientNode : MetalPerformanceShaders.MPSNNArithmeticGradientNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNSubtractionGradientNode (Foundation.NSObjectFlag t);
	protected MPSNNSubtractionGradientNode (IntPtr handle);
	public MPSNNSubtractionGradientNode (MPSNNImageNode[] gradientImages, MPSNNFilterNode filter, bool isSecondarySourceFilter);
	public MPSNNSubtractionGradientNode (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSNNSubtractionGradientNode Create (MPSNNImageNode sourceGradient, MPSNNImageNode sourceImage, MPSNNBinaryGradientStateNode gradientState, bool isSecondarySourceFilter);
}

New Type: MetalPerformanceShaders.MPSNNTrainingStyle

[Serializable]
[Flags]
public enum MPSNNTrainingStyle {
	Cpu = 1,
	Gpu = 2,
	None = 0,
}

New Type: MetalPerformanceShaders.MPSNNUnaryReductionNode

public class MPSNNUnaryReductionNode : MetalPerformanceShaders.MPSNNFilterNode, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSNNUnaryReductionNode (Foundation.NSObjectFlag t);
	public MPSNNUnaryReductionNode (MPSNNImageNode sourceNode);
	protected MPSNNUnaryReductionNode (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLRegion ClipRectSource { get; set; }
	// methods
	public static MPSNNUnaryReductionNode Create (MPSNNImageNode sourceNode);
}

New Type: MetalPerformanceShaders.MPSRayDataType

[Serializable]
public enum MPSRayDataType {
	OriginDirection = 0,
	OriginMaskDirectionMaxDistance = 2,
	OriginMinDistanceDirectionMaxDistance = 1,
}

New Type: MetalPerformanceShaders.MPSRayIntersector

public class MPSRayIntersector : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSRayIntersector (Foundation.NSCoder coder);
	protected MPSRayIntersector (Foundation.NSObjectFlag t);
	public MPSRayIntersector (Metal.IMTLDevice device);
	protected MPSRayIntersector (IntPtr handle);
	public MPSRayIntersector (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	// properties
	public virtual MPSBoundingBoxIntersectionTestType BoundingBoxIntersectionTestType { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual Metal.MTLCullMode CullMode { get; set; }
	public virtual Metal.MTLWinding FrontFacingWinding { get; set; }
	public virtual MPSIntersectionDataType IntersectionDataType { get; set; }
	public virtual uint IntersectionStride { get; set; }
	public virtual MPSRayDataType RayDataType { get; set; }
	public virtual MPSRayMaskOptions RayMaskOptions { get; set; }
	public virtual uint RayStride { get; set; }
	public virtual MPSTriangleIntersectionTestType TriangleIntersectionTestType { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual MPSRayIntersector Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void Encode (Foundation.NSCoder coder);
	public virtual void EncodeIntersection (Metal.IMTLCommandBuffer commandBuffer, MPSIntersectionType intersectionType, Metal.IMTLBuffer rayBuffer, uint rayBufferOffset, Metal.IMTLBuffer intersectionBuffer, uint intersectionBufferOffset, uint rayCount, MPSAccelerationStructure accelerationStructure);
	public virtual void EncodeIntersection (Metal.IMTLCommandBuffer commandBuffer, MPSIntersectionType intersectionType, Metal.IMTLBuffer rayBuffer, uint rayBufferOffset, Metal.IMTLBuffer intersectionBuffer, uint intersectionBufferOffset, Metal.IMTLBuffer rayCountBuffer, uint rayCountBufferOffset, MPSAccelerationStructure accelerationStructure);
	public virtual uint GetRecommendedMinimumRayBatchSize (uint rayCount);
}

New Type: MetalPerformanceShaders.MPSRayMaskOptions

[Serializable]
[Flags]
public enum MPSRayMaskOptions {
	Instance = 2,
	None = 0,
	Primitive = 1,
}

New Type: MetalPerformanceShaders.MPSRnnMatrixId

[Serializable]
public enum MPSRnnMatrixId {
	GruInputGateBiasTerms = 21,
	GruInputGateInputWeights = 19,
	GruInputGateRecurrentWeights = 20,
	GruOutputGateBiasTerms = 28,
	GruOutputGateInputGateWeights = 27,
	GruOutputGateInputWeights = 25,
	GruOutputGateRecurrentWeights = 26,
	GruRecurrentGateBiasTerms = 24,
	GruRecurrentGateInputWeights = 22,
	GruRecurrentGateRecurrentWeights = 23,
	LstmForgetGateBiasTerms = 10,
	LstmForgetGateInputWeights = 7,
	LstmForgetGateMemoryWeights = 9,
	LstmForgetGateRecurrentWeights = 8,
	LstmInputGateBiasTerms = 6,
	LstmInputGateInputWeights = 3,
	LstmInputGateMemoryWeights = 5,
	LstmInputGateRecurrentWeights = 4,
	LstmMemoryGateBiasTerms = 14,
	LstmMemoryGateInputWeights = 11,
	LstmMemoryGateMemoryWeights = 13,
	LstmMemoryGateRecurrentWeights = 12,
	LstmOutputGateBiasTerms = 18,
	LstmOutputGateInputWeights = 15,
	LstmOutputGateMemoryWeights = 17,
	LstmOutputGateRecurrentWeights = 16,
	SingleGateBiasTerms = 2,
	SingleGateInputWeights = 0,
	SingleGateRecurrentWeights = 1,
}

New Type: MetalPerformanceShaders.MPSRnnMatrixTrainingLayer

public class MPSRnnMatrixTrainingLayer : MetalPerformanceShaders.MPSKernel, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSRnnMatrixTrainingLayer (Foundation.NSCoder coder);
	protected MPSRnnMatrixTrainingLayer (Foundation.NSObjectFlag t);
	protected MPSRnnMatrixTrainingLayer (IntPtr handle);
	public MPSRnnMatrixTrainingLayer (Foundation.NSCoder decoder, Metal.IMTLDevice device);
	public MPSRnnMatrixTrainingLayer (Metal.IMTLDevice device, MPSRnnDescriptor rnnDescriptor, Foundation.NSMutableArray<MPSMatrix> trainableWeights);
	// properties
	public virtual bool AccumulateWeightGradients { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual uint InputFeatureChannels { get; }
	public virtual uint OutputFeatureChannels { get; }
	public virtual bool RecurrentOutputIsTemporary { get; set; }
	public virtual bool StoreAllIntermediateStates { get; set; }
	public virtual bool TrainingStateIsTemporary { get; set; }
	// methods
	public virtual MPSRnnMatrixTrainingLayer Copy (Foundation.NSZone zone, Metal.IMTLDevice device);
	public virtual void CreateTemporaryWeightGradientMatrices (Foundation.NSMutableArray<MPSMatrix> matrices, MPSDataType dataType, Metal.IMTLCommandBuffer commandBuffer);
	public virtual void CreateWeightGradientMatrices (Foundation.NSMutableArray<MPSMatrix> matrices, MPSDataType dataType);
	public virtual void CreateWeightMatrices (Foundation.NSMutableArray<MPSMatrix> matrices);
	public virtual void EncodeCopyWeights (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] weights, MPSRnnMatrixId matrixId, MPSMatrix matrix, bool copyFromWeightsToMatrix, Metal.MTLOrigin matrixOffset);
	public virtual void EncodeForwardSequence (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] sourceMatrices, MPSMatrix[] destinationMatrices, Foundation.NSMutableArray<MPSRnnMatrixTrainingState> trainingStates, MPSMatrix[] weights);
	public virtual void EncodeForwardSequence (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] sourceMatrices, IntPtr sourceOffsets, MPSMatrix[] destinationMatrices, IntPtr destinationOffsets, Foundation.NSMutableArray<MPSRnnMatrixTrainingState> trainingStates, MPSRnnRecurrentMatrixState recurrentInputState, Foundation.NSMutableArray<MPSRnnRecurrentMatrixState> recurrentOutputStates, MPSMatrix[] weights);
	public virtual void EncodeGradientSequence (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] forwardSources, MPSMatrix[] sourceGradients, MPSMatrix[] destinationGradients, MPSMatrix[] weightGradients, MPSRnnMatrixTrainingState[] trainingStates, MPSMatrix[] weights);
	public virtual void EncodeGradientSequence (Metal.IMTLCommandBuffer commandBuffer, MPSMatrix[] forwardSources, IntPtr forwardSourceOffsets, MPSMatrix[] sourceGradients, IntPtr sourceGradientOffsets, MPSMatrix[] destinationGradients, IntPtr destinationOffsets, MPSMatrix[] weightGradients, MPSRnnMatrixTrainingState[] trainingStates, MPSRnnRecurrentMatrixState recurrentInputState, Foundation.NSMutableArray<MPSRnnRecurrentMatrixState> recurrentOutputStates, MPSMatrix[] weights);
}

New Type: MetalPerformanceShaders.MPSRnnMatrixTrainingState

public class MPSRnnMatrixTrainingState : MetalPerformanceShaders.MPSState, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected MPSRnnMatrixTrainingState (Foundation.NSObjectFlag t);
	public MPSRnnMatrixTrainingState (Metal.IMTLResource resource);
	public MPSRnnMatrixTrainingState (Metal.IMTLResource[] resources);
	protected MPSRnnMatrixTrainingState (IntPtr handle);
	public MPSRnnMatrixTrainingState (Metal.IMTLDevice device, Metal.MTLTextureDescriptor descriptor);
	public MPSRnnMatrixTrainingState (Metal.IMTLDevice device, MPSStateResourceList resourceList);
	public MPSRnnMatrixTrainingState (Metal.IMTLDevice device, uint bufferSize);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static MPSRnnMatrixTrainingState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer);
	public static MPSRnnMatrixTrainingState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, Metal.MTLTextureDescriptor descriptor);
	public static MPSRnnMatrixTrainingState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, MPSStateResourceList resourceList);
	public static MPSRnnMatrixTrainingState CreateTemporaryState (Metal.IMTLCommandBuffer commandBuffer, uint bufferSize);
}

New Type: MetalPerformanceShaders.MPSStateBatch

public static class MPSStateBatch {
	// methods
	public static uint GetResourceSize (Foundation.NSArray<MPSState> stateBatch);
	public static uint IncrementReadCount (Foundation.NSArray<MPSState> stateBatch, nint amount);
	public static void Synchronize (Foundation.NSArray<MPSState> stateBatch, Metal.IMTLCommandBuffer commandBuffer);
}

New Type: MetalPerformanceShaders.MPSStateResourceList

public class MPSStateResourceList : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSStateResourceList ();
	protected MPSStateResourceList (Foundation.NSObjectFlag t);
	protected MPSStateResourceList (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void Append (Metal.MTLTextureDescriptor descriptor);
	public virtual void Append (uint bufferSize);
	public static MPSStateResourceList Create ();
	public static MPSStateResourceList Create (Metal.MTLTextureDescriptor[] descriptors);
	public static MPSStateResourceList Create (uint[] bufferSizes);
}

New Type: MetalPerformanceShaders.MPSStateResourceType

[Serializable]
public enum MPSStateResourceType {
	Buffer = 1,
	None = 0,
	Texture = 2,
}

New Type: MetalPerformanceShaders.MPSStateTextureInfo

public struct MPSStateTextureInfo {
	// fields
	public uint ArrayLength;
	public uint Depth;
	public uint Height;
	public uint Width;
	// properties
	public Metal.MTLPixelFormat PixelFormat { get; set; }
	public Metal.MTLTextureType TextureType { get; set; }
	public Metal.MTLTextureUsage TextureUsage { get; set; }
}

New Type: MetalPerformanceShaders.MPSTransformType

[Serializable]
public enum MPSTransformType {
	Float4x4 = 0,
	Identity = 1,
}

New Type: MetalPerformanceShaders.MPSTriangleAccelerationStructure

public class MPSTriangleAccelerationStructure : MetalPerformanceShaders.MPSAccelerationStructure, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public MPSTriangleAccelerationStructure (Foundation.NSCoder coder);
	protected MPSTriangleAccelerationStructure (Foundation.NSObjectFlag t);
	public MPSTriangleAccelerationStructure (Metal.IMTLDevice device);
	public MPSTriangleAccelerationStructure (MPSAccelerationStructureGroup group);
	protected MPSTriangleAccelerationStructure (IntPtr handle);
	public MPSTriangleAccelerationStructure (Foundation.NSCoder aDecoder, Metal.IMTLDevice device);
	public MPSTriangleAccelerationStructure (Foundation.NSCoder aDecoder, MPSAccelerationStructureGroup group);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Metal.IMTLBuffer IndexBuffer { get; set; }
	public virtual uint IndexBufferOffset { get; set; }
	public virtual MPSDataType IndexType { get; set; }
	public virtual Metal.IMTLBuffer MaskBuffer { get; set; }
	public virtual uint MaskBufferOffset { get; set; }
	public virtual uint TriangleCount { get; set; }
	public virtual Metal.IMTLBuffer VertexBuffer { get; set; }
	public virtual uint VertexBufferOffset { get; set; }
	public virtual uint VertexStride { get; set; }
}

New Type: MetalPerformanceShaders.MPSTriangleIntersectionTestType

[Serializable]
public enum MPSTriangleIntersectionTestType {
	Default = 0,
	Watertight = 1,
}

Namespace ObjCRuntime

Type Changed: ObjCRuntime.Constants

Modified fields:

-public const string SdkVersion = "12.1";
+public const string SdkVersion = "12.2";
-public const string Version = "12.2.1";
+public const string Version = "12.4.0";

Namespace Security

Type Changed: Security.SecTrust

Added methods:

public SecStatusCode SetSignedCertificateTimestamps (Foundation.NSArray<Foundation.NSData> sct);
public SecStatusCode SetSignedCertificateTimestamps (System.Collections.Generic.IEnumerable<Foundation.NSData> sct);

Namespace SpriteKit

Type Changed: SpriteKit.SKBlendMode

Added value:

MultiplyAlpha = 7,

Namespace StoreKit

Type Changed: StoreKit.SKError

Obsoleted fields:

 [Obsolete ("Use 'SKError.CloudServiceRevoked' instead.")]
 Revoked = 8,

Added values:

CloudServiceRevoked = 8,
InvalidOfferIdentifier = 11,
InvalidOfferPrice = 14,
InvalidSignature = 12,
MissingOfferParams = 13,
PrivacyAcknowledgementRequired = 9,
UnauthorizedRequestData = 10,

Type Changed: StoreKit.SKMutablePayment

Added property:

public virtual SKPaymentDiscount PaymentDiscount { get; set; }

Type Changed: StoreKit.SKPayment

Added property:

public virtual SKPaymentDiscount PaymentDiscount { get; set; }

Type Changed: StoreKit.SKProduct

Added property:

public virtual SKProductDiscount[] Discounts { get; }

Type Changed: StoreKit.SKProductDiscount

Added properties:

public virtual string Identifier { get; }
public virtual SKProductDiscountType Type { get; }

New Type: StoreKit.SKPaymentDiscount

public class SKPaymentDiscount : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected SKPaymentDiscount (Foundation.NSObjectFlag t);
	protected SKPaymentDiscount (IntPtr handle);
	public SKPaymentDiscount (string identifier, string keyIdentifier, Foundation.NSUuid nonce, string signature, Foundation.NSNumber timestamp);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Identifier { get; }
	public virtual string KeyIdentifier { get; }
	public virtual Foundation.NSUuid Nonce { get; }
	public virtual string Signature { get; }
	public virtual Foundation.NSNumber Timestamp { get; }
}

New Type: StoreKit.SKProductDiscountType

[Serializable]
public enum SKProductDiscountType {
	Introductory = 0,
	Subscription = 1,
}

Namespace UIKit

Type Changed: UIKit.NSLayoutManager

Obsoleted methods:

 [Obsolete ("Use 'GetCharacterIndex' instead.")]
 public virtual uint CharacterIndexForPoint (CoreGraphics.CGPoint point, NSTextContainer container, ref nfloat partialFraction);
 [Obsolete ("Use 'GetCharacterRange' instead.")]
 public Foundation.NSRange CharacterRangeForGlyphRange (Foundation.NSRange charRange);
 [Obsolete ("Use 'GetGlyphRange' instead.")]
 public Foundation.NSRange GlyphRangeForCharacterRange (Foundation.NSRange charRange);
 [Obsolete ("Use 'GetGlyphRange' instead.")]
 public Foundation.NSRange GlyphRangeForCharacterRange (Foundation.NSRange charRange, ref Foundation.NSRange actualCharRange);
 [Obsolete ("Use 'GetLineFragmentRect' instead.")]
 public CoreGraphics.CGRect LineFragmentRectForGlyphAtIndex (uint glyphIndex);
 [Obsolete ("Use 'GetLineFragmentRect' instead.")]
 public CoreGraphics.CGRect LineFragmentRectForGlyphAtIndex (uint glyphIndex, ref Foundation.NSRange effectiveGlyphRange);
 [Obsolete ("Use 'GetLineFragmentUsedRect' instead.")]
 public CoreGraphics.CGRect LineFragmentUsedRectForGlyphAtIndex (uint glyphIndex);
 [Obsolete ("Use 'GetLineFragmentUsedRect' instead.")]
 public CoreGraphics.CGRect LineFragmentUsedRectForGlyphAtIndex (uint glyphIndex, ref Foundation.NSRange effectiveGlyphRange);
 [Obsolete ("Use 'GetProperty' instead.")]
 public virtual NSGlyphProperty PropertyForGlyphAtIndex (uint glyphIndex);
 [Obsolete ("Use 'GetTextContainer' instead.")]
 public NSTextContainer TextContainerForGlyphAtIndex (uint glyphIndex);
 [Obsolete ("Use 'GetTextContainer' instead.")]
 public NSTextContainer TextContainerForGlyphAtIndex (uint glyphIndex, ref Foundation.NSRange effectiveGlyphRange);
 [Obsolete ("Use 'GetTruncatedGlyphRangeInLineFragment' instead.")]
 public virtual Foundation.NSRange TruncatedGlyphRangeInLineFragmentForGlyphAtIndex (uint glyphIndex);

Added methods:

public void AddTemporaryAttribute (Foundation.NSString attributeName, Foundation.NSObject value, Foundation.NSRange characterRange);
public virtual void AddTemporaryAttribute (string attributeName, Foundation.NSObject value, Foundation.NSRange characterRange);
public virtual void AddTemporaryAttributes (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> attributes, Foundation.NSRange characterRange);
protected virtual void FillBackground (IntPtr rectArray, uint rectCount, Foundation.NSRange characterRange, UIColor color);
public uint GetCharacterIndex (CoreGraphics.CGPoint point, NSTextContainer container);
public uint GetCharacterIndex (CoreGraphics.CGPoint point, NSTextContainer container, out nfloat fractionOfDistanceBetweenInsertionPoints);
public Foundation.NSRange GetCharacterRange (Foundation.NSRange glyphRange);
protected virtual Foundation.NSRange GetCharacterRange (Foundation.NSRange glyphRange, IntPtr actualGlyphRange);
public Foundation.NSRange GetCharacterRange (Foundation.NSRange glyphRange, out Foundation.NSRange actualGlyphRange);
public virtual nfloat GetDefaultBaselineOffset (UIFont font);
public virtual nfloat GetDefaultLineHeight (UIFont font);
public Foundation.NSRange GetGlyphRange (Foundation.NSRange characterRange);
protected virtual Foundation.NSRange GetGlyphRange (Foundation.NSRange characterRange, IntPtr actualCharacterRange);
public Foundation.NSRange GetGlyphRange (Foundation.NSRange characterRange, out Foundation.NSRange actualCharacterRange);
protected virtual uint GetGlyphs (Foundation.NSRange glyphRange, IntPtr glyphBuffer, IntPtr properties, IntPtr characterIndexBuffer, IntPtr bidiLevelBuffer);
protected virtual uint GetLineFragmentInsertionPoints (uint characterIndex, bool alternatePositions, bool inDisplayOrder, IntPtr positions, IntPtr characterIndexes);
public CoreGraphics.CGRect GetLineFragmentRect (uint glyphIndex);
public CoreGraphics.CGRect GetLineFragmentRect (uint glyphIndex, bool withoutAdditionalLayout);
protected virtual CoreGraphics.CGRect GetLineFragmentRect (uint glyphIndex, IntPtr effectiveGlyphRange);
public CoreGraphics.CGRect GetLineFragmentRect (uint glyphIndex, out Foundation.NSRange effectiveGlyphRange);
public CoreGraphics.CGRect GetLineFragmentUsedRect (uint glyphIndex);
public CoreGraphics.CGRect GetLineFragmentUsedRect (uint glyphIndex, bool withoutAdditionalLayout);
protected virtual CoreGraphics.CGRect GetLineFragmentUsedRect (uint glyphIndex, IntPtr effectiveGlyphRange);
public CoreGraphics.CGRect GetLineFragmentUsedRect (uint glyphIndex, out Foundation.NSRange effectiveGlyphRange);
public NSGlyphProperty GetProperty (uint glyphIndex);
public Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex);
public Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex, Foundation.NSRange rangeLimit);
protected virtual Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex, IntPtr effectiveRange);
public Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex, out Foundation.NSRange effectiveRange);
protected virtual Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex, IntPtr longestEffectiveRange, Foundation.NSRange rangeLimit);
public Foundation.NSObject GetTemporaryAttribute (Foundation.NSString attributeName, uint characterIndex, out Foundation.NSRange longestEffectiveRange, Foundation.NSRange rangeLimit);
public Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex);
public Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex, Foundation.NSRange rangeLimit);
protected virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex, IntPtr effectiveCharacterRange);
public Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex, out Foundation.NSRange effectiveCharacterRange);
protected virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex, IntPtr longestEffectiveRange, Foundation.NSRange rangeLimit);
public Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetTemporaryAttributes (uint characterIndex, out Foundation.NSRange longestEffectiveRange, Foundation.NSRange rangeLimit);
public NSTextContainer GetTextContainer (uint glyphIndex);
public NSTextContainer GetTextContainer (uint glyphIndex, bool flag);
public virtual NSTextContainer GetTextContainer (uint glyphIndex, out Foundation.NSRange effectiveGlyphRange);
public Foundation.NSRange GetTruncatedGlyphRangeInLineFragment (uint glyphIndex);
public void InvalidateGlyphs (Foundation.NSRange characterRange, nint delta);
public void InvalidateLayout (Foundation.NSRange characterRange);
public virtual void RemoveTemporaryAttribute (Foundation.NSString attributeName, Foundation.NSRange characterRange);
public void RemoveTemporaryAttribute (string attributeName, Foundation.NSRange characterRange);
public virtual void ReplaceTextStorage (NSTextStorage newTextStorage);
public virtual void SetTemporaryAttributes (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> attributes, Foundation.NSRange characterReange);
protected virtual void ShowGlyphs (IntPtr glyphs, IntPtr positions, uint glyphCount, UIFont font, CoreGraphics.CGAffineTransform textMatrix, Foundation.NSDictionary attributes, CoreGraphics.CGContext graphicsContext);
public virtual void TextContainerChangedTextView (NSTextContainer container);