# API diff: Microsoft.iOS.dll

## Microsoft.iOS.dll

### Namespace AVFoundation

#### Type Changed: AVFoundation.AVAssetDownloadDelegate

Added methods:

```csharp
public virtual void DidReceiveInformationalResponse (Foundation.NSUrlSession session, Foundation.NSUrlSessionTask task, Foundation.NSHttpUrlResponse response);
public virtual void NeedNewBodyStream (Foundation.NSUrlSession session, Foundation.NSUrlSessionTask task, long offset, System.Action<Foundation.NSInputStream> completionHandler);
```


#### Type Changed: AVFoundation.AVAudioSourceNode

Obsoleted constructors:

```diff
 [Obsolete ("Use the overload that takes a delegate that does not take a 'ref AudioBuffers' instead. Assigning a value to the 'inputData' parameter in the callback has no effect.")]
 public AVAudioSourceNode (AVAudioSourceNodeRenderHandler renderHandler);
 [Obsolete ("Use the overload that takes a delegate that does not take a 'ref AudioBuffers' instead. Assigning a value to the 'inputData' parameter in the callback has no effect.")]
 public AVAudioSourceNode (AVAudioFormat format, AVAudioSourceNodeRenderHandler renderHandler);
```

Added constructors:

```csharp
public AVAudioSourceNode (AVAudioSourceNodeRenderHandler3 renderHandler);
public AVAudioSourceNode (AVAudioSourceNodeRenderHandlerRaw renderHandler);
public AVAudioSourceNode (AVAudioFormat format, AVAudioSourceNodeRenderHandler3 renderHandler);
public AVAudioSourceNode (AVAudioFormat format, AVAudioSourceNodeRenderHandlerRaw renderHandler);
```


#### Type Changed: AVFoundation.AVSpeechSynthesizer

Obsoleted methods:

```diff
 [Obsolete ("Do not use this API, it doesn't work correctly. Use the non-Async version (WriteUtterance) instead.")]
 public virtual System.Threading.Tasks.Task<AVAudioBuffer> WriteUtteranceAsync (AVSpeechUtterance utterance);
```


#### New Type: AVFoundation.AVAudioSourceNodeRenderHandler3

```csharp
public sealed delegate AVAudioSourceNodeRenderHandler3 : System.MulticastDelegate {
	// constructors
	public AVAudioSourceNodeRenderHandler3 (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (ref bool isSilence, ref AudioToolbox.AudioTimeStamp timestamp, uint frameCount, AudioToolbox.AudioBuffers outputData, System.AsyncCallback callback, object object);
	public virtual int EndInvoke (ref bool isSilence, ref AudioToolbox.AudioTimeStamp timestamp, System.IAsyncResult result);
	public virtual int Invoke (ref bool isSilence, ref AudioToolbox.AudioTimeStamp timestamp, uint frameCount, AudioToolbox.AudioBuffers outputData);
}
```

#### New Type: AVFoundation.AVAudioSourceNodeRenderHandlerRaw

```csharp
public sealed delegate AVAudioSourceNodeRenderHandlerRaw : System.MulticastDelegate {
	// constructors
	public AVAudioSourceNodeRenderHandlerRaw (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (IntPtr isSilence, IntPtr timestamp, uint frameCount, IntPtr outputData, System.AsyncCallback callback, object object);
	public virtual int EndInvoke (System.IAsyncResult result);
	public virtual int Invoke (IntPtr isSilence, IntPtr timestamp, uint frameCount, IntPtr outputData);
}
```

#### New Type: AVFoundation.AVSampleCursor

```csharp
public class AVSampleCursor : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected AVSampleCursor (Foundation.NSObjectFlag t);
	protected AVSampleCursor (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVSampleCursorChunkInfo CurrentChunkInfo { get; }
	public virtual AVSampleCursorStorageRange CurrentChunkStorageRange { get; }
	public virtual Foundation.NSUrl CurrentChunkStorageUrl { get; }
	public virtual AVSampleCursorAudioDependencyInfo CurrentSampleAudioDependencyInfo { get; }
	public virtual Foundation.NSDictionary CurrentSampleDependencyAttachments { get; }
	public AVSampleCursorDependencyInfo CurrentSampleDependencyInfo2 { get; }
	public virtual CoreMedia.CMTime CurrentSampleDuration { get; }
	public virtual long CurrentSampleIndexInChunk { get; }
	public virtual AVSampleCursorStorageRange CurrentSampleStorageRange { get; }
	public virtual AVSampleCursorSyncInfo CurrentSampleSyncInfo { get; }
	public virtual CoreMedia.CMTime DecodeTimeStamp { get; }
	public virtual CoreMedia.CMTime PresentationTimeStamp { get; }
	public virtual IntPtr SamplesRequiredForDecoderRefresh { get; }
	// methods
	public virtual Foundation.NSComparisonResult ComparePositionInDecodeOrder (AVSampleCursor positionOfCursor);
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual CoreMedia.CMFormatDescription CopyCurrentSampleFormatDescription ();
	public virtual bool SamplesWithEarlierDecodeTimeStampsMayHaveLaterPresentationTimeStampsThan (AVSampleCursor positionOfCursor);
	public virtual bool SamplesWithLaterDecodeTimeStampsMayHaveEarlierPresentationTimeStampsThan (AVSampleCursor positionOfCursor);
	public virtual CoreMedia.CMTime StepByDecodeTime (CoreMedia.CMTime deltaDecodeTime, out bool wasPinned);
	public virtual CoreMedia.CMTime StepByPresentationTime (CoreMedia.CMTime deltaPresentationTime, out bool wasPinned);
	public virtual long StepInDecodeOrder (long stepCount);
	public virtual long StepInPresentationOrder (long stepCount);
}
```

#### New Type: AVFoundation.AVSampleCursorAudioDependencyInfo

```csharp
public struct AVSampleCursorAudioDependencyInfo {
	// fields
	public IntPtr PacketRefreshCount;
	// properties
	public bool IsIndependentlyDecodable { get; set; }
}
```

#### New Type: AVFoundation.AVSampleCursorChunkInfo

```csharp
public struct AVSampleCursorChunkInfo {
	// fields
	public bool HasUniformFormatDescriptions;
	public bool HasUniformSampleDurations;
	public bool HasUniformSampleSizes;
	public long SampleCount;
}
```

#### New Type: AVFoundation.AVSampleCursorDependencyInfo

```csharp
public struct AVSampleCursorDependencyInfo {
	// fields
	public bool DependsOnOthers;
	public bool HasDependentSamples;
	public bool HasRedundantCoding;
	public bool IndicatesWhetherItDependsOnOthers;
	public bool IndicatesWhetherItHasDependentSamples;
	public bool IndicatesWhetherItHasRedundantCoding;
}
```

#### New Type: AVFoundation.AVSampleCursorStorageRange

```csharp
public struct AVSampleCursorStorageRange {
	// fields
	public long Length;
	public long Offset;
}
```

#### New Type: AVFoundation.AVSampleCursorSyncInfo

```csharp
public struct AVSampleCursorSyncInfo {
	// fields
	public bool IsDroppable;
	public bool IsFullSync;
	public bool IsPartialSync;
}
```


### Namespace AVKit

#### New Type: AVKit.AVCaptureEvent

```csharp
public class AVCaptureEvent : Foundation.NSObject {
	// constructors
	protected AVCaptureEvent (Foundation.NSObjectFlag t);
	protected AVCaptureEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureEventPhase Phase { get; }
}
```

#### New Type: AVKit.AVCaptureEventInteraction

```csharp
public class AVCaptureEventInteraction : Foundation.NSObject, ObjCRuntime.INativeObject, System.IDisposable, UIKit.IUIInteraction {
	// constructors
	protected AVCaptureEventInteraction (Foundation.NSObjectFlag t);
	protected AVCaptureEventInteraction (ObjCRuntime.NativeHandle handle);
	public AVCaptureEventInteraction (System.Action<AVCaptureEvent> handler);
	public AVCaptureEventInteraction (System.Action<AVCaptureEvent> primaryHandler, System.Action<AVCaptureEvent> secondaryHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool Enabled { get; set; }
	public virtual UIKit.UIView View { get; }
	// methods
	public virtual void DidMoveToView (UIKit.UIView view);
	protected override void Dispose (bool disposing);
	public virtual void WillMoveToView (UIKit.UIView view);
}
```

#### New Type: AVKit.AVCaptureEventPhase

```csharp
[Serializable]
public enum AVCaptureEventPhase {
	Began = 0,
	Cancelled = 2,
	Ended = 1,
}
```


### Namespace Accessibility

#### Type Changed: Accessibility.AXHearingUtilities

Added method:

```csharp
public static byte AXSupportsBidirectionalAXMFiHearingDeviceStreaming ();
```



### Namespace AudioToolbox

#### Type Changed: AudioToolbox.MusicPlayer

Modified methods:

```diff
-protected virtual void Dispose (bool disposing)
+protected override void Dispose (bool disposing)
```

Added methods:

```csharp
public MusicPlayerStatus GetTime (out double time);
public MusicPlayerStatus SetTime (double time);
```



### Namespace AudioUnit

#### Type Changed: AudioUnit.AudioComponentDescription

Modified fields:

```diff
 ---[MarshalAs]---
 public AudioComponentManufacturerType ComponentManufacturer;
 ---[MarshalAs]---
 public AudioUnitSubType ComponentSubType;
 ---[MarshalAs]---
 public AudioComponentType ComponentType;
```



### Namespace Compression

#### Type Changed: Compression.CompressionAlgorithm

Added values:

```csharp
Brotli = 2818,
LZBitmap = 1794,
```



### Namespace CoreImage

#### Type Changed: CoreImage.ICIFilterProtocol

Added method:

```csharp
public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetCustomAttributes<T> ();
```



### Namespace CoreML

#### Type Changed: CoreML.IMLCustomModel

Added method:

```csharp
public static T CreateInstance<T> (MLModelDescription modelDescription, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> parameters, out Foundation.NSError error);
```



### Namespace CoreMidi

#### Type Changed: CoreMidi.MidiPacket

Obsoleted properties:

```diff
 [Obsolete ("This property may return a pointer to a managed object, and this pointer is never safe to use. Use ByteArray or BytePointer instead.")]
 public IntPtr Bytes { get; }
```

Added properties:

```csharp
public byte[] ByteArray { get; }
public IntPtr BytePointer { get; }
```



### Namespace CoreText

#### Type Changed: CoreText.CTFontDescriptor

Obsoleted methods:

```diff
 [Obsolete ("Use 'MatchFontDescriptors (CTFontDescriptor[], NSSet, CTFontDescriptorProgressHandler)' instead.")]
 public static bool MatchFontDescriptors (CTFontDescriptor[] descriptors, Foundation.NSSet mandatoryAttributes, System.Func<CTFontDescriptorMatchingState,System.IntPtr,System.Boolean> progressHandler);
```

Added method:

```csharp
public static bool MatchFontDescriptors (CTFontDescriptor[] descriptors, Foundation.NSSet mandatoryAttributes, CTFontDescriptor.CTFontDescriptorProgressHandler progressHandler);
```


#### Type Changed: CoreText.CTFontDescriptorAttributes

Added property:

```csharp
public bool? WeakEnabled { get; set; }
```


#### New Type: CoreText.CTFontDescriptorMatchingProgress

```csharp
public class CTFontDescriptorMatchingProgress : Foundation.DictionaryContainer {
	// constructors
	public CTFontDescriptorMatchingProgress ();
	public CTFontDescriptorMatchingProgress (Foundation.NSDictionary dictionary);
	// properties
	public long? CurrentAssetSize { get; }
	public CTFontDescriptor[] Descriptors { get; }
	public Foundation.NSError Error { get; }
	public double? Percentage { get; }
	public CTFontDescriptor[] Result { get; }
	public CTFontDescriptor SourceDescriptor { get; }
	public long? TotalAssetSize { get; }
	public long? TotalDownloadedSize { get; }
}
```


### Namespace Foundation

#### Type Changed: Foundation.DictionaryContainer

Added methods:

```csharp
protected UIKit.UIEdgeInsets? GetUIEdgeInsets (NSString key);
protected void SetUIEdgeInsets (NSString key, UIKit.UIEdgeInsets? value);
```


#### Type Changed: Foundation.INSCoding

Added method:

```csharp
public static T CreateInstance<T> (NSCoder decoder);
```


#### Type Changed: Foundation.INSItemProviderReading

Added methods:

```csharp
public static INSItemProviderReading GetObject<T> (NSData data, string typeIdentifier, out NSError outError);
public static string[] GetReadableTypeIdentifiers<T> ();
```


#### Type Changed: Foundation.INSItemProviderWriting

Added method:

```csharp
public static string[] GetWritableTypeIdentifiers<T> ();
```


#### Type Changed: Foundation.NSAttributedStringDocumentAttributes

Obsoleted properties:

```diff
 [Obsolete ("Use 'CharacterEncoding' instead.")]
 public NSStringEncoding? StringEncoding { get; set; }
```

Added properties:

```csharp
public NSStringEncoding? CharacterEncoding { get; set; }
public float? CocoaVersion { get; set; }
public NSAttributedStringDocumentAttributes DefaultAttributes { get; set; }
public UIKit.NSTextScalingType? SourceTextScaling { get; set; }
public UIKit.NSTextScalingType? TextScaling { get; set; }
```


#### Type Changed: Foundation.NSAttributedStringNameKey

Added values:

```csharp
InflectionAgreementArgument = 10,
InflectionAgreementConcept = 11,
InflectionReferentConcept = 12,
```


#### Type Changed: Foundation.NSBundle

Added property:

```csharp
public static NSString BundleDidLoadNotification { get; }
```


#### Type Changed: Foundation.NSDataWritingOptions

Added value:

```csharp
FileProtectionCompleteWhenUserInactive = 1342177280,
```


#### Type Changed: Foundation.NSDate

Added property:

```csharp
public static NSString SystemClockDidChangeNotification { get; }
```


#### Type Changed: Foundation.NSError

Added property:

```csharp
public static NSString NSNetServicesErrorCode { get; }
```


#### Type Changed: Foundation.NSFileProtectionType

Added value:

```csharp
CompleteWhenUserInactive = 4,
```


#### Type Changed: Foundation.NSLocale

Added properties:

```csharp
public virtual string LanguageIdentifier { get; }
public virtual string RegionCode { get; }
```


#### Type Changed: Foundation.NSMorphology

Added properties:

```csharp
public virtual NSGrammaticalDefiniteness Definiteness { get; set; }
public virtual NSGrammaticalDetermination Determination { get; set; }
public virtual NSGrammaticalCase GrammaticalCase { get; set; }
public virtual NSGrammaticalPerson GrammaticalPerson { get; set; }
public virtual NSGrammaticalPronounType PronounType { get; set; }
```


#### Type Changed: Foundation.NSPort

Added property:

```csharp
public static NSString PortDidBecomeInvalidNotification { get; }
```


#### Type Changed: Foundation.NSThread

Added properties:

```csharp
public static NSString ThreadWillExitNotification { get; }
public static NSString WillBecomeMultiThreadedNotification { get; }
```


#### Type Changed: Foundation.NSTimeZone

Added property:

```csharp
public static NSString SystemTimeZoneDidChangeNotification { get; }
```


#### Type Changed: Foundation.NSUrl

Added properties:

```csharp
public static NSString DirectoryEntryCountKey { get; }
public static NSString FileProtectionCompleteWhenUserInactive { get; }
```

Added method:

```csharp
public static NSUrl FromString (string url, bool encodingInvalidCharacters);
```


#### Type Changed: Foundation.NSUrlComponents

Added method:

```csharp
public static NSUrlComponents FromString (string url, bool encodingInvalidCharacters);
```


#### Type Changed: Foundation.NSUrlSession

Added methods:

```csharp
public virtual NSUrlSessionUploadTask CreateUploadTask (NSData resumeData);
public virtual NSUrlSessionUploadTask CreateUploadTask (NSData resumeData, System.Action<NSData,Foundation.NSUrlResponse,Foundation.NSError> completionHandler);
public virtual System.Threading.Tasks.Task<NSUrlSessionUploadTaskResumeRequest> CreateUploadTaskAsync (NSData resumeData);
public virtual System.Threading.Tasks.Task<NSUrlSessionUploadTaskResumeRequest> CreateUploadTaskAsync (NSData resumeData, out NSUrlSessionUploadTask result);
```


#### Type Changed: Foundation.NSUrlSessionConfiguration

Added property:

```csharp
public Network.NWProxyConfig[] ProxyConfigurations { get; set; }
```


#### Type Changed: Foundation.NSUrlSessionTaskDelegate

Added methods:

```csharp
public virtual void DidReceiveInformationalResponse (NSUrlSession session, NSUrlSessionTask task, NSHttpUrlResponse response);
public virtual void NeedNewBodyStream (NSUrlSession session, NSUrlSessionTask task, long offset, System.Action<NSInputStream> completionHandler);
```


#### Type Changed: Foundation.NSUrlSessionTaskDelegate_Extensions

Added methods:

```csharp
public static void DidReceiveInformationalResponse (this INSUrlSessionTaskDelegate This, NSUrlSession session, NSUrlSessionTask task, NSHttpUrlResponse response);
public static void NeedNewBodyStream (this INSUrlSessionTaskDelegate This, NSUrlSession session, NSUrlSessionTask task, long offset, System.Action<NSInputStream> completionHandler);
```


#### Type Changed: Foundation.NSUrlSessionUploadTask

Added property:

```csharp
public static NSString ResumeDataKey { get; }
```

Added methods:

```csharp
public virtual void CancelByProducingResumeData (System.Action<NSData> completionHandler);
public virtual System.Threading.Tasks.Task<NSData> CancelByProducingResumeDataAsync ();
```


#### New Type: Foundation.NSExceptionError

```csharp
public sealed class NSExceptionError : Foundation.NSError {
	// constructors
	public NSExceptionError (System.Exception exception);
	// properties
	public System.Exception Exception { get; }
}
```

#### New Type: Foundation.NSGrammaticalCase

```csharp
[Serializable]
public enum NSGrammaticalCase {
	Ablative = 6,
	Accusative = 2,
	Adessive = 7,
	Allative = 8,
	Dative = 3,
	Elative = 9,
	Essive = 11,
	Genitive = 4,
	Illative = 10,
	Inessive = 12,
	Locative = 13,
	Nominative = 1,
	NotSet = 0,
	Prepositional = 5,
	Translative = 14,
}
```

#### New Type: Foundation.NSGrammaticalDefiniteness

```csharp
[Serializable]
public enum NSGrammaticalDefiniteness {
	Definite = 2,
	Indefinite = 1,
	NotSet = 0,
}
```

#### New Type: Foundation.NSGrammaticalDetermination

```csharp
[Serializable]
public enum NSGrammaticalDetermination {
	Dependent = 2,
	Independent = 1,
	NotSet = 0,
}
```

#### New Type: Foundation.NSGrammaticalPerson

```csharp
[Serializable]
public enum NSGrammaticalPerson {
	First = 1,
	NotSet = 0,
	Second = 2,
	Third = 3,
}
```

#### New Type: Foundation.NSGrammaticalPronounType

```csharp
[Serializable]
public enum NSGrammaticalPronounType {
	NotSet = 0,
	Personal = 1,
	Possessive = 3,
	Reflexive = 2,
}
```

#### New Type: Foundation.NSMorphologyPronoun

```csharp
public class NSMorphologyPronoun : Foundation.NSObject, INSCoding, INSCopying, INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public NSMorphologyPronoun (NSCoder coder);
	protected NSMorphologyPronoun (NSObjectFlag t);
	protected NSMorphologyPronoun (ObjCRuntime.NativeHandle handle);
	public NSMorphologyPronoun (string pronoun, NSMorphology morphology, NSMorphology dependentMorphology);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual NSMorphology DependentMorphology { get; }
	public virtual NSMorphology Morphology { get; }
	public virtual string Pronoun { get; }
	// methods
	public virtual NSObject Copy (NSZone zone);
	public virtual void EncodeTo (NSCoder encoder);
}
```

#### New Type: Foundation.NSTermOfAddress

```csharp
public class NSTermOfAddress : Foundation.NSObject, INSCoding, INSCopying, INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public NSTermOfAddress (NSCoder coder);
	protected NSTermOfAddress (NSObjectFlag t);
	protected NSTermOfAddress (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static NSTermOfAddress Feminine { get; }
	public virtual string LanguageIdentifier { get; }
	public static NSTermOfAddress Masculine { get; }
	public static NSTermOfAddress Neutral { get; }
	public virtual NSMorphologyPronoun[] Pronouns { get; }
	// methods
	public virtual NSObject Copy (NSZone zone);
	public virtual void EncodeTo (NSCoder encoder);
	public static NSTermOfAddress GetLocalized (string language, NSMorphologyPronoun[] pronouns);
}
```

#### New Type: Foundation.NSUrlSessionUploadTaskResumeRequest

```csharp
public class NSUrlSessionUploadTaskResumeRequest {
	// constructors
	public NSUrlSessionUploadTaskResumeRequest (NSData arg1, NSUrlResponse arg2);
	// properties
	public NSData Arg1 { get; set; }
	public NSUrlResponse Arg2 { get; set; }
}
```


### Namespace GameController

#### Type Changed: GameController.GCVirtualControllerConfiguration

Added property:

```csharp
public virtual bool Hidden { get; set; }
```



### Namespace GameKit

#### Type Changed: GameKit.GKAchievement

Added methods:

```csharp
public virtual UIKit.UIViewController ChallengeComposeControllerWithMessage (string message, GKPlayer[] players, GKChallengeComposeHandler2 completionHandler);
public virtual System.Threading.Tasks.Task<GKChallengeComposeControllerResult> ChallengeComposeControllerWithMessageAsync (string message, GKPlayer[] players);
public virtual System.Threading.Tasks.Task<GKChallengeComposeControllerResult> ChallengeComposeControllerWithMessageAsync (string message, GKPlayer[] players, out UIKit.UIViewController result);
```


#### Type Changed: GameKit.GKAchievementDescription

Added property:

```csharp
public virtual Foundation.NSNumber RarityPercent { get; }
```


#### Type Changed: GameKit.GKLeaderboardEntry

Added methods:

```csharp
public virtual UIKit.UIViewController ChallengeComposeControllerWithMessage (string message, GKPlayer[] players, GKChallengeComposeHandler2 completionHandler);
public virtual System.Threading.Tasks.Task<GKChallengeComposeControllerResult> ChallengeComposeControllerWithMessageAsync (string message, GKPlayer[] players);
public virtual System.Threading.Tasks.Task<GKChallengeComposeControllerResult> ChallengeComposeControllerWithMessageAsync (string message, GKPlayer[] players, out UIKit.UIViewController result);
```


#### Type Changed: GameKit.GKVoiceChat

Added property:

```csharp
public virtual System.Action<GKPlayer,GameKit.GKVoiceChatPlayerState> PlayerVoiceChatStateDidChangeHandler { get; }
```


#### New Type: GameKit.GKChallengeComposeControllerResult

```csharp
public class GKChallengeComposeControllerResult {
	// constructors
	public GKChallengeComposeControllerResult (UIKit.UIViewController composeController, bool issuedChallenge, GKPlayer[] sentPlayers);
	// properties
	public UIKit.UIViewController ComposeController { get; set; }
	public bool IssuedChallenge { get; set; }
	public GKPlayer[] SentPlayers { get; set; }
}
```

#### New Type: GameKit.GKChallengeComposeHandler2

```csharp
public sealed delegate GKChallengeComposeHandler2 : System.MulticastDelegate {
	// constructors
	public GKChallengeComposeHandler2 (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (UIKit.UIViewController composeController, bool issuedChallenge, GKPlayer[] sentPlayers, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (UIKit.UIViewController composeController, bool issuedChallenge, GKPlayer[] sentPlayers);
}
```


### Namespace Metal

#### Type Changed: Metal.IMTLAccelerationStructure

Added property:

```csharp
public virtual MTLResourceId GpuResourceId { get; }
```


#### Type Changed: Metal.IMTLDevice

Added properties:

```csharp
public virtual ulong RecommendedMaxWorkingSetSize { get; }
public virtual bool SupportsBCTextureCompression { get; }
```


#### Type Changed: Metal.IMTLRenderPipelineState

Added properties:

```csharp
public virtual MTLResourceId GpuResourceId { get; }
public virtual UIntPtr MaxTotalThreadgroupsPerMeshGrid { get; }
public virtual UIntPtr MeshThreadExecutionWidth { get; }
```


#### Type Changed: Metal.MTLAccelerationStructureGeometryDescriptor

Added properties:

```csharp
public virtual IMTLBuffer PrimitiveDataBuffer { get; set; }
public virtual UIntPtr PrimitiveDataBufferOffset { get; set; }
public virtual UIntPtr PrimitiveDataElementSize { get; set; }
public virtual UIntPtr PrimitiveDataStride { get; set; }
```


#### Type Changed: Metal.MTLAccelerationStructureInstanceDescriptorType

Added values:

```csharp
Indirect = 3,
IndirectMotion = 4,
```


#### Type Changed: Metal.MTLAccelerationStructureMotionTriangleGeometryDescriptor

Added properties:

```csharp
public virtual IMTLBuffer TransformationMatrixBuffer { get; set; }
public virtual UIntPtr TransformationMatrixBufferOffset { get; set; }
public virtual MTLAttributeFormat VertexFormat { get; set; }
```


#### Type Changed: Metal.MTLAccelerationStructureTriangleGeometryDescriptor

Added properties:

```csharp
public virtual IMTLBuffer TransformationMatrixBuffer { get; set; }
public virtual UIntPtr TransformationMatrixBufferOffset { get; set; }
public virtual MTLAttributeFormat VertexFormat { get; set; }
```


#### Type Changed: Metal.MTLAttributeFormat

Added values:

```csharp
FloatRG11B10 = 54,
FloatRGB9E5 = 55,
```


#### Type Changed: Metal.MTLBinaryArchiveError

Added value:

```csharp
InternalError = 4,
```


#### Type Changed: Metal.MTLCompileOptions

Added properties:

```csharp
public virtual bool AllowReferencingUndefinedSymbols { get; set; }
public virtual MTLCompileSymbolVisibility CompileSymbolVisibility { get; set; }
public virtual UIntPtr MaxTotalThreadsPerThreadgroup { get; set; }
public virtual MTLLibraryOptimizationLevel OptimizationLevel { get; set; }
```


#### Type Changed: Metal.MTLComputePipelineReflection

Added property:

```csharp
public virtual IMTLBinding[] Bindings { get; }
```


#### Type Changed: Metal.MTLDataType

Added values:

```csharp
BFloat = 121,
BFloat2 = 122,
BFloat3 = 123,
BFloat4 = 124,
```


#### Type Changed: Metal.MTLDevice_Extensions

Added methods:

```csharp
public static IMTLArgumentEncoder CreateArgumentEncoder (this IMTLDevice This, IMTLBufferBinding bufferBinding);
public static void CreateRenderPipelineState (this IMTLDevice This, MTLMeshRenderPipelineDescriptor descriptor, MTLPipelineOption options, MTLNewRenderPipelineStateWithReflectionCompletionHandler completionHandler);
public static IMTLRenderPipelineState CreateRenderPipelineState (this IMTLDevice This, MTLMeshRenderPipelineDescriptor descriptor, MTLPipelineOption options, out MTLRenderPipelineReflection reflection, out Foundation.NSError error);
public static MTLArchitecture GetArchitecture (this IMTLDevice This);
public static MTLSizeAndAlign GetHeapAccelerationStructureSizeAndAlign (this IMTLDevice This, MTLAccelerationStructureDescriptor descriptor);
public static MTLSizeAndAlign GetHeapAccelerationStructureSizeAndAlign (this IMTLDevice This, UIntPtr size);
public static MTLSize GetSparseTileSize (this IMTLDevice This, MTLTextureType textureType, MTLPixelFormat pixelFormat, UIntPtr sampleCount, MTLSparsePageSize sparsePageSize);
public static UIntPtr GetSparseTileSizeInBytes (this IMTLDevice This, MTLSparsePageSize sparsePageSize);
```


#### Type Changed: Metal.MTLFunctionOptions

Added value:

```csharp
StoreFunctionInMetalScript = 2,
```


#### Type Changed: Metal.MTLFunctionType

Added values:

```csharp
Mesh = 7,
Object = 8,
```


#### Type Changed: Metal.MTLGpuFamily

Added values:

```csharp
Apple8 = 1008,
Apple9 = 1009,
Metal3 = 5001,
```


#### Type Changed: Metal.MTLHeapDescriptor

Added property:

```csharp
public virtual MTLSparsePageSize SparsePageSize { get; set; }
```


#### Type Changed: Metal.MTLIndirectCommandBufferDescriptor

Added properties:

```csharp
public virtual UIntPtr MaxKernelThreadgroupMemoryBindCount { get; set; }
public virtual UIntPtr MaxMeshBufferBindCount { get; set; }
public virtual UIntPtr MaxObjectBufferBindCount { get; set; }
public virtual UIntPtr MaxObjectThreadgroupMemoryBindCount { get; set; }
public virtual bool SupportDynamicAttributeStride { get; set; }
public virtual bool SupportRayTracing { get; set; }
```


#### Type Changed: Metal.MTLIndirectCommandType

Added values:

```csharp
DrawMeshThreadgroups = 128,
DrawMeshThreads = 256,
```


#### Type Changed: Metal.MTLIntersectionFunctionSignature

Added values:

```csharp
CurveData = 128,
MaxLevels = 64,
```


#### Type Changed: Metal.MTLLanguageVersion

Added values:

```csharp
v3_0 = 196608,
v3_1 = 196609,
```


#### Type Changed: Metal.MTLRenderPipelineReflection

Added properties:

```csharp
public virtual IMTLBinding[] FragmentBindings { get; }
public virtual IMTLBinding[] MeshBindings { get; }
public virtual IMTLBinding[] ObjectBindings { get; }
public virtual IMTLBinding[] TileBindings { get; }
public virtual IMTLBinding[] VertexBindings { get; }
```


#### Type Changed: Metal.MTLRenderStages

Added values:

```csharp
Mesh = 16,
Object = 8,
```


#### Type Changed: Metal.MTLResourceStateCommandEncoder_Extensions

Added method:

```csharp
public static void MoveTextureMappings (this IMTLResourceStateCommandEncoder This, IMTLTexture sourceTexture, UIntPtr sourceSlice, UIntPtr sourceLevel, MTLOrigin sourceOrigin, MTLSize sourceSize, IMTLTexture destinationTexture, UIntPtr destinationSlice, UIntPtr destinationLevel, MTLOrigin destinationOrigin);
```


#### Type Changed: Metal.MTLTextureUsage

Added value:

```csharp
ShaderAtomic = 32,
```


#### Type Changed: Metal.MTLVertexFormat

Added values:

```csharp
FloatRG11B10 = 54,
FloatRgb9E5 = 55,
```


#### New Type: Metal.IMTLBinding

```csharp
public interface IMTLBinding : ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual MTLBindingAccess Access { get; }
	public virtual bool Argument { get; }
	public virtual UIntPtr Index { get; }
	public virtual string Name { get; }
	public virtual MTLBindingType Type { get; }
	public virtual bool Used { get; }
}
```

#### New Type: Metal.IMTLBufferBinding

```csharp
public interface IMTLBufferBinding : IMTLBinding, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual UIntPtr BufferAlignment { get; }
	public virtual UIntPtr BufferDataSize { get; }
	public virtual MTLDataType BufferDataType { get; }
	public virtual MTLPointerType BufferPointerType { get; }
	public virtual MTLStructType BufferStructType { get; }
}
```

#### New Type: Metal.IMTLObjectPayloadBinding

```csharp
public interface IMTLObjectPayloadBinding : IMTLBinding, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual UIntPtr ObjectPayloadAlignment { get; }
	public virtual UIntPtr ObjectPayloadDataSize { get; }
}
```

#### New Type: Metal.IMTLTextureBinding

```csharp
public interface IMTLTextureBinding : IMTLBinding, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual UIntPtr ArrayLength { get; }
	public virtual bool DepthTexture { get; }
	public virtual MTLDataType TextureDataType { get; }
	public virtual MTLTextureType TextureType { get; }
}
```

#### New Type: Metal.IMTLThreadgroupBinding

```csharp
public interface IMTLThreadgroupBinding : IMTLBinding, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual UIntPtr ThreadgroupMemoryAlignment { get; }
	public virtual UIntPtr ThreadgroupMemoryDataSize { get; }
}
```

#### New Type: Metal.MTLAccelerationStructureCommandEncoder_Extensions

```csharp
public static class MTLAccelerationStructureCommandEncoder_Extensions {
	// methods
	public static void RefitAccelerationStructure (this IMTLAccelerationStructureCommandEncoder This, IMTLAccelerationStructure sourceAccelerationStructure, MTLAccelerationStructureDescriptor descriptor, IMTLAccelerationStructure destinationAccelerationStructure, IMTLBuffer scratchBuffer, UIntPtr scratchBufferOffset, MTLAccelerationStructureRefitOptions options);
}
```

#### New Type: Metal.MTLAccelerationStructureCurveGeometryDescriptor

```csharp
public class MTLAccelerationStructureCurveGeometryDescriptor : Metal.MTLAccelerationStructureGeometryDescriptor {
	// constructors
	public MTLAccelerationStructureCurveGeometryDescriptor ();
	protected MTLAccelerationStructureCurveGeometryDescriptor (Foundation.NSObjectFlag t);
	protected MTLAccelerationStructureCurveGeometryDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IMTLBuffer ControlPointBuffer { get; set; }
	public virtual UIntPtr ControlPointBufferOffset { get; set; }
	public virtual UIntPtr ControlPointCount { get; set; }
	public virtual MTLAttributeFormat ControlPointFormat { get; set; }
	public virtual UIntPtr ControlPointStride { get; set; }
	public virtual MTLCurveBasis CurveBasis { get; set; }
	public virtual MTLCurveEndCaps CurveEndCaps { get; set; }
	public virtual MTLCurveType CurveType { get; set; }
	public virtual IMTLBuffer IndexBuffer { get; set; }
	public virtual UIntPtr IndexBufferOffset { get; set; }
	public virtual MTLIndexType IndexType { get; set; }
	public virtual IMTLBuffer RadiusBuffer { get; set; }
	public virtual UIntPtr RadiusBufferOffset { get; set; }
	public virtual MTLAttributeFormat RadiusFormat { get; set; }
	public virtual UIntPtr RadiusStride { get; set; }
	public virtual UIntPtr SegmentControlPointCount { get; set; }
	public virtual UIntPtr SegmentCount { get; set; }
	// methods
	public static MTLAccelerationStructureCurveGeometryDescriptor GetDescriptor ();
}
```

#### New Type: Metal.MTLAccelerationStructureMotionCurveGeometryDescriptor

```csharp
public class MTLAccelerationStructureMotionCurveGeometryDescriptor : Metal.MTLAccelerationStructureGeometryDescriptor {
	// constructors
	public MTLAccelerationStructureMotionCurveGeometryDescriptor ();
	protected MTLAccelerationStructureMotionCurveGeometryDescriptor (Foundation.NSObjectFlag t);
	protected MTLAccelerationStructureMotionCurveGeometryDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual MTLMotionKeyframeData[] ControlPointBuffers { get; set; }
	public virtual UIntPtr ControlPointCount { get; set; }
	public virtual MTLAttributeFormat ControlPointFormat { get; set; }
	public virtual UIntPtr ControlPointStride { get; set; }
	public virtual MTLCurveBasis CurveBasis { get; set; }
	public virtual MTLCurveEndCaps CurveEndCaps { get; set; }
	public virtual MTLCurveType CurveType { get; set; }
	public virtual IMTLBuffer IndexBuffer { get; set; }
	public virtual UIntPtr IndexBufferOffset { get; set; }
	public virtual MTLIndexType IndexType { get; set; }
	public virtual MTLMotionKeyframeData[] RadiusBuffers { get; set; }
	public virtual MTLAttributeFormat RadiusFormat { get; set; }
	public virtual UIntPtr RadiusStride { get; set; }
	public virtual UIntPtr SegmentControlPointCount { get; set; }
	public virtual UIntPtr SegmentCount { get; set; }
	// methods
	public static MTLAccelerationStructureMotionCurveGeometryDescriptor GetDescriptor ();
}
```

#### New Type: Metal.MTLAccelerationStructurePassDescriptor

```csharp
public class MTLAccelerationStructurePassDescriptor : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public MTLAccelerationStructurePassDescriptor ();
	protected MTLAccelerationStructurePassDescriptor (Foundation.NSObjectFlag t);
	protected MTLAccelerationStructurePassDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public static MTLAccelerationStructurePassDescriptor AccelerationStructurePassDescriptor { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray SampleBufferAttachments { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
```

#### New Type: Metal.MTLAccelerationStructurePassSampleBufferAttachmentDescriptor

```csharp
public class MTLAccelerationStructurePassSampleBufferAttachmentDescriptor : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public MTLAccelerationStructurePassSampleBufferAttachmentDescriptor ();
	protected MTLAccelerationStructurePassSampleBufferAttachmentDescriptor (Foundation.NSObjectFlag t);
	protected MTLAccelerationStructurePassSampleBufferAttachmentDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual UIntPtr EndOfEncoderSampleIndex { get; set; }
	public virtual IMTLCounterSampleBuffer SampleBuffer { get; set; }
	public virtual UIntPtr StartOfEncoderSampleIndex { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
```

#### New Type: Metal.MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray

```csharp
public class MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray : Foundation.NSObject {
	// constructors
	public MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray ();
	protected MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray (Foundation.NSObjectFlag t);
	protected MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual MTLAccelerationStructurePassSampleBufferAttachmentDescriptor GetObject (UIntPtr attachmentIndex);
	public virtual void SetObject (MTLAccelerationStructurePassSampleBufferAttachmentDescriptor attachment, UIntPtr attachmentIndex);
}
```

#### New Type: Metal.MTLAccelerationStructureRefitOptions

```csharp
[Serializable]
[Flags]
public enum MTLAccelerationStructureRefitOptions {
	PerPrimitiveData = 2,
	VertexData = 1,
}
```

#### New Type: Metal.MTLArchitecture

```csharp
public class MTLArchitecture : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public MTLArchitecture ();
	protected MTLArchitecture (Foundation.NSObjectFlag t);
	protected MTLArchitecture (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string Name { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}
```

#### New Type: Metal.MTLBindingAccess

```csharp
[Serializable]
public enum MTLBindingAccess {
	ReadOnly = 0,
	ReadWrite = 1,
	WriteOnly = 2,
}
```

#### New Type: Metal.MTLBindingType

```csharp
[Serializable]
public enum MTLBindingType {
	Buffer = 0,
	Imageblock = 17,
	ImageblockData = 16,
	InstanceAccelerationStructure = 26,
	IntersectionFunctionTable = 27,
	ObjectPayload = 34,
	PrimitiveAccelerationStructure = 25,
	Sampler = 3,
	Texture = 2,
	ThreadgroupMemory = 1,
	VisibleFunctionTable = 24,
}
```

#### New Type: Metal.MTLBuffer_Extensions

```csharp
public static class MTLBuffer_Extensions {
	// methods
	public static ulong GetGpuAddress (this IMTLBuffer This);
}
```

#### New Type: Metal.MTLCommandBuffer_Extensions

```csharp
public static class MTLCommandBuffer_Extensions {
	// methods
	public static IMTLAccelerationStructureCommandEncoder CreateAccelerationStructureCommandEncoder (this IMTLCommandBuffer This, MTLAccelerationStructurePassDescriptor descriptor);
}
```

#### New Type: Metal.MTLCompileSymbolVisibility

```csharp
[Serializable]
public enum MTLCompileSymbolVisibility {
	Default = 0,
	Hidden = 1,
}
```

#### New Type: Metal.MTLComputeCommandEncoder_Extensions

```csharp
public static class MTLComputeCommandEncoder_Extensions {
	// methods
	public static void SetBuffer (this IMTLComputeCommandEncoder This, IMTLBuffer buffer, UIntPtr offset, UIntPtr stride, UIntPtr index);
	public static void SetBufferOffset (this IMTLComputeCommandEncoder This, UIntPtr offset, UIntPtr stride, UIntPtr index);
	public static void SetBuffers (this IMTLComputeCommandEncoder This, IntPtr buffers, IntPtr offsets, IntPtr strides, Foundation.NSRange range);
	public static void SetBytes (this IMTLComputeCommandEncoder This, IntPtr bytes, UIntPtr length, UIntPtr stride, UIntPtr index);
}
```

#### New Type: Metal.MTLComputePipelineState_Extensions

```csharp
public static class MTLComputePipelineState_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceId (this IMTLComputePipelineState This);
}
```

#### New Type: Metal.MTLCurveBasis

```csharp
[Serializable]
public enum MTLCurveBasis {
	BSpline = 0,
	Bezier = 3,
	CatmullRom = 1,
	Linear = 2,
}
```

#### New Type: Metal.MTLCurveEndCaps

```csharp
[Serializable]
public enum MTLCurveEndCaps {
	Disk = 1,
	None = 0,
	Sphere = 2,
}
```

#### New Type: Metal.MTLCurveType

```csharp
[Serializable]
public enum MTLCurveType {
	Flat = 1,
	Round = 0,
}
```

#### New Type: Metal.MTLHeap_Extensions

```csharp
public static class MTLHeap_Extensions {
	// methods
	public static IMTLAccelerationStructure CreateAccelerationStructure (this IMTLHeap This, MTLAccelerationStructureDescriptor descriptor);
	public static IMTLAccelerationStructure CreateAccelerationStructure (this IMTLHeap This, UIntPtr size);
	public static IMTLAccelerationStructure CreateAccelerationStructure (this IMTLHeap This, MTLAccelerationStructureDescriptor descriptor, UIntPtr offset);
	public static IMTLAccelerationStructure CreateAccelerationStructure (this IMTLHeap This, UIntPtr size, UIntPtr offset);
}
```

#### New Type: Metal.MTLIOCommandQueueType

```csharp
[Serializable]
public enum MTLIOCommandQueueType {
	Concurrent = 0,
	Serial = 1,
}
```

#### New Type: Metal.MTLIOCompressionContext

```csharp
public class MTLIOCompressionContext : ObjCRuntime.DisposableObject {
	// properties
	public static IntPtr DefaultChunkSize { get; }
	// methods
	public void AppendData (Foundation.NSData data);
	public void AppendData (byte[] data);
	public void AppendData (System.ReadOnlySpan<byte> data);
	public static MTLIOCompressionContext Create (string path, MTLIOCompressionMethod type, long chunkSize);
	protected override void Dispose (bool disposing);
	public MTLIOCompressionStatus FlushAndDestroy ();
}
```

#### New Type: Metal.MTLIOCompressionMethod

```csharp
[Serializable]
public enum MTLIOCompressionMethod {
	Lz4 = 2,
	LzBitmap = 4,
	Lzfse = 1,
	Lzma = 3,
	Zlib = 0,
}
```

#### New Type: Metal.MTLIOCompressionStatus

```csharp
[Serializable]
public enum MTLIOCompressionStatus {
	Complete = 0,
	Error = 1,
}
```

#### New Type: Metal.MTLIOError

```csharp
[Serializable]
public enum MTLIOError {
	Internal = 2,
	UrlInvalid = 1,
}
```

#### New Type: Metal.MTLIOErrorExtensions

```csharp
public static class MTLIOErrorExtensions {
	// methods
	public static Foundation.NSString GetDomain (this MTLIOError self);
}
```

#### New Type: Metal.MTLIOPriority

```csharp
[Serializable]
public enum MTLIOPriority {
	High = 0,
	Low = 2,
	Normal = 1,
}
```

#### New Type: Metal.MTLIOStatus

```csharp
[Serializable]
public enum MTLIOStatus {
	Cancelled = 1,
	Complete = 3,
	Error = 2,
	Pending = 0,
}
```

#### New Type: Metal.MTLIndirectCommandBuffer_Extensions

```csharp
public static class MTLIndirectCommandBuffer_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceID (this IMTLIndirectCommandBuffer This);
}
```

#### New Type: Metal.MTLIndirectComputeCommand_Extensions

```csharp
public static class MTLIndirectComputeCommand_Extensions {
	// methods
	public static void SetKernelBuffer (this IMTLIndirectComputeCommand This, IMTLBuffer buffer, UIntPtr offset, UIntPtr stride, UIntPtr index);
}
```

#### New Type: Metal.MTLIndirectInstanceAccelerationStructureDescriptor

```csharp
public class MTLIndirectInstanceAccelerationStructureDescriptor : Metal.MTLAccelerationStructureDescriptor {
	// constructors
	public MTLIndirectInstanceAccelerationStructureDescriptor ();
	protected MTLIndirectInstanceAccelerationStructureDescriptor (Foundation.NSObjectFlag t);
	protected MTLIndirectInstanceAccelerationStructureDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IMTLBuffer InstanceCountBuffer { get; set; }
	public virtual UIntPtr InstanceCountBufferOffset { get; set; }
	public virtual IMTLBuffer InstanceDescriptorBuffer { get; set; }
	public virtual UIntPtr InstanceDescriptorBufferOffset { get; set; }
	public virtual UIntPtr InstanceDescriptorStride { get; set; }
	public virtual MTLAccelerationStructureInstanceDescriptorType InstanceDescriptorType { get; set; }
	public virtual UIntPtr MaxInstanceCount { get; set; }
	public virtual UIntPtr MaxMotionTransformCount { get; set; }
	public virtual IMTLBuffer MotionTransformBuffer { get; set; }
	public virtual UIntPtr MotionTransformBufferOffset { get; set; }
	public virtual IMTLBuffer MotionTransformCountBuffer { get; set; }
	public virtual UIntPtr MotionTransformCountBufferOffset { get; set; }
	// methods
	public static MTLIndirectInstanceAccelerationStructureDescriptor GetDescriptor ();
}
```

#### New Type: Metal.MTLIndirectRenderCommand_Extensions

```csharp
public static class MTLIndirectRenderCommand_Extensions {
	// methods
	public static void ClearBarrier (this IMTLIndirectRenderCommand This);
	public static void DrawMeshThreadgroups (this IMTLIndirectRenderCommand This, MTLSize threadgroupsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup);
	public static void DrawMeshThreads (this IMTLIndirectRenderCommand This, MTLSize threadsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup);
	public static void SetBarrier (this IMTLIndirectRenderCommand This);
	public static void SetMeshBuffer (this IMTLIndirectRenderCommand This, IMTLBuffer buffer, UIntPtr offset, UIntPtr index);
	public static void SetObjectBuffer (this IMTLIndirectRenderCommand This, IMTLBuffer buffer, UIntPtr offset, UIntPtr index);
	public static void SetObjectThreadgroupMemoryLength (this IMTLIndirectRenderCommand This, UIntPtr length, UIntPtr index);
	public static void SetVertexBuffer (this IMTLIndirectRenderCommand This, IMTLBuffer buffer, UIntPtr offset, UIntPtr stride, UIntPtr index);
}
```

#### New Type: Metal.MTLIntersectionFunctionTable_Extensions

```csharp
public static class MTLIntersectionFunctionTable_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceId (this IMTLIntersectionFunctionTable This);
	public static void SetOpaqueCurveIntersectionFunction (this IMTLIntersectionFunctionTable This, MTLIntersectionFunctionSignature signature, Foundation.NSRange range);
	public static void SetOpaqueCurveIntersectionFunction (this IMTLIntersectionFunctionTable This, MTLIntersectionFunctionSignature signature, UIntPtr index);
}
```

#### New Type: Metal.MTLLibraryOptimizationLevel

```csharp
[Serializable]
public enum MTLLibraryOptimizationLevel {
	Default = 0,
	Size = 1,
}
```

#### New Type: Metal.MTLMeshRenderPipelineDescriptor

```csharp
public class MTLMeshRenderPipelineDescriptor : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public MTLMeshRenderPipelineDescriptor ();
	protected MTLMeshRenderPipelineDescriptor (Foundation.NSObjectFlag t);
	protected MTLMeshRenderPipelineDescriptor (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual bool AlphaToCoverageEnabled { get; set; }
	public virtual bool AlphaToOneEnabled { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual MTLRenderPipelineColorAttachmentDescriptorArray ColorAttachments { get; }
	public virtual MTLPixelFormat DepthAttachmentPixelFormat { get; set; }
	public virtual MTLPipelineBufferDescriptorArray FragmentBuffers { get; }
	public virtual IMTLFunction FragmentFunction { get; set; }
	public virtual MTLLinkedFunctions FragmentLinkedFunctions { get; set; }
	public virtual string Label { get; set; }
	public virtual UIntPtr MaxTotalThreadgroupsPerMeshGrid { get; set; }
	public virtual UIntPtr MaxTotalThreadsPerMeshThreadgroup { get; set; }
	public virtual UIntPtr MaxTotalThreadsPerObjectThreadgroup { get; set; }
	public virtual UIntPtr MaxVertexAmplificationCount { get; set; }
	public virtual MTLPipelineBufferDescriptorArray MeshBuffers { get; }
	public virtual IMTLFunction MeshFunction { get; set; }
	public virtual MTLLinkedFunctions MeshLinkedFunctions { get; set; }
	public virtual bool MeshThreadgroupSizeIsMultipleOfThreadExecutionWidth { get; set; }
	public virtual MTLPipelineBufferDescriptorArray ObjectBuffers { get; }
	public virtual IMTLFunction ObjectFunction { get; set; }
	public virtual MTLLinkedFunctions ObjectLinkedFunctions { get; set; }
	public virtual bool ObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth { get; set; }
	public virtual UIntPtr PayloadMemoryLength { get; set; }
	public virtual UIntPtr RasterSampleCount { get; set; }
	public virtual bool RasterizationEnabled { get; set; }
	public virtual MTLPixelFormat StencilAttachmentPixelFormat { get; set; }
	public virtual bool SupportIndirectCommandBuffers { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void Reset ();
}
```

#### New Type: Metal.MTLRenderCommandEncoder_Extensions

```csharp
public static class MTLRenderCommandEncoder_Extensions {
	// methods
	public static void DrawMeshThreadgroups (this IMTLRenderCommandEncoder This, MTLSize threadgroupsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup);
	public static void DrawMeshThreadgroups (this IMTLRenderCommandEncoder This, IMTLBuffer indirectBuffer, UIntPtr indirectBufferOffset, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup);
	public static void DrawMeshThreads (this IMTLRenderCommandEncoder This, MTLSize threadsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup);
	public static void MemoryBarrier (this IMTLRenderCommandEncoder This, MTLBarrierScope scope, MTLRenderStages after, MTLRenderStages before);
	public static void MemoryBarrier (this IMTLRenderCommandEncoder This, IMTLResource[] resources, UIntPtr count, MTLRenderStages after, MTLRenderStages before);
	public static void SetMeshBuffer (this IMTLRenderCommandEncoder This, IMTLBuffer buffer, UIntPtr offset, UIntPtr index);
	public static void SetMeshBufferOffset (this IMTLRenderCommandEncoder This, UIntPtr offset, UIntPtr index);
	public static void SetMeshBuffers (this IMTLRenderCommandEncoder This, IntPtr buffers, IntPtr offsets, Foundation.NSRange range);
	public static void SetMeshBytes (this IMTLRenderCommandEncoder This, IntPtr bytes, UIntPtr length, UIntPtr index);
	public static void SetMeshSamplerState (this IMTLRenderCommandEncoder This, IMTLSamplerState sampler, UIntPtr index);
	public static void SetMeshSamplerState (this IMTLRenderCommandEncoder This, IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, UIntPtr index);
	public static void SetMeshSamplerStates (this IMTLRenderCommandEncoder This, IntPtr samplers, Foundation.NSRange range);
	public static void SetMeshSamplerStates (this IMTLRenderCommandEncoder This, IntPtr samplers, IntPtr lodMinClamps, IntPtr lodMaxClamps, Foundation.NSRange range);
	public static void SetMeshTexture (this IMTLRenderCommandEncoder This, IMTLTexture texture, UIntPtr index);
	public static void SetMeshTextures (this IMTLRenderCommandEncoder This, IntPtr textures, Foundation.NSRange range);
	public static void SetObjectBuffer (this IMTLRenderCommandEncoder This, IMTLBuffer buffer, UIntPtr offset, UIntPtr index);
	public static void SetObjectBufferOffset (this IMTLRenderCommandEncoder This, UIntPtr offset, UIntPtr index);
	public static void SetObjectBuffers (this IMTLRenderCommandEncoder This, IntPtr buffers, IntPtr offsets, Foundation.NSRange range);
	public static void SetObjectBytes (this IMTLRenderCommandEncoder This, IntPtr bytes, UIntPtr length, UIntPtr index);
	public static void SetObjectSamplerState (this IMTLRenderCommandEncoder This, IMTLSamplerState sampler, UIntPtr index);
	public static void SetObjectSamplerState (this IMTLRenderCommandEncoder This, IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, UIntPtr index);
	public static void SetObjectSamplerStates (this IMTLRenderCommandEncoder This, IntPtr samplers, Foundation.NSRange range);
	public static void SetObjectSamplerStates (this IMTLRenderCommandEncoder This, IntPtr samplers, IntPtr lodMinClamps, IntPtr lodMaxClamps, Foundation.NSRange range);
	public static void SetObjectTexture (this IMTLRenderCommandEncoder This, IMTLTexture texture, UIntPtr index);
	public static void SetObjectTextures (this IMTLRenderCommandEncoder This, IntPtr textures, Foundation.NSRange range);
	public static void SetObjectThreadgroupMemoryLength (this IMTLRenderCommandEncoder This, UIntPtr length, UIntPtr index);
	public static void SetVertexBuffer (this IMTLRenderCommandEncoder This, IMTLBuffer buffer, UIntPtr offset, UIntPtr stride, UIntPtr index);
	public static void SetVertexBufferOffset (this IMTLRenderCommandEncoder This, UIntPtr offset, UIntPtr stride, UIntPtr index);
	public static void SetVertexBuffers (this IMTLRenderCommandEncoder This, IntPtr buffers, IntPtr offsets, IntPtr strides, Foundation.NSRange range);
	public static void SetVertexBytes (this IMTLRenderCommandEncoder This, IntPtr bytes, UIntPtr length, UIntPtr stride, UIntPtr index);
}
```

#### New Type: Metal.MTLRenderPipelineState_Extensions

```csharp
public static class MTLRenderPipelineState_Extensions {
	// methods
	public static UIntPtr GetMaxTotalThreadsPerMeshThreadgroup (this IMTLRenderPipelineState This);
	public static UIntPtr GetMaxTotalThreadsPerObjectThreadgroup (this IMTLRenderPipelineState This);
	public static UIntPtr GetObjectThreadExecutionWidth (this IMTLRenderPipelineState This);
}
```

#### New Type: Metal.MTLResourceId

```csharp
public struct MTLResourceId {
	// fields
	public ulong Impl;
}
```

#### New Type: Metal.MTLSamplerState_Extensions

```csharp
public static class MTLSamplerState_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceId (this IMTLSamplerState This);
}
```

#### New Type: Metal.MTLSparsePageSize

```csharp
[Serializable]
public enum MTLSparsePageSize {
	Size16 = 101,
	Size256 = 103,
	Size64 = 102,
}
```

#### New Type: Metal.MTLTexture_Extensions

```csharp
public static class MTLTexture_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceId (this IMTLTexture This);
}
```

#### New Type: Metal.MTLVisibleFunctionTable_Extensions

```csharp
public static class MTLVisibleFunctionTable_Extensions {
	// methods
	public static MTLResourceId GetGpuResourceId (this IMTLVisibleFunctionTable This);
}
```


### Namespace MetalPerformanceShaders

#### Type Changed: MetalPerformanceShaders.IMPSCnnBatchNormalizationDataSource

Added methods:

```csharp
public static T CreateInstance<T> (Foundation.NSCoder decoder);
public static bool GetSupportsSecureCoding<T> ();
```


#### Type Changed: MetalPerformanceShaders.IMPSCnnInstanceNormalizationDataSource

Added method:

```csharp
public static T CreateInstance<T> (Foundation.NSCoder decoder);
```


#### Type Changed: MetalPerformanceShaders.MPSCommandBuffer

Added method:

```csharp
public virtual Metal.IMTLAccelerationStructureCommandEncoder CreateAccelerationStructureCommandEncoder (Metal.MTLAccelerationStructurePassDescriptor descriptor);
```



### Namespace ModelIO

#### Type Changed: ModelIO.IMDLTransformComponent

Added method:

```csharp
public static CoreGraphics.NMatrix4 CreateGlobalTransform<T> (MDLObject obj, double atTime);
```


#### Type Changed: ModelIO.MDLMaterial

Added properties:

```csharp
public MDLMaterialProperty Item { get; }
public MDLMaterialProperty Item { get; }
```



### Namespace Network

#### Type Changed: Network.NWPrivacyContext

Added methods:

```csharp
public void AddProxy (NWProxyConfig proxyConfig);
public void ClearProxies ();
```


#### New Type: Network.NWProxyConfig

```csharp
public class NWProxyConfig : CoreFoundation.NativeObject {
	// properties
	public bool FailoverAllowed { get; set; }
	// methods
	public void AddExcludedDomain (string domain);
	public void AddMatchDomain (string domain);
	public void ClearExcludedDomains ();
	public void ClearMatchDomains ();
	public static NWProxyConfig CreateHttpConnect (NWEndpoint proxyEndpoint, NWProtocolTlsOptions options);
	public static NWProxyConfig CreateObliviousHttp (NWRelayHop hop, string relaysResourcePath, byte[] gatewayKeyConfig);
	public static NWProxyConfig CreateRelay (NWRelayHop firstHop, NWRelayHop secondHop);
	public static NWProxyConfig CreateSocksV5 (NWEndpoint endpoint);
	public void EnumerateExcludedDomains (System.Action<string> handler);
	public void EnumerateMatchDomains (System.Action<string> handler);
	public void SetUsernameAndPassword (string username, string password);
}
```

#### New Type: Network.NWRelayHop

```csharp
public class NWRelayHop : CoreFoundation.NativeObject {
	// methods
	public void AddAdditionalHttpHeaderField (string fieldName, string fieldValue);
	public static NWRelayHop Create (NWEndpoint http3RelayEndpoint, NWEndpoint http2RelayEndpoint, NWProtocolOptions relayTlsOptions);
}
```


### Namespace ObjCRuntime

#### Type Changed: ObjCRuntime.Constants

Modified fields:

```diff
-public const string Version = "17.2.0";
+public const string Version = "17.3.0";
```

Added fields:

```csharp
public static const string CryptoTokenKitLibrary = "/System/Library/Frameworks/CryptoTokenKit.framework/CryptoTokenKit";
public static const string DeviceDiscoveryExtensionLibrary = "/System/Library/Frameworks/DeviceDiscoveryExtension.framework/DeviceDiscoveryExtension";
public static const string SafetyKitLibrary = "/System/Library/Frameworks/SafetyKit.framework/SafetyKit";
```


#### Type Changed: ObjCRuntime.DisposableObject

Added method:

```csharp
protected void ClearHandle ();
```


#### Type Changed: ObjCRuntime.LinkWithAttribute

Added property:

```csharp
public bool LinkWithSwiftSystemLibraries { get; set; }
```


#### New Type: ObjCRuntime.BlockCallbackAttribute

```csharp
public class BlockCallbackAttribute : System.Attribute {
	// constructors
	public BlockCallbackAttribute ();
}
```

#### New Type: ObjCRuntime.CCallbackAttribute

```csharp
public class CCallbackAttribute : System.Attribute {
	// constructors
	public CCallbackAttribute ();
}
```


### Namespace UIKit

#### Type Changed: UIKit.IUICGFloatTraitDefinition

Added method:

```csharp
public static System.Runtime.InteropServices.NFloat GetDefaultValue<T> ();
```


#### Type Changed: UIKit.IUINSIntegerTraitDefinition

Added method:

```csharp
public static IntPtr GetDefaultValue<T> ();
```


#### Type Changed: UIKit.IUIObjectTraitDefinition

Added method:

```csharp
public static Foundation.NSObject GetDefaultValue<T> ();
```


#### Type Changed: UIKit.IUIPopoverBackgroundViewMethods

Added methods:

```csharp
public static System.Runtime.InteropServices.NFloat GetArrowBase<T> ();
public static System.Runtime.InteropServices.NFloat GetArrowHeight<T> ();
public static UIEdgeInsets GetContentViewInsets<T> ();
```


#### Type Changed: UIKit.IUITraitDefinition

Added methods:

```csharp
public static bool GetAffectsColorAppearance<T> ();
public static string GetIdentifier<T> ();
public static string GetName<T> ();
```


#### Type Changed: UIKit.UITextView

Obsoleted properties:

```diff
 [Obsolete ("Use 'TypingAttributes2' instead, because this property will return null instead of an empty dictionary.")]
 public virtual Foundation.NSDictionary TypingAttributes { get; set; }
```

Added property:

```csharp
public Foundation.NSDictionary TypingAttributes2 { get; set; }
```


#### New Type: UIKit.NSAttributedStringDocumentReadingOptions

```csharp
public class NSAttributedStringDocumentReadingOptions : Foundation.DictionaryContainer {
	// constructors
	public NSAttributedStringDocumentReadingOptions ();
	public NSAttributedStringDocumentReadingOptions (Foundation.NSDictionary dictionary);
	// properties
	public Foundation.NSStringEncoding? CharacterEncoding { get; set; }
	public Foundation.NSDictionary DefaultAttributes { get; set; }
	public NSAttributedStringDocumentType? DocumentType { get; set; }
	public NSTextScalingType? SourceTextScaling { get; set; }
	public NSTextScalingType? TargetTextScaling { get; set; }
}
```

#### New Type: UIKit.NSAttributedStringDocumentType

```csharp
[Serializable]
public enum NSAttributedStringDocumentType {
	DocFormat = 5,
	Html = 3,
	MacSimple = 4,
	OfficeOpenXml = 7,
	OpenDocument = 9,
	Plain = 0,
	Rtf = 1,
	Rtfd = 2,
	Unknown = -1,
	WebArchive = 8,
	WordML = 6,
}
```

#### New Type: UIKit.NSAttributedStringDocumentTypeExtensions

```csharp
public static class NSAttributedStringDocumentTypeExtensions {
	// methods
	public static Foundation.NSString GetConstant (this NSAttributedStringDocumentType self);
	public static NSAttributedStringDocumentType GetValue (Foundation.NSString constant);
}
```


### Namespace Vision

#### Type Changed: Vision.VNBarcodeObservation

Added properties:

```csharp
public virtual bool IsColorInverted { get; }
public virtual bool IsGS1DataCarrier { get; }
public virtual Foundation.NSData PayloadData { get; }
public virtual VNBarcodeCompositeType SupplementalCompositeType { get; }
public virtual Foundation.NSData SupplementalPayloadData { get; }
public virtual string SupplementalPayloadString { get; }
```


#### Type Changed: Vision.VNBarcodeSymbology

Added value:

```csharp
MsiPlessey = 23,
```


#### Type Changed: Vision.VNClassifyImageRequestRevision

Added value:

```csharp
Two = 2,
```


#### Type Changed: Vision.VNDetectBarcodesRequest

Added property:

```csharp
public virtual bool CoalesceCompositeSymbologies { get; set; }
```


#### Type Changed: Vision.VNDetectBarcodesRequestRevision

Added values:

```csharp
Four = 4,
Three = 3,
```


#### Type Changed: Vision.VNDetectFaceCaptureQualityRequestRevision

Added value:

```csharp
Three = 3,
```


#### Type Changed: Vision.VNDetectHumanBodyPoseRequest

Added methods:

```csharp
public virtual VNHumanBodyPoseObservationJointName[] GetSupportedJointNames (out Foundation.NSError error);
public virtual VNHumanBodyPoseObservationJointsGroupName[] GetSupportedJointsGroupNames (out Foundation.NSError error);
```


#### Type Changed: Vision.VNDetectHumanHandPoseRequest

Added methods:

```csharp
public virtual VNHumanHandPoseObservationJointName[] GetSupportedJointNames (out Foundation.NSError error);
public virtual VNHumanHandPoseObservationJointsGroupName[] GetSupportedJointsGroupNames (out Foundation.NSError error);
```


#### Type Changed: Vision.VNErrorCode

Added values:

```csharp
UnsupportedComputeDevice = 22,
UnsupportedComputeStage = 21,
```


#### Type Changed: Vision.VNGenerateAttentionBasedSaliencyImageRequestRevision

Added value:

```csharp
Two = 2,
```


#### Type Changed: Vision.VNGenerateImageFeaturePrintRequestRevision

Added value:

```csharp
Two = 2,
```


#### Type Changed: Vision.VNGenerateObjectnessBasedSaliencyImageRequestRevision

Added value:

```csharp
Two = 2,
```


#### Type Changed: Vision.VNImageRequestHandler

Added constructors:

```csharp
public VNImageRequestHandler (CoreMedia.CMSampleBuffer sampleBuffer, AVFoundation.AVDepthData depthData, ImageIO.CGImagePropertyOrientation orientation, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> options);
public VNImageRequestHandler (CoreVideo.CVPixelBuffer pixelBuffer, AVFoundation.AVDepthData depthData, ImageIO.CGImagePropertyOrientation orientation, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> options);
```


#### Type Changed: Vision.VNRectangleObservation

Added method:

```csharp
public static VNRectangleObservation FromRectangleObservation (VNRectangleObservationRequestRevision requestRevision, CoreGraphics.CGPoint topLeft, CoreGraphics.CGPoint topRight, CoreGraphics.CGPoint bottomRight, CoreGraphics.CGPoint bottomLeft);
```


#### Type Changed: Vision.VNRequest

Added methods:

```csharp
public virtual CoreML.IMLComputeDeviceProtocol GetComputeDevice (string computeStage);
public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSArray<CoreML.IMLComputeDeviceProtocol>> GetSupportedComputeDevices (out Foundation.NSError error);
public virtual void SetComputeDevice (CoreML.IMLComputeDeviceProtocol computeDevice, string computeStage);
```


#### Type Changed: Vision.VNTrackingRequest

Added method:

```csharp
public virtual UIntPtr GetSupportedNumberOfTrackers (out Foundation.NSError error);
```


#### New Type: Vision.VNAnimalBodyPoseObservation

```csharp
public class VNAnimalBodyPoseObservation : Vision.VNRecognizedPointsObservation {
	// constructors
	public VNAnimalBodyPoseObservation (Foundation.NSCoder coder);
	protected VNAnimalBodyPoseObservation (Foundation.NSObjectFlag t);
	protected VNAnimalBodyPoseObservation (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual VNAnimalBodyPoseObservationJointsGroupName[] AvailableJointGroupNames { get; }
	public virtual VNAnimalBodyPoseObservationJointName[] AvailableJointNames { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual VNRecognizedPoint GetRecognizedPoint (VNAnimalBodyPoseObservationJointName jointName, out Foundation.NSError error);
	public virtual Foundation.NSDictionary<Foundation.NSString,Vision.VNRecognizedPoint> GetRecognizedPoints (VNAnimalBodyPoseObservationJointsGroupName jointsGroupName, out Foundation.NSError error);
}
```

#### New Type: Vision.VNAnimalBodyPoseObservationJointName

```csharp
[Serializable]
public enum VNAnimalBodyPoseObservationJointName {
	LeftBackElbow = 17,
	LeftBackKnee = 19,
	LeftBackPaw = 21,
	LeftEarBottom = 5,
	LeftEarMiddle = 3,
	LeftEarTop = 1,
	LeftEye = 7,
	LeftFrontElbow = 11,
	LeftFrontKnee = 13,
	LeftFrontPaw = 15,
	Neck = 10,
	None = 0,
	Nose = 9,
	RightBackElbow = 18,
	RightBackKnee = 20,
	RightBackPaw = 22,
	RightEarBottom = 6,
	RightEarMiddle = 4,
	RightEarTop = 2,
	RightEye = 8,
	RightFrontElbow = 12,
	RightFrontKnee = 14,
	RightFrontPaw = 16,
	TailBottom = 25,
	TailMiddle = 24,
	TailTop = 23,
}
```

#### New Type: Vision.VNAnimalBodyPoseObservationJointNameExtensions

```csharp
public static class VNAnimalBodyPoseObservationJointNameExtensions {
	// methods
	public static Foundation.NSString GetConstant (this VNAnimalBodyPoseObservationJointName self);
	public static VNAnimalBodyPoseObservationJointName GetValue (Foundation.NSString constant);
}
```

#### New Type: Vision.VNAnimalBodyPoseObservationJointsGroupName

```csharp
[Serializable]
public enum VNAnimalBodyPoseObservationJointsGroupName {
	All = 6,
	Forelegs = 3,
	Head = 1,
	Hindlegs = 4,
	None = 0,
	Tail = 5,
	Trunk = 2,
}
```

#### New Type: Vision.VNAnimalBodyPoseObservationJointsGroupNameExtensions

```csharp
public static class VNAnimalBodyPoseObservationJointsGroupNameExtensions {
	// methods
	public static Foundation.NSString GetConstant (this VNAnimalBodyPoseObservationJointsGroupName self);
	public static VNAnimalBodyPoseObservationJointsGroupName GetValue (Foundation.NSString constant);
}
```

#### New Type: Vision.VNBarcodeCompositeType

```csharp
[Serializable]
public enum VNBarcodeCompositeType {
	Gs1TypeA = 2,
	Gs1TypeB = 3,
	Gs1TypeC = 4,
	Linked = 1,
	None = 0,
}
```

#### New Type: Vision.VNComputeStage

```csharp
[Serializable]
public enum VNComputeStage {
	Main = 1,
	None = 0,
	PostProcessing = 2,
}
```

#### New Type: Vision.VNComputeStageExtensions

```csharp
public static class VNComputeStageExtensions {
	// methods
	public static Foundation.NSString GetConstant (this VNComputeStage self);
	public static VNComputeStage GetValue (Foundation.NSString constant);
}
```

#### New Type: Vision.VNDetectAnimalBodyPoseRequest

```csharp
public class VNDetectAnimalBodyPoseRequest : Vision.VNImageBasedRequest {
	// constructors
	protected VNDetectAnimalBodyPoseRequest (Foundation.NSObjectFlag t);
	protected VNDetectAnimalBodyPoseRequest (ObjCRuntime.NativeHandle handle);
	public VNDetectAnimalBodyPoseRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual VNAnimalBodyPoseObservation[] Results { get; }
	// methods
	public virtual VNAnimalBodyPoseObservationJointName[] GetSupportedJointNames (out Foundation.NSError error);
	public virtual VNAnimalBodyPoseObservationJointsGroupName[] GetSupportedJointsGroupNames (out Foundation.NSError error);
}
```

#### New Type: Vision.VNDetectHumanBodyPose3DRequest

```csharp
public class VNDetectHumanBodyPose3DRequest : Vision.VNStatefulRequest {
	// constructors
	public VNDetectHumanBodyPose3DRequest ();
	protected VNDetectHumanBodyPose3DRequest (Foundation.NSObjectFlag t);
	protected VNDetectHumanBodyPose3DRequest (ObjCRuntime.NativeHandle handle);
	public VNDetectHumanBodyPose3DRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static VNDetectHumanBodyPose3DRequestRevision CurrentRevision { get; }
	public static VNDetectHumanBodyPose3DRequestRevision DefaultRevision { get; }
	public virtual VNHumanBodyPose3DObservation[] Results { get; }
	public virtual VNDetectHumanBodyPose3DRequestRevision Revision { get; set; }
	public static VNDetectHumanBodyPose3DRequestRevision[] SupportedRevisions { get; }
	public static Foundation.NSIndexSet WeakSupportedRevisions { get; }
	// methods
	public virtual VNHumanBodyPose3DObservationJointName[] GetSupportedJointNames (out Foundation.NSError error);
	public virtual VNHumanBodyPose3DObservationJointsGroupName[] GetSupportedJointsGroupNames (out Foundation.NSError error);
}
```

#### New Type: Vision.VNDetectHumanBodyPose3DRequestRevision

```csharp
[Serializable]
public enum VNDetectHumanBodyPose3DRequestRevision {
	One = 1,
}
```

#### New Type: Vision.VNGenerateForegroundInstanceMaskRequest

```csharp
public class VNGenerateForegroundInstanceMaskRequest : Vision.VNImageBasedRequest {
	// constructors
	protected VNGenerateForegroundInstanceMaskRequest (Foundation.NSObjectFlag t);
	protected VNGenerateForegroundInstanceMaskRequest (ObjCRuntime.NativeHandle handle);
	public VNGenerateForegroundInstanceMaskRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual VNInstanceMaskObservation[] Results { get; }
}
```

#### New Type: Vision.VNGeneratePersonInstanceMaskRequest

```csharp
public class VNGeneratePersonInstanceMaskRequest : Vision.VNImageBasedRequest {
	// constructors
	protected VNGeneratePersonInstanceMaskRequest (Foundation.NSObjectFlag t);
	protected VNGeneratePersonInstanceMaskRequest (ObjCRuntime.NativeHandle handle);
	public VNGeneratePersonInstanceMaskRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual VNInstanceMaskObservation[] Results { get; }
}
```

#### New Type: Vision.VNHumanBodyPose3DObservation

```csharp
public class VNHumanBodyPose3DObservation : Vision.VNRecognizedPoints3DObservation {
	// constructors
	public VNHumanBodyPose3DObservation (Foundation.NSCoder coder);
	protected VNHumanBodyPose3DObservation (Foundation.NSObjectFlag t);
	protected VNHumanBodyPose3DObservation (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual VNHumanBodyPose3DObservationJointName[] AvailableJointNames { get; }
	public virtual VNHumanBodyPose3DObservationJointsGroupName[] AvailableJointsGroupNames { get; }
	public virtual float BodyHeight { get; }
	public virtual CoreGraphics.NMatrix4 CameraOriginMatrix { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual VNHumanBodyPose3DObservationHeightEstimation HeightEstimation { get; }
	// methods
	public virtual bool GetCameraRelativePosition (out CoreGraphics.NMatrix4 modelPositionOut, VNHumanBodyPose3DObservationJointName jointName, out Foundation.NSError error);
	public virtual VNHumanBodyPose3DObservationJointName GetParentJointName (VNHumanBodyPose3DObservationJointName jointName);
	public virtual VNPoint GetPointInImage (VNHumanBodyPose3DObservationJointName jointName, out Foundation.NSError error);
	public virtual VNHumanBodyRecognizedPoint3D GetRecognizedPoint (VNHumanBodyPose3DObservationJointName jointName, out Foundation.NSError error);
	public virtual Foundation.NSDictionary<Foundation.NSString,Vision.VNHumanBodyRecognizedPoint3D> GetRecognizedPoints (VNHumanBodyPose3DObservationJointsGroupName jointName, out Foundation.NSError error);
}
```

#### New Type: Vision.VNHumanBodyPose3DObservationHeightEstimation

```csharp
[Serializable]
public enum VNHumanBodyPose3DObservationHeightEstimation {
	Measured = 1,
	Reference = 0,
}
```

#### New Type: Vision.VNHumanBodyPose3DObservationJointName

```csharp
[Serializable]
public enum VNHumanBodyPose3DObservationJointName {
	CenterHead = 11,
	CenterShoulder = 10,
	LeftAnkle = 8,
	LeftElbow = 14,
	LeftHip = 6,
	LeftKnee = 7,
	LeftShoulder = 13,
	LeftWrist = 15,
	None = 0,
	RightAnkle = 4,
	RightElbow = 16,
	RightHip = 2,
	RightKnee = 3,
	RightShoulder = 5,
	RightWrist = 17,
	Root = 1,
	Spine = 9,
	TopHead = 12,
}
```

#### New Type: Vision.VNHumanBodyPose3DObservationJointNameExtensions

```csharp
public static class VNHumanBodyPose3DObservationJointNameExtensions {
	// methods
	public static Foundation.NSString GetConstant (this VNHumanBodyPose3DObservationJointName self);
	public static VNHumanBodyPose3DObservationJointName GetValue (Foundation.NSString constant);
}
```

#### New Type: Vision.VNHumanBodyPose3DObservationJointsGroupName

```csharp
[Serializable]
public enum VNHumanBodyPose3DObservationJointsGroupName {
	All = 7,
	Head = 1,
	LeftArm = 3,
	LeftLeg = 5,
	None = 0,
	RightArm = 4,
	RightLeg = 6,
	Torso = 2,
}
```

#### New Type: Vision.VNHumanBodyPose3DObservationJointsGroupNameExtensions

```csharp
public static class VNHumanBodyPose3DObservationJointsGroupNameExtensions {
	// methods
	public static Foundation.NSString GetConstant (this VNHumanBodyPose3DObservationJointsGroupName self);
	public static VNHumanBodyPose3DObservationJointsGroupName GetValue (Foundation.NSString constant);
}
```

#### New Type: Vision.VNHumanBodyRecognizedPoint3D

```csharp
public class VNHumanBodyRecognizedPoint3D : Vision.VNRecognizedPoint3D {
	// constructors
	public VNHumanBodyRecognizedPoint3D (CoreGraphics.NMatrix4 position);
	public VNHumanBodyRecognizedPoint3D (Foundation.NSCoder coder);
	protected VNHumanBodyRecognizedPoint3D (Foundation.NSObjectFlag t);
	protected VNHumanBodyRecognizedPoint3D (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreGraphics.NMatrix4 LocalPosition { get; }
	public virtual VNHumanBodyPose3DObservationJointName ParentJoint { get; }
}
```

#### New Type: Vision.VNInstanceMaskObservation

```csharp
public class VNInstanceMaskObservation : Vision.VNObservation {
	// constructors
	public VNInstanceMaskObservation (Foundation.NSCoder coder);
	protected VNInstanceMaskObservation (Foundation.NSObjectFlag t);
	protected VNInstanceMaskObservation (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSIndexSet AllInstances { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreVideo.CVPixelBuffer InstanceMask { get; }
	// methods
	public virtual CoreVideo.CVPixelBuffer GenerateMask (Foundation.NSIndexSet instances, out Foundation.NSError error);
	public virtual CoreVideo.CVPixelBuffer GenerateMaskedImage (Foundation.NSIndexSet instances, VNImageRequestHandler requestHandler, bool cropResult, out Foundation.NSError error);
	public virtual CoreVideo.CVPixelBuffer GenerateScaledMask (Foundation.NSIndexSet instances, VNImageRequestHandler requestHandler, out Foundation.NSError error);
}
```

#### New Type: Vision.VNPoint3D

```csharp
public class VNPoint3D : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public VNPoint3D (CoreGraphics.NMatrix4 position);
	public VNPoint3D (Foundation.NSCoder coder);
	protected VNPoint3D (Foundation.NSObjectFlag t);
	protected VNPoint3D (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreGraphics.NMatrix4 Position { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}
```

#### New Type: Vision.VNRecognizedPoint3D

```csharp
public class VNRecognizedPoint3D : Vision.VNPoint3D {
	// constructors
	public VNRecognizedPoint3D (CoreGraphics.NMatrix4 position);
	public VNRecognizedPoint3D (Foundation.NSCoder coder);
	protected VNRecognizedPoint3D (Foundation.NSObjectFlag t);
	protected VNRecognizedPoint3D (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static Foundation.NSString GroupKeyAll { get; }
	public virtual string Identifier { get; }
}
```

#### New Type: Vision.VNRecognizedPoints3DObservation

```csharp
public class VNRecognizedPoints3DObservation : Vision.VNObservation {
	// constructors
	public VNRecognizedPoints3DObservation (Foundation.NSCoder coder);
	protected VNRecognizedPoints3DObservation (Foundation.NSObjectFlag t);
	protected VNRecognizedPoints3DObservation (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSString[] AvailableGroupKeys { get; }
	public virtual Foundation.NSString[] AvailableKeys { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual VNRecognizedPoint3D GetRecognizedPoint (Foundation.NSString pointKey, out Foundation.NSError error);
	public virtual Foundation.NSDictionary<Foundation.NSString,Vision.VNRecognizedPoint3D> GetRecognizedPoints (Foundation.NSString groupKey, out Foundation.NSError error);
}
```

#### New Type: Vision.VNTrackHomographicImageRegistrationRequest

```csharp
public class VNTrackHomographicImageRegistrationRequest : Vision.VNStatefulRequest {
	// constructors
	public VNTrackHomographicImageRegistrationRequest ();
	protected VNTrackHomographicImageRegistrationRequest (Foundation.NSObjectFlag t);
	protected VNTrackHomographicImageRegistrationRequest (ObjCRuntime.NativeHandle handle);
	public VNTrackHomographicImageRegistrationRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static VNTrackHomographicImageRegistrationRequestRevision CurrentRevision { get; }
	public static VNTrackHomographicImageRegistrationRequestRevision DefaultRevision { get; }
	public virtual VNImageHomographicAlignmentObservation[] Results { get; }
	public virtual VNTrackHomographicImageRegistrationRequestRevision Revision { get; set; }
	public static VNTrackHomographicImageRegistrationRequestRevision[] SupportedRevisions { get; }
	public static Foundation.NSIndexSet WeakSupportedRevisions { get; }
}
```

#### New Type: Vision.VNTrackHomographicImageRegistrationRequestRevision

```csharp
[Serializable]
public enum VNTrackHomographicImageRegistrationRequestRevision {
	One = 1,
}
```

#### New Type: Vision.VNTrackOpticalFlowRequest

```csharp
public class VNTrackOpticalFlowRequest : Vision.VNStatefulRequest {
	// constructors
	public VNTrackOpticalFlowRequest ();
	protected VNTrackOpticalFlowRequest (Foundation.NSObjectFlag t);
	protected VNTrackOpticalFlowRequest (ObjCRuntime.NativeHandle handle);
	public VNTrackOpticalFlowRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual VNTrackOpticalFlowRequestComputationAccuracy ComputationAccuracy { get; set; }
	public virtual bool KeepNetworkOutput { get; set; }
	public virtual uint OutputPixelFormat { get; set; }
	public virtual VNPixelBufferObservation[] Results { get; }
}
```

#### New Type: Vision.VNTrackOpticalFlowRequestComputationAccuracy

```csharp
[Serializable]
public enum VNTrackOpticalFlowRequestComputationAccuracy {
	High = 2,
	Low = 0,
	Medium = 1,
	VeryHigh = 3,
}
```

#### New Type: Vision.VNTrackOpticalFlowRequestRevision

```csharp
[Serializable]
public enum VNTrackOpticalFlowRequestRevision {
	One = 1,
}
```

#### New Type: Vision.VNTrackTranslationalImageRegistrationRequest

```csharp
public class VNTrackTranslationalImageRegistrationRequest : Vision.VNStatefulRequest {
	// constructors
	public VNTrackTranslationalImageRegistrationRequest ();
	protected VNTrackTranslationalImageRegistrationRequest (Foundation.NSObjectFlag t);
	protected VNTrackTranslationalImageRegistrationRequest (ObjCRuntime.NativeHandle handle);
	public VNTrackTranslationalImageRegistrationRequest (VNRequestCompletionHandler completionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static VNTrackTranslationalImageRegistrationRequestRevision CurrentRevision { get; }
	public static VNTrackTranslationalImageRegistrationRequestRevision DefaultRevision { get; }
	public virtual VNImageTranslationAlignmentObservation[] Results { get; }
	public virtual VNTrackTranslationalImageRegistrationRequestRevision Revision { get; set; }
	public static VNTrackTranslationalImageRegistrationRequestRevision[] SupportedRevisions { get; }
	public static Foundation.NSIndexSet WeakSupportedRevisions { get; }
}
```

#### New Type: Vision.VNTrackTranslationalImageRegistrationRequestRevision

```csharp
[Serializable]
public enum VNTrackTranslationalImageRegistrationRequestRevision {
	One = 1,
}
```


### Namespace WebKit

#### Type Changed: WebKit.WKHttpCookieStore

Added methods:

```csharp
public virtual void GetCookiePolicy (System.Action<WKCookiePolicy> completionHandler);
public virtual System.Threading.Tasks.Task<WKCookiePolicy> GetCookiePolicyAsync ();
public virtual void SetCookiePolicy (WKCookiePolicy policy, System.Action completionHandler);
public virtual System.Threading.Tasks.Task SetCookiePolicyAsync (WKCookiePolicy policy);
```


#### Type Changed: WebKit.WKPdfConfiguration

Added property:

```csharp
public virtual bool AllowTransparentBackground { get; set; }
```


#### Type Changed: WebKit.WKPreferences

Added property:

```csharp
public virtual WKInactiveSchedulingPolicy InactiveSchedulingPolicy { get; set; }
```


#### Type Changed: WebKit.WKWebViewConfiguration

Added property:

```csharp
public virtual bool AllowsInlinePredictions { get; set; }
```


#### Type Changed: WebKit.WKWebsiteDataStore

Added property:

```csharp
public virtual Foundation.NSUuid Identifier { get; }
```

Added methods:

```csharp
public static WKWebsiteDataStore Create (Foundation.NSUuid identifier);
public static void FetchAllDataStoreIdentifiers (System.Action<Foundation.NSArray<Foundation.NSUuid>> completionHandler);
public static System.Threading.Tasks.Task<Foundation.NSArray<Foundation.NSUuid>> FetchAllDataStoreIdentifiersAsync ();
public static void Remove (Foundation.NSUuid identifier, System.Action<Foundation.NSError> completionHandler);
public static System.Threading.Tasks.Task RemoveAsync (Foundation.NSUuid identifier);
```


#### Type Changed: WebKit.WKWebsiteDataType

Added properties:

```csharp
public static Foundation.NSString HashSalt { get; }
public static Foundation.NSString MediaKeys { get; }
public static Foundation.NSString SearchFieldRecentSearches { get; }
```


#### New Type: WebKit.WKCookiePolicy

```csharp
[Serializable]
public enum WKCookiePolicy {
	Allow = 0,
	Disallow = 1,
}
```

#### New Type: WebKit.WKInactiveSchedulingPolicy

```csharp
[Serializable]
public enum WKInactiveSchedulingPolicy {
	None = 2,
	Suspend = 0,
	Throttle = 1,
}
```


### New Namespace CryptoTokenKit

#### New Type: CryptoTokenKit.ITKSmartCardTokenDriverDelegate

```csharp
public interface ITKSmartCardTokenDriverDelegate : ITKTokenDriverDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public abstract TKSmartCardToken CreateToken (TKSmartCardTokenDriver driver, TKSmartCard smartCard, Foundation.NSData aid, out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.ITKSmartCardUserInteractionDelegate

```csharp
public interface ITKSmartCardUserInteractionDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}
```

#### New Type: CryptoTokenKit.ITKTokenDelegate

```csharp
public interface ITKTokenDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public abstract TKTokenSession CreateSession (TKToken token, out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.ITKTokenDriverDelegate

```csharp
public interface ITKTokenDriverDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}
```

#### New Type: CryptoTokenKit.ITKTokenSessionDelegate

```csharp
public interface ITKTokenSessionDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}
```

#### New Type: CryptoTokenKit.TKBerTlvRecord

```csharp
public class TKBerTlvRecord : CryptoTokenKit.TKTlvRecord {
	// constructors
	public TKBerTlvRecord ();
	protected TKBerTlvRecord (Foundation.NSObjectFlag t);
	protected TKBerTlvRecord (ObjCRuntime.NativeHandle handle);
	public TKBerTlvRecord (ulong tag, TKTlvRecord[] records);
	public TKBerTlvRecord (ulong tag, Foundation.NSData value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public static Foundation.NSData GetData (ulong tag);
}
```

#### New Type: CryptoTokenKit.TKCompactTlvRecord

```csharp
public class TKCompactTlvRecord : CryptoTokenKit.TKTlvRecord {
	// constructors
	public TKCompactTlvRecord ();
	protected TKCompactTlvRecord (Foundation.NSObjectFlag t);
	protected TKCompactTlvRecord (ObjCRuntime.NativeHandle handle);
	public TKCompactTlvRecord (byte tag, Foundation.NSData value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: CryptoTokenKit.TKErrorCode

```csharp
[Serializable]
public enum TKErrorCode {
	AuthenticationFailed = -5,
	AuthenticationNeeded = -9,
	BadParameter = -8,
	CanceledByUser = -4,
	CommunicationError = -2,
	CorruptedData = -3,
	NotImplemented = -1,
	ObjectNotFound = -6,
	TokenNotFound = -7,
}
```

#### New Type: CryptoTokenKit.TKErrorCodeExtensions

```csharp
public static class TKErrorCodeExtensions {
	// methods
	public static Foundation.NSString GetDomain (this TKErrorCode self);
}
```

#### New Type: CryptoTokenKit.TKGetSlotCallback

```csharp
public sealed delegate TKGetSlotCallback : System.MulticastDelegate {
	// constructors
	public TKGetSlotCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (TKSmartCardSlot slot, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (TKSmartCardSlot slot);
}
```

#### New Type: CryptoTokenKit.TKSimpleTlvRecord

```csharp
public class TKSimpleTlvRecord : CryptoTokenKit.TKTlvRecord {
	// constructors
	public TKSimpleTlvRecord ();
	protected TKSimpleTlvRecord (Foundation.NSObjectFlag t);
	protected TKSimpleTlvRecord (ObjCRuntime.NativeHandle handle);
	public TKSimpleTlvRecord (byte tag, Foundation.NSData value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: CryptoTokenKit.TKSmartCard

```csharp
public class TKSmartCard : Foundation.NSObject {
	// constructors
	public TKSmartCard ();
	protected TKSmartCard (Foundation.NSObjectFlag t);
	protected TKSmartCard (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual TKSmartCardProtocol AllowedProtocols { get; set; }
	public virtual byte Cla { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSObject Context { get; set; }
	public virtual TKSmartCardProtocol CurrentProtocol { get; }
	public virtual bool Sensitive { get; set; }
	public virtual TKSmartCardSlot Slot { get; }
	public virtual bool UseCommandChaining { get; set; }
	public virtual bool UseExtendedLength { get; set; }
	public virtual bool Valid { get; }
	// methods
	public virtual void BeginSession (System.Action<System.Boolean,Foundation.NSError> reply);
	public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> BeginSessionAsync ();
	public virtual TKSmartCardUserInteractionForSecurePinChange CreateUserInteractionForSecurePinChange (TKSmartCardPinFormat pinFormat, Foundation.NSData apdu, IntPtr currentPinByteOffset, IntPtr newPinByteOffset);
	public virtual TKSmartCardUserInteractionForSecurePinVerification CreateUserInteractionForSecurePinVerification (TKSmartCardPinFormat pinFormat, Foundation.NSData apdu, IntPtr pinByteOffset);
	protected override void Dispose (bool disposing);
	public virtual void EndSession ();
	public virtual bool ExecuteBlock (out Foundation.NSError error, TKSmartCardExecuteCallback block);
	public virtual void Send (byte ins, byte p1, byte p2, Foundation.NSData requestData, Foundation.NSNumber le, TKSmartCardSendCallback reply);
	public virtual Foundation.NSData Send (byte ins, byte p1, byte p2, Foundation.NSData requestData, Foundation.NSNumber le, out ushort sw, out Foundation.NSError error);
	public virtual void TransmitRequest (Foundation.NSData request, System.Action<Foundation.NSData,Foundation.NSError> reply);
	public virtual System.Threading.Tasks.Task<Foundation.NSData> TransmitRequestAsync (Foundation.NSData request);
}
```

#### New Type: CryptoTokenKit.TKSmartCardAtr

```csharp
public class TKSmartCardAtr : Foundation.NSObject {
	// constructors
	public TKSmartCardAtr (Foundation.NSData bytes);
	protected TKSmartCardAtr (Foundation.NSObjectFlag t);
	protected TKSmartCardAtr (ObjCRuntime.NativeHandle handle);
	public TKSmartCardAtr (System.Func<int> source);
	// properties
	public virtual Foundation.NSData Bytes { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSData HistoricalBytes { get; }
	public virtual TKCompactTlvRecord[] HistoricalRecords { get; }
	public virtual TKSmartCardProtocol[] Protocols { get; }
	// methods
	public virtual TKSmartCardAtrInterfaceGroup GetInterfaceGroup (TKSmartCardProtocol protocol);
	public virtual TKSmartCardAtrInterfaceGroup GetInterfaceGroup (IntPtr index);
}
```

#### New Type: CryptoTokenKit.TKSmartCardAtrInterfaceGroup

```csharp
public class TKSmartCardAtrInterfaceGroup : Foundation.NSObject {
	// constructors
	public TKSmartCardAtrInterfaceGroup ();
	protected TKSmartCardAtrInterfaceGroup (Foundation.NSObjectFlag t);
	protected TKSmartCardAtrInterfaceGroup (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSNumber Protocol { get; }
	public virtual Foundation.NSNumber TA { get; }
	public virtual Foundation.NSNumber TB { get; }
	public virtual Foundation.NSNumber TC { get; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardExecuteCallback

```csharp
public sealed delegate TKSmartCardExecuteCallback : System.MulticastDelegate {
	// constructors
	public TKSmartCardExecuteCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (out Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual bool EndInvoke (out Foundation.NSError error, System.IAsyncResult result);
	public virtual bool Invoke (out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinCharset

```csharp
[Serializable]
public enum TKSmartCardPinCharset {
	Alphanumeric = 1,
	Numeric = 0,
	UpperAlphanumeric = 2,
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinCompletion

```csharp
[Serializable]
[Flags]
public enum TKSmartCardPinCompletion {
	Key = 2,
	MaxLength = 1,
	Timeout = 4,
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinConfirmation

```csharp
[Serializable]
[Flags]
public enum TKSmartCardPinConfirmation {
	Current = 2,
	New = 1,
	None = 0,
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinEncoding

```csharp
[Serializable]
public enum TKSmartCardPinEncoding {
	Ascii = 1,
	Bcd = 2,
	Binary = 0,
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinFormat

```csharp
public class TKSmartCardPinFormat : Foundation.NSObject {
	// constructors
	public TKSmartCardPinFormat ();
	protected TKSmartCardPinFormat (Foundation.NSObjectFlag t);
	protected TKSmartCardPinFormat (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual TKSmartCardPinCharset Charset { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual TKSmartCardPinEncoding Encoding { get; set; }
	public virtual IntPtr MaxPinLength { get; set; }
	public virtual IntPtr MinPinLength { get; set; }
	public virtual IntPtr PinBitOffset { get; set; }
	public virtual IntPtr PinBlockByteLength { get; set; }
	public virtual TKSmartCardPinJustification PinJustification { get; set; }
	public virtual IntPtr PinLengthBitOffset { get; set; }
	public virtual IntPtr PinLengthBitSize { get; set; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardPinJustification

```csharp
[Serializable]
public enum TKSmartCardPinJustification {
	Left = 0,
	Right = 1,
}
```

#### New Type: CryptoTokenKit.TKSmartCardProtocol

```csharp
[Serializable]
[Flags]
public enum TKSmartCardProtocol {
	Any = 65535,
	None = 0,
	T0 = 1,
	T1 = 2,
	T15 = 32768,
}
```

#### New Type: CryptoTokenKit.TKSmartCardSendCallback

```csharp
public sealed delegate TKSmartCardSendCallback : System.MulticastDelegate {
	// constructors
	public TKSmartCardSendCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSData replyData, ushort sq, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSData replyData, ushort sq, Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.TKSmartCardSlot

```csharp
public class TKSmartCardSlot : Foundation.NSObject {
	// constructors
	public TKSmartCardSlot ();
	protected TKSmartCardSlot (Foundation.NSObjectFlag t);
	protected TKSmartCardSlot (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual TKSmartCardAtr Atr { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IntPtr MaxInputLength { get; }
	public virtual IntPtr MaxOutputLength { get; }
	public virtual string Name { get; }
	public virtual TKSmartCardSlotState State { get; }
	// methods
	public virtual TKSmartCard MakeSmartCard ();
}
```

#### New Type: CryptoTokenKit.TKSmartCardSlotManager

```csharp
public class TKSmartCardSlotManager : Foundation.NSObject {
	// constructors
	protected TKSmartCardSlotManager (Foundation.NSObjectFlag t);
	protected TKSmartCardSlotManager (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static TKSmartCardSlotManager DefaultManager { get; }
	public virtual string[] SlotNames { get; }
	// methods
	public virtual TKSmartCardSlot GetSlot (string name);
	public virtual void GetSlot (string name, TKGetSlotCallback reply);
	public virtual System.Threading.Tasks.Task<TKSmartCardSlot> GetSlotAsync (string name);
}
```

#### New Type: CryptoTokenKit.TKSmartCardSlotState

```csharp
[Serializable]
public enum TKSmartCardSlotState {
	Empty = 1,
	Missing = 0,
	MuteCard = 3,
	Probing = 2,
	ValidCard = 4,
}
```

#### New Type: CryptoTokenKit.TKSmartCardToken

```csharp
public class TKSmartCardToken : CryptoTokenKit.TKToken {
	// constructors
	public TKSmartCardToken ();
	protected TKSmartCardToken (Foundation.NSObjectFlag t);
	protected TKSmartCardToken (ObjCRuntime.NativeHandle handle);
	public TKSmartCardToken (TKSmartCard smartCard, Foundation.NSData aid, string instanceId, TKSmartCardTokenDriver tokenDriver);
	// properties
	public virtual Foundation.NSData Aid { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardTokenDriver

```csharp
public class TKSmartCardTokenDriver : CryptoTokenKit.TKTokenDriver {
	// constructors
	public TKSmartCardTokenDriver ();
	protected TKSmartCardTokenDriver (Foundation.NSObjectFlag t);
	protected TKSmartCardTokenDriver (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardTokenSession

```csharp
public class TKSmartCardTokenSession : CryptoTokenKit.TKTokenSession {
	// constructors
	public TKSmartCardTokenSession ();
	public TKSmartCardTokenSession (TKToken token);
	protected TKSmartCardTokenSession (Foundation.NSObjectFlag t);
	protected TKSmartCardTokenSession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual TKSmartCard SmartCard { get; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardUserInteraction

```csharp
public class TKSmartCardUserInteraction : Foundation.NSObject {
	// constructors
	public TKSmartCardUserInteraction ();
	protected TKSmartCardUserInteraction (Foundation.NSObjectFlag t);
	protected TKSmartCardUserInteraction (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public ITKSmartCardUserInteractionDelegate Delegate { get; set; }
	public virtual double InitialTimeout { get; set; }
	public virtual double InteractionTimeout { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	public virtual bool Cancel ();
	protected override void Dispose (bool disposing);
	public virtual void Run (System.Action<System.Boolean,Foundation.NSError> reply);
	public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> RunAsync ();
}
```

#### New Type: CryptoTokenKit.TKSmartCardUserInteractionDelegate_Extensions

```csharp
public static class TKSmartCardUserInteractionDelegate_Extensions {
	// methods
	public static void CharacterEntered (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void CorrectionKeyPressed (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void InvalidCharacterEntered (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void NewPinConfirmationRequested (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void NewPinRequested (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void OldPinRequested (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
	public static void ValidationKeyPressed (this ITKSmartCardUserInteractionDelegate This, TKSmartCardUserInteraction interaction);
}
```

#### New Type: CryptoTokenKit.TKSmartCardUserInteractionForPinOperation

```csharp
public class TKSmartCardUserInteractionForPinOperation : CryptoTokenKit.TKSmartCardUserInteraction {
	// constructors
	public TKSmartCardUserInteractionForPinOperation ();
	protected TKSmartCardUserInteractionForPinOperation (Foundation.NSObjectFlag t);
	protected TKSmartCardUserInteractionForPinOperation (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSLocale Locale { get; set; }
	public virtual TKSmartCardPinCompletion PinCompletion { get; set; }
	public virtual Foundation.NSNumber[] PinMessageIndices { get; set; }
	public virtual Foundation.NSData ResultData { get; set; }
	public virtual ushort ResultSW { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: CryptoTokenKit.TKSmartCardUserInteractionForSecurePinChange

```csharp
public class TKSmartCardUserInteractionForSecurePinChange : CryptoTokenKit.TKSmartCardUserInteractionForPinOperation {
	// constructors
	public TKSmartCardUserInteractionForSecurePinChange ();
	protected TKSmartCardUserInteractionForSecurePinChange (Foundation.NSObjectFlag t);
	protected TKSmartCardUserInteractionForSecurePinChange (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual TKSmartCardPinConfirmation PinConfirmation { get; set; }
}
```

#### New Type: CryptoTokenKit.TKSmartCardUserInteractionForSecurePinVerification

```csharp
public class TKSmartCardUserInteractionForSecurePinVerification : CryptoTokenKit.TKSmartCardUserInteractionForPinOperation {
	// constructors
	public TKSmartCardUserInteractionForSecurePinVerification ();
	protected TKSmartCardUserInteractionForSecurePinVerification (Foundation.NSObjectFlag t);
	protected TKSmartCardUserInteractionForSecurePinVerification (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: CryptoTokenKit.TKTlvRecord

```csharp
public class TKTlvRecord : Foundation.NSObject {
	// constructors
	protected TKTlvRecord (Foundation.NSObjectFlag t);
	protected TKTlvRecord (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSData Data { get; }
	public virtual ulong Tag { get; }
	public virtual Foundation.NSData Value { get; }
	// methods
	public static TKTlvRecord CreateRecord (Foundation.NSData data);
	public static TKTlvRecord[] CreateSequenceOfRecords (Foundation.NSData data);
}
```

#### New Type: CryptoTokenKit.TKToken

```csharp
public class TKToken : Foundation.NSObject {
	// constructors
	protected TKToken (Foundation.NSObjectFlag t);
	protected TKToken (ObjCRuntime.NativeHandle handle);
	public TKToken (TKTokenDriver tokenDriver, string instanceId);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual TKTokenConfiguration Configuration { get; }
	public ITKTokenDelegate Delegate { get; set; }
	public virtual TKTokenKeychainContents KeychainContents { get; }
	public virtual TKTokenDriver TokenDriver { get; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: CryptoTokenKit.TKTokenAuthOperation

```csharp
public class TKTokenAuthOperation : Foundation.NSObject, Foundation.INSCoding, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public TKTokenAuthOperation ();
	public TKTokenAuthOperation (Foundation.NSCoder coder);
	protected TKTokenAuthOperation (Foundation.NSObjectFlag t);
	protected TKTokenAuthOperation (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual void EncodeTo (Foundation.NSCoder encoder);
	public virtual bool Finish (out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.TKTokenConfiguration

```csharp
public class TKTokenConfiguration : Foundation.NSObject {
	// constructors
	protected TKTokenConfiguration (Foundation.NSObjectFlag t);
	protected TKTokenConfiguration (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSData ConfigurationData { get; set; }
	public virtual string InstanceId { get; }
	public virtual TKTokenKeychainItem[] KeychainItems { get; set; }
	// methods
	public virtual TKTokenKeychainCertificate GetCertificate (Foundation.NSObject objectId, out Foundation.NSError error);
	public virtual TKTokenKeychainKey GetKey (Foundation.NSObject objectId, out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.TKTokenDelegate

```csharp
public abstract class TKTokenDelegate : Foundation.NSObject, ITKTokenDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected TKTokenDelegate ();
	protected TKTokenDelegate (Foundation.NSObjectFlag t);
	protected TKTokenDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual TKTokenSession CreateSession (TKToken token, out Foundation.NSError error);
	public virtual void TerminateSession (TKToken token, TKTokenSession session);
}
```

#### New Type: CryptoTokenKit.TKTokenDelegate_Extensions

```csharp
public static class TKTokenDelegate_Extensions {
	// methods
	public static void TerminateSession (this ITKTokenDelegate This, TKToken token, TKTokenSession session);
}
```

#### New Type: CryptoTokenKit.TKTokenDriver

```csharp
public class TKTokenDriver : Foundation.NSObject {
	// constructors
	public TKTokenDriver ();
	protected TKTokenDriver (Foundation.NSObjectFlag t);
	protected TKTokenDriver (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public ITKTokenDriverDelegate Delegate { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: CryptoTokenKit.TKTokenDriverConfiguration

```csharp
public class TKTokenDriverConfiguration : Foundation.NSObject {
	// constructors
	protected TKTokenDriverConfiguration (Foundation.NSObjectFlag t);
	protected TKTokenDriverConfiguration (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string ClassId { get; }
	public static Foundation.NSDictionary<Foundation.NSString,CryptoTokenKit.TKTokenDriverConfiguration> DriverConfigurations { get; }
	public virtual Foundation.NSDictionary<Foundation.NSString,CryptoTokenKit.TKTokenConfiguration> TokenConfigurations { get; }
	// methods
	public virtual TKTokenConfiguration AddTokenConfiguration (string instanceId);
	public virtual void RemoveTokenConfiguration (string instanceId);
}
```

#### New Type: CryptoTokenKit.TKTokenDriverDelegate

```csharp
public class TKTokenDriverDelegate : Foundation.NSObject, ITKTokenDriverDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public TKTokenDriverDelegate ();
	protected TKTokenDriverDelegate (Foundation.NSObjectFlag t);
	protected TKTokenDriverDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual TKToken GetToken (TKTokenDriver driver, TKTokenConfiguration configuration, out Foundation.NSError error);
	public virtual void TerminateToken (TKTokenDriver driver, TKToken token);
}
```

#### New Type: CryptoTokenKit.TKTokenDriverDelegate_Extensions

```csharp
public static class TKTokenDriverDelegate_Extensions {
	// methods
	public static TKToken GetToken (this ITKTokenDriverDelegate This, TKTokenDriver driver, TKTokenConfiguration configuration, out Foundation.NSError error);
	public static void TerminateToken (this ITKTokenDriverDelegate This, TKTokenDriver driver, TKToken token);
}
```

#### New Type: CryptoTokenKit.TKTokenKeyAlgorithm

```csharp
public class TKTokenKeyAlgorithm : Foundation.NSObject {
	// constructors
	protected TKTokenKeyAlgorithm (Foundation.NSObjectFlag t);
	protected TKTokenKeyAlgorithm (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual bool IsAlgorithm (Security.SecKeyAlgorithm algorithm);
	public virtual bool SupportsAlgorithm (Security.SecKeyAlgorithm algorithm);
}
```

#### New Type: CryptoTokenKit.TKTokenKeyExchangeParameters

```csharp
public class TKTokenKeyExchangeParameters : Foundation.NSObject {
	// constructors
	public TKTokenKeyExchangeParameters ();
	protected TKTokenKeyExchangeParameters (Foundation.NSObjectFlag t);
	protected TKTokenKeyExchangeParameters (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IntPtr RequestedSize { get; }
	public virtual Foundation.NSData SharedInfo { get; }
}
```

#### New Type: CryptoTokenKit.TKTokenKeychainCertificate

```csharp
public class TKTokenKeychainCertificate : CryptoTokenKit.TKTokenKeychainItem {
	// constructors
	public TKTokenKeychainCertificate ();
	protected TKTokenKeychainCertificate (Foundation.NSObjectFlag t);
	protected TKTokenKeychainCertificate (ObjCRuntime.NativeHandle handle);
	public TKTokenKeychainCertificate (Security.SecKeyAlgorithm certificateRef, Foundation.NSObject objectId);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSData Data { get; }
}
```

#### New Type: CryptoTokenKit.TKTokenKeychainContents

```csharp
public class TKTokenKeychainContents : Foundation.NSObject {
	// constructors
	protected TKTokenKeychainContents (Foundation.NSObjectFlag t);
	protected TKTokenKeychainContents (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual TKTokenKeychainItem[] Items { get; }
	// methods
	public virtual void Fill (TKTokenKeychainItem[] items);
	public virtual TKTokenKeychainCertificate GetCertificate (Foundation.NSObject objectId, out Foundation.NSError error);
	public virtual TKTokenKeychainKey GetKey (Foundation.NSObject objectId, out Foundation.NSError error);
}
```

#### New Type: CryptoTokenKit.TKTokenKeychainItem

```csharp
public class TKTokenKeychainItem : Foundation.NSObject {
	// constructors
	public TKTokenKeychainItem (Foundation.NSObject objectId);
	protected TKTokenKeychainItem (Foundation.NSObjectFlag t);
	protected TKTokenKeychainItem (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDictionary<Foundation.NSNumber,Foundation.NSObject> Constraints { get; set; }
	public virtual string Label { get; set; }
	public virtual Foundation.NSObject ObjectId { get; }
}
```

#### New Type: CryptoTokenKit.TKTokenKeychainKey

```csharp
public class TKTokenKeychainKey : CryptoTokenKit.TKTokenKeychainItem {
	// constructors
	public TKTokenKeychainKey ();
	protected TKTokenKeychainKey (Foundation.NSObjectFlag t);
	protected TKTokenKeychainKey (ObjCRuntime.NativeHandle handle);
	public TKTokenKeychainKey (Security.SecCertificate certificate, Foundation.NSObject objectId);
	public TKTokenKeychainKey (IntPtr certificate, Foundation.NSObject objectId);
	// properties
	public virtual Foundation.NSData ApplicationTag { get; set; }
	public virtual bool CanDecrypt { get; set; }
	public virtual bool CanPerformKeyExchange { get; set; }
	public virtual bool CanSign { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IntPtr KeySizeInBits { get; set; }
	public virtual string KeyType { get; set; }
	public virtual Foundation.NSData PublicKeyData { get; set; }
	public virtual Foundation.NSData PublicKeyHash { get; set; }
	public virtual bool SuitableForLogin { get; set; }
}
```

#### New Type: CryptoTokenKit.TKTokenOperation

```csharp
[Serializable]
public enum TKTokenOperation {
	DecryptData = 3,
	None = 0,
	PerformKeyExchange = 4,
	ReadData = 1,
	SignData = 2,
}
```

#### New Type: CryptoTokenKit.TKTokenPasswordAuthOperation

```csharp
public class TKTokenPasswordAuthOperation : CryptoTokenKit.TKTokenAuthOperation {
	// constructors
	public TKTokenPasswordAuthOperation ();
	public TKTokenPasswordAuthOperation (Foundation.NSCoder coder);
	protected TKTokenPasswordAuthOperation (Foundation.NSObjectFlag t);
	protected TKTokenPasswordAuthOperation (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string Password { get; set; }
}
```

#### New Type: CryptoTokenKit.TKTokenSession

```csharp
public class TKTokenSession : Foundation.NSObject {
	// constructors
	public TKTokenSession (TKToken token);
	protected TKTokenSession (Foundation.NSObjectFlag t);
	protected TKTokenSession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public ITKTokenSessionDelegate Delegate { get; set; }
	public virtual TKToken Token { get; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: CryptoTokenKit.TKTokenSessionDelegate

```csharp
public class TKTokenSessionDelegate : Foundation.NSObject, ITKTokenSessionDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public TKTokenSessionDelegate ();
	protected TKTokenSessionDelegate (Foundation.NSObjectFlag t);
	protected TKTokenSessionDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual TKTokenAuthOperation BeginAuthentication (TKTokenSession session, TKTokenOperation operation, Foundation.NSObject constraint, out Foundation.NSError error);
	public virtual Foundation.NSData DecryptData (TKTokenSession session, Foundation.NSData ciphertext, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm, out Foundation.NSError error);
	public virtual Foundation.NSData PerformKeyExchange (TKTokenSession session, Foundation.NSData otherPartyPublicKeyData, Foundation.NSObject objectId, TKTokenKeyAlgorithm algorithm, TKTokenKeyExchangeParameters parameters, out Foundation.NSError error);
	public virtual Foundation.NSData SignData (TKTokenSession session, Foundation.NSData dataToSign, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm, out Foundation.NSError error);
	public virtual bool SupportsOperation (TKTokenSession session, TKTokenOperation operation, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm);
}
```

#### New Type: CryptoTokenKit.TKTokenSessionDelegate_Extensions

```csharp
public static class TKTokenSessionDelegate_Extensions {
	// methods
	public static TKTokenAuthOperation BeginAuthentication (this ITKTokenSessionDelegate This, TKTokenSession session, TKTokenOperation operation, Foundation.NSObject constraint, out Foundation.NSError error);
	public static Foundation.NSData DecryptData (this ITKTokenSessionDelegate This, TKTokenSession session, Foundation.NSData ciphertext, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm, out Foundation.NSError error);
	public static Foundation.NSData PerformKeyExchange (this ITKTokenSessionDelegate This, TKTokenSession session, Foundation.NSData otherPartyPublicKeyData, Foundation.NSObject objectId, TKTokenKeyAlgorithm algorithm, TKTokenKeyExchangeParameters parameters, out Foundation.NSError error);
	public static Foundation.NSData SignData (this ITKTokenSessionDelegate This, TKTokenSession session, Foundation.NSData dataToSign, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm, out Foundation.NSError error);
	public static bool SupportsOperation (this ITKTokenSessionDelegate This, TKTokenSession session, TKTokenOperation operation, Foundation.NSObject keyObjectId, TKTokenKeyAlgorithm algorithm);
}
```

#### New Type: CryptoTokenKit.TKTokenSmartCardPinAuthOperation

```csharp
public class TKTokenSmartCardPinAuthOperation : CryptoTokenKit.TKTokenAuthOperation {
	// constructors
	public TKTokenSmartCardPinAuthOperation ();
	public TKTokenSmartCardPinAuthOperation (Foundation.NSCoder coder);
	protected TKTokenSmartCardPinAuthOperation (Foundation.NSObjectFlag t);
	protected TKTokenSmartCardPinAuthOperation (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSData ApduTemplate { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string Pin { get; set; }
	public virtual IntPtr PinByteOffset { get; set; }
	public virtual TKSmartCardPinFormat PinFormat { get; set; }
	public virtual TKSmartCard SmartCard { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: CryptoTokenKit.TKTokenWatcher

```csharp
public class TKTokenWatcher : Foundation.NSObject {
	// constructors
	public TKTokenWatcher ();
	protected TKTokenWatcher (Foundation.NSObjectFlag t);
	protected TKTokenWatcher (ObjCRuntime.NativeHandle handle);
	public TKTokenWatcher (System.Action<Foundation.NSString> insertionHandler);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string[] TokenIds { get; }
	// methods
	public virtual void AddRemovalHandler (System.Action<Foundation.NSString> removalHandler, string tokenId);
	public virtual TKTokenWatcherTokenInfo GetTokenInfo (string tokenId);
	public virtual void SetInsertionHandler (System.Action<Foundation.NSString> insertionHandler);
}
```

#### New Type: CryptoTokenKit.TKTokenWatcherTokenInfo

```csharp
public class TKTokenWatcherTokenInfo : Foundation.NSObject {
	// constructors
	protected TKTokenWatcherTokenInfo (Foundation.NSObjectFlag t);
	protected TKTokenWatcherTokenInfo (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string DriverName { get; }
	public virtual string SlotName { get; }
	public virtual string TokenId { get; }
}
```

### New Namespace DeviceDiscoveryExtension

#### New Type: DeviceDiscoveryExtension.DDDevice

```csharp
public class DDDevice : Foundation.NSObject {
	// constructors
	protected DDDevice (Foundation.NSObjectFlag t);
	protected DDDevice (ObjCRuntime.NativeHandle handle);
	public DDDevice (string displayName, DDDeviceCategory category, UniformTypeIdentifiers.UTType protocolType, string identifier);
	// properties
	public virtual Foundation.NSUuid BluetoothIdentifier { get; set; }
	public virtual DDDeviceCategory Category { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string DisplayName { get; set; }
	public virtual string Identifier { get; set; }
	public virtual string MediaContentSubtitle { get; set; }
	public virtual string MediaContentTitle { get; set; }
	public virtual DDDeviceMediaPlaybackState MediaPlaybackState { get; set; }
	public Network.NWEndpoint NetworkEndpoint { get; set; }
	public virtual DDDeviceProtocol Protocol { get; set; }
	public virtual UniformTypeIdentifiers.UTType ProtocolType { get; set; }
	public virtual DDDeviceState State { get; set; }
	public virtual bool SupportsGrouping { get; set; }
	public virtual Foundation.NSData TxtRecordData { get; set; }
	public virtual Foundation.NSUrl Url { get; set; }
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceCategory

```csharp
[Serializable]
public enum DDDeviceCategory {
	DesktopComputer = 5,
	HiFiSpeaker = 0,
	HiFiSpeakerMultiple = 1,
	LaptopComputer = 4,
	Tv = 3,
	TvWithMediaBox = 2,
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceEvent

```csharp
public class DDDeviceEvent : Foundation.NSObject {
	// constructors
	protected DDDeviceEvent (Foundation.NSObjectFlag t);
	protected DDDeviceEvent (ObjCRuntime.NativeHandle handle);
	public DDDeviceEvent (DDEventType type, DDDevice device);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual DDDevice Device { get; }
	public virtual DDEventType EventType { get; }
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceMediaPlaybackState

```csharp
[Serializable]
public enum DDDeviceMediaPlaybackState {
	NoContent = 0,
	Paused = 1,
	Playing = 2,
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceProtocol

```csharp
[Serializable]
public enum DDDeviceProtocol {
	Dial = 1,
	Invalid = 0,
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceProtocolStrings

```csharp
public static class DDDeviceProtocolStrings {
	// properties
	public static Foundation.NSString Dial { get; }
	public static Foundation.NSString Invalid { get; }
}
```

#### New Type: DeviceDiscoveryExtension.DDDeviceState

```csharp
[Serializable]
public enum DDDeviceState {
	Activated = 20,
	Activating = 10,
	Authorized = 25,
	Invalid = 0,
	Invalidating = 30,
}
```

#### New Type: DeviceDiscoveryExtension.DDDiscoverySession

```csharp
public class DDDiscoverySession : Foundation.NSObject {
	// constructors
	public DDDiscoverySession ();
	protected DDDiscoverySession (Foundation.NSObjectFlag t);
	protected DDDiscoverySession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual void ReportEvent (DDDeviceEvent inEvent);
}
```

#### New Type: DeviceDiscoveryExtension.DDErrorCode

```csharp
[Serializable]
public enum DDErrorCode {
	BadParameter = 350001,
	Internal = 350004,
	MissingEntitlement = 350005,
	Permission = 350006,
	Success = 0,
	Timeout = 350003,
	Unknown = 350000,
	Unsupported = 350002,
}
```

#### New Type: DeviceDiscoveryExtension.DDErrorCodeExtensions

```csharp
public static class DDErrorCodeExtensions {
	// methods
	public static Foundation.NSString GetDomain (this DDErrorCode self);
}
```

#### New Type: DeviceDiscoveryExtension.DDEventType

```csharp
[Serializable]
public enum DDEventType {
	DeviceChanged = 42,
	DeviceFound = 40,
	DeviceLost = 41,
	Unknown = 0,
}
```

### New Namespace SafetyKit

#### New Type: SafetyKit.ISACrashDetectionDelegate

```csharp
public interface ISACrashDetectionDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}
```

#### New Type: SafetyKit.ISAEmergencyResponseDelegate

```csharp
public interface ISAEmergencyResponseDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}
```

#### New Type: SafetyKit.SAAuthorizationStatus

```csharp
[Serializable]
public enum SAAuthorizationStatus {
	Authorized = 2,
	Denied = 1,
	NotDetermined = 0,
}
```

#### New Type: SafetyKit.SACrashDetectionDelegate

```csharp
public class SACrashDetectionDelegate : Foundation.NSObject, ObjCRuntime.INativeObject, ISACrashDetectionDelegate, System.IDisposable {
	// constructors
	public SACrashDetectionDelegate ();
	protected SACrashDetectionDelegate (Foundation.NSObjectFlag t);
	protected SACrashDetectionDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidDetectEvent (SACrashDetectionManager crashDetectionManager, SACrashDetectionEvent event);
}
```

#### New Type: SafetyKit.SACrashDetectionDelegate_Extensions

```csharp
public static class SACrashDetectionDelegate_Extensions {
	// methods
	public static void DidDetectEvent (this ISACrashDetectionDelegate This, SACrashDetectionManager crashDetectionManager, SACrashDetectionEvent event);
}
```

#### New Type: SafetyKit.SACrashDetectionEvent

```csharp
public class SACrashDetectionEvent : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public SACrashDetectionEvent (Foundation.NSCoder coder);
	protected SACrashDetectionEvent (Foundation.NSObjectFlag t);
	protected SACrashDetectionEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDate Date { get; }
	public virtual CoreLocation.CLLocation Location { get; }
	public virtual SACrashDetectionEventResponse Response { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}
```

#### New Type: SafetyKit.SACrashDetectionEventResponse

```csharp
[Serializable]
public enum SACrashDetectionEventResponse {
	Attempted = 0,
	Disabled = 1,
}
```

#### New Type: SafetyKit.SACrashDetectionManager

```csharp
public class SACrashDetectionManager : Foundation.NSObject {
	// constructors
	public SACrashDetectionManager ();
	protected SACrashDetectionManager (Foundation.NSObjectFlag t);
	protected SACrashDetectionManager (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual SAAuthorizationStatus AuthorizationStatus { get; }
	public static bool Available { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public ISACrashDetectionDelegate Delegate { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
	public virtual void RequestAuthorization (SACrashDetectionManagerRequestAuthorizationCompletionHandler handler);
	public virtual System.Threading.Tasks.Task<SAAuthorizationStatus> RequestAuthorizationAsync ();
}
```

#### New Type: SafetyKit.SACrashDetectionManagerRequestAuthorizationCompletionHandler

```csharp
public sealed delegate SACrashDetectionManagerRequestAuthorizationCompletionHandler : System.MulticastDelegate {
	// constructors
	public SACrashDetectionManagerRequestAuthorizationCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (SAAuthorizationStatus status, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (SAAuthorizationStatus status, Foundation.NSError error);
}
```

#### New Type: SafetyKit.SAEmergencyResponseDelegate

```csharp
public class SAEmergencyResponseDelegate : Foundation.NSObject, ObjCRuntime.INativeObject, ISAEmergencyResponseDelegate, System.IDisposable {
	// constructors
	public SAEmergencyResponseDelegate ();
	protected SAEmergencyResponseDelegate (Foundation.NSObjectFlag t);
	protected SAEmergencyResponseDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidUpdateVoiceCallStatus (SAEmergencyResponseManager emergencyResponseManager, SAEmergencyResponseManagerVoiceCallStatus voiceCallStatus);
}
```

#### New Type: SafetyKit.SAEmergencyResponseDelegate_Extensions

```csharp
public static class SAEmergencyResponseDelegate_Extensions {
	// methods
	public static void DidUpdateVoiceCallStatus (this ISAEmergencyResponseDelegate This, SAEmergencyResponseManager emergencyResponseManager, SAEmergencyResponseManagerVoiceCallStatus voiceCallStatus);
}
```

#### New Type: SafetyKit.SAEmergencyResponseManager

```csharp
public class SAEmergencyResponseManager : Foundation.NSObject {
	// constructors
	public SAEmergencyResponseManager ();
	protected SAEmergencyResponseManager (Foundation.NSObjectFlag t);
	protected SAEmergencyResponseManager (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public ISAEmergencyResponseDelegate Delegate { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	public virtual void DialVoiceCall (string phoneNumber, SAEmergencyResponseManagerDialVoiceCallCompletionHandler handler);
	public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DialVoiceCallAsync (string phoneNumber);
	protected override void Dispose (bool disposing);
}
```

#### New Type: SafetyKit.SAEmergencyResponseManagerDialVoiceCallCompletionHandler

```csharp
public sealed delegate SAEmergencyResponseManagerDialVoiceCallCompletionHandler : System.MulticastDelegate {
	// constructors
	public SAEmergencyResponseManagerDialVoiceCallCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (bool requestAccepted, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (bool requestAccepted, Foundation.NSError error);
}
```

#### New Type: SafetyKit.SAEmergencyResponseManagerVoiceCallStatus

```csharp
[Serializable]
public enum SAEmergencyResponseManagerVoiceCallStatus {
	Active = 1,
	Dialing = 0,
	Disconnected = 2,
	Failed = 3,
}
```

#### New Type: SafetyKit.SAErrorCode

```csharp
[Serializable]
public enum SAErrorCode {
	InvalidArgument = 3,
	NotAllowed = 2,
	NotAuthorized = 1,
	OperationFailed = 4,
}
```

#### New Type: SafetyKit.SAErrorCodeExtensions

```csharp
public static class SAErrorCodeExtensions {
	// methods
	public static Foundation.NSString GetDomain (this SAErrorCode self);
}
```