# API diff: Microsoft.tvOS.dll

## Microsoft.tvOS.dll

### Namespace AVFoundation

#### Type Changed: AVFoundation.AVAssetExportSession

Added property:

```csharp
public virtual AVAssetTrackGroupOutputHandling AudioTrackGroupHandling { get; set; }
```


#### Type Changed: AVFoundation.AVAssetImageGenerator

Added properties:

```csharp
public virtual AVAssetImageGeneratorDynamicRangePolicy DynamicRangePolicy { get; set; }
public Foundation.NSString WeakDynamicRangePolicy { get; set; }
```


#### Type Changed: AVFoundation.AVAssetResourceLoader

Added property:

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


#### Type Changed: AVFoundation.AVAssetResourceLoadingContentInformationRequest

Added property:

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


#### Type Changed: AVFoundation.AVAssetTrack

Added property:

```csharp
public virtual bool CanProvideSampleCursors { get; }
```

Added methods:

```csharp
public virtual AVSampleCursor MakeSampleCursor (CoreMedia.CMTime presentationTimeStamp);
public virtual AVSampleCursor MakeSampleCursorAtFirstSampleInDecodeOrder ();
public virtual AVSampleCursor MakeSampleCursorAtLastSampleInDecodeOrder ();
```


#### Type Changed: AVFoundation.AVAssetVariantAudioRenditionSpecificAttributes

Added properties:

```csharp
public virtual bool Binaural { get; }
public virtual bool Downmix { get; }
public virtual bool Immersive { get; }
```


#### Type Changed: AVFoundation.AVAssetVariantQualifier

Added methods:

```csharp
public static Foundation.NSPredicate GetPredicateForAudioSampleRate (double sampleRate, AVMediaSelectionOption mediaSelectionOption, Foundation.NSPredicateOperatorType operatorType);
public static Foundation.NSPredicate GetPredicateForBinauralAudio (bool isBinauralAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForDownmixAudio (bool isDownmixAudio, AVMediaSelectionOption mediaSelectionOption);
public static Foundation.NSPredicate GetPredicateForImmersiveAudio (bool isImmersiveAudio, AVMediaSelectionOption mediaSelectionOption);
```


#### Type Changed: AVFoundation.AVAssetVariantVideoAttributes

Added property:

```csharp
public virtual AVAssetVariantVideoLayoutAttributes[] VideoLayoutAttributes { get; }
```


#### Type Changed: AVFoundation.AVAssetWriter

Added property:

```csharp
public virtual CoreMedia.CMTime InitialMovieFragmentInterval { get; set; }
```


#### Type Changed: AVFoundation.AVAudioApplication

Added properties:

```csharp
public static Foundation.NSString InputMuteStateChangeNotification { get; }
public static Foundation.NSString MuteStateKey { get; }
```


#### Type Changed: AVFoundation.AVAudioInputNode

Added method:

```csharp
public virtual bool SetMutedSpeechActivityEventListener (AVAudioInputNodeMutedSpeechEventListener listenerAction);
```


#### Type Changed: AVFoundation.AVAudioPlayer

Obsoleted constructors:

```diff
 [Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
 public AVAudioPlayer (Foundation.NSData data, string fileTypeHint, out Foundation.NSError outError);
 [Obsolete ("Use the 'FromUrl' method instead, because a constructor can't fail.")]
 public AVAudioPlayer (Foundation.NSUrl url, string fileTypeHint, out Foundation.NSError outError);
```

Added methods:

```csharp
public static AVAudioPlayer FromData (Foundation.NSData data, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromData (Foundation.NSData data, Foundation.NSString fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, AVFileTypes fileTypeHint, out Foundation.NSError error);
public static AVAudioPlayer FromUrl (Foundation.NSUrl url, Foundation.NSString fileTypeHint, out Foundation.NSError error);
```


#### Type Changed: AVFoundation.AVAudioSequencer

Added methods:

```csharp
public virtual AVMusicTrack CreateAndAppendTrack ();
public virtual bool RemoveTrack (AVMusicTrack track);
public virtual void ReverseEvents ();
public virtual void SetUserCallback (AVAudioSequencerUserCallback userCallback);
```


#### Type Changed: AVFoundation.AVAudioSession

Added properties:

```csharp
public static Foundation.NSString PortContinuityMicrophone { get; }
public virtual bool PrefersInterruptionOnRouteDisconnect { get; }
```

Added method:

```csharp
public virtual bool SetPrefersInterruptionOnRouteDisconnect (bool value, out Foundation.NSError outError);
```


#### Type Changed: AVFoundation.AVAudioSessionRouteSharingPolicy

Added value:

```csharp
LongFormAudio = 1,
```


#### Type Changed: AVFoundation.AVAudioUnitComponent

Added properties:

```csharp
public virtual UIKit.UIImage Icon { get; }
public virtual bool PassesAUVal { get; }
```


#### Type Changed: AVFoundation.AVCaptureConnection

Modified properties:

```diff
-public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; set; }
+public virtual System.Runtime.InteropServices.NFloat VideoRotationAngle { get; }
```


#### Type Changed: AVFoundation.AVCaptureDeviceType

Added values:

```csharp
ContinuityCamera = 13,
DeskViewCamera = 14,
Microphone = 12,
```


#### Type Changed: AVFoundation.AVCaptureSession

Added properties:

```csharp
public virtual bool ConfiguresApplicationAudioSessionToMixWithOthers { get; set; }
public virtual AVCaptureConnection[] Connections { get; }
public virtual AVCaptureControl[] Controls { get; }
public IAVCaptureSessionControlsDelegate ControlsDelegate { get; }
public virtual CoreFoundation.DispatchQueue ControlsDelegateCallbackQueue { get; }
public virtual float HardwareCost { get; }
public virtual IntPtr MaxControlsCount { get; }
public virtual bool MultitaskingCameraAccessEnabled { get; set; }
public virtual bool MultitaskingCameraAccessSupported { get; }
public virtual bool SupportsControls { get; }
public virtual Foundation.NSObject WeakControlsDelegate { get; }
```

Added methods:

```csharp
public virtual void AddControl (AVCaptureControl control);
public virtual bool CanAddControl (AVCaptureControl control);
public virtual void RemoveControl (AVCaptureControl control);
public virtual void SetControlsDelegate (IAVCaptureSessionControlsDelegate controlsDelegate, CoreFoundation.DispatchQueue controlsDelegateCallbackQueue);
```


#### Type Changed: AVFoundation.AVCaptureVideoPreviewLayer

Added property:

```csharp
public virtual bool Previewing { get; }
```


#### Type Changed: AVFoundation.AVComposition

Added methods:

```csharp
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (string[] bestMatchingPreferredLanguages);
public virtual AVTimedMetadataGroup[] GetChapterMetadataGroups (Foundation.NSLocale titleLocale, string[] commonKeys);
public virtual AVMediaSelectionGroup GetMediaSelectionGroup (string mediaCharacteristic);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual int GetUnusedTrackId ();
```


#### Type Changed: AVFoundation.AVCompositionTrack

Added methods:

```csharp
public virtual AVAssetTrack[] GetAssociatedTracks (string trackAssociationType);
public virtual AVMetadataItem[] GetMetadata (string format);
public virtual CoreMedia.CMTime GetSamplePresentationTime (CoreMedia.CMTime trackTime);
public virtual bool HasMediaCharacteristic (string mediaCharacteristic);
```


#### Type Changed: AVFoundation.AVContentKey

Added property:

```csharp
public virtual AVExternalContentProtectionStatus ExternalContentProtectionStatus { get; }
```

Added method:

```csharp
public virtual void Revoke ();
```


#### Type Changed: AVFoundation.AVContentKeyRequest

Added method:

```csharp
public virtual bool RespondByRequestingPersistableContentKeyRequest (out Foundation.NSError error);
```


#### Type Changed: AVFoundation.AVContentKeySession

Added methods:

```csharp
public virtual void InvalidateAllPersistableContentKeys (Foundation.NSData appIdentifier, Foundation.NSDictionary options, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> InvalidateAllPersistableContentKeysAsync (Foundation.NSData appIdentifier, Foundation.NSDictionary options);
public virtual void InvalidatePersistableContentKey (Foundation.NSData persistableContentKeyData, Foundation.NSDictionary options, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> InvalidatePersistableContentKeyAsync (Foundation.NSData persistableContentKeyData, Foundation.NSDictionary options);
public virtual void MakeSecureToken (Foundation.NSData persistableContentKeyData, System.Action<Foundation.NSData,Foundation.NSError> handler);
public virtual System.Threading.Tasks.Task<Foundation.NSData> MakeSecureTokenAsync (Foundation.NSData persistableContentKeyData);
```


#### Type Changed: AVFoundation.AVContentKeySessionDelegate

Added methods:

```csharp
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void DidUpdate (AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);
```


#### Type Changed: AVFoundation.AVContentKeySessionDelegate_Extensions

Added methods:

```csharp
public static void DidProvideContentKeyRequests (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public static void DidUpdate (this IAVContentKeySessionDelegate This, AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public static void ExternalProtectionStatusDidChange (this IAVContentKeySessionDelegate This, AVContentKeySession session, AVContentKey contentKey);
```


#### Type Changed: AVFoundation.AVDisplayCriteria

Added constructor:

```csharp
public AVDisplayCriteria (float refreshRate, CoreMedia.CMFormatDescription formatDescription);
```


#### Type Changed: AVFoundation.AVError

Added values:

```csharp
AirPlayReceiverTemporarilyUnavailable = -11882,
EncodeFailed = -11883,
FailedToLoadSampleData = -11881,
InvalidSampleCursor = -11880,
MediaExtensionConflict = -11887,
MediaExtensionDisabled = -11886,
SandboxExtensionDenied = -11884,
ToneMappingFailed = -11885,
```


#### Type Changed: AVFoundation.AVFileTypes

Added value:

```csharp
Ahap = 23,
```


#### Type Changed: AVFoundation.AVMediaCharacteristics

Added values:

```csharp
CarriesVideoStereoMetadata = 18,
ContainsStereoMultiviewVideo = 19,
EnhancesSpeechIntelligibility = 20,
IndicatesHorizontalFieldOfView = 21,
TactileMinimal = 22,
```


#### Type Changed: AVFoundation.AVMediaTypes

Added values:

```csharp
AuxiliaryPicture = 11,
Haptic = 12,
```


#### Type Changed: AVFoundation.AVMetadata

Added properties:

```csharp
public static Foundation.NSString QuickTimeMetadataFullFrameRatePlaybackIntent { get; }
public static Foundation.NSString QuickTimeMetadataKeyFullFrameRatePlaybackIntent { get; }
```


#### Type Changed: AVFoundation.AVMetadataObjectType

Added value:

```csharp
HumanFullBody = 16777216,
```


#### Type Changed: AVFoundation.AVMusicTrack

Added property:

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

Added methods:

```csharp
public virtual void AddEvent (AVMusicEvent event, double beat);
public virtual void ClearEvents (AVBeatRange range);
public virtual void CopyAndMergeEvents (AVBeatRange range, AVMusicTrack sourceTrack, double mergeStartBeat);
public virtual void CopyEvents (AVBeatRange range, AVMusicTrack sourceTrack, double insertStartBeat);
public virtual void CutEvents (AVBeatRange range);
public virtual void EnumerateEvents (AVBeatRange range, AVMusicEventEnumerationBlock block);
public virtual void MoveEvents (AVBeatRange range, double beatAmount);
```


#### Type Changed: AVFoundation.AVMutableComposition

Added methods:

```csharp
public virtual void Insert (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime, AVMutableCompositionInsertHandler completionHandler);
public virtual System.Threading.Tasks.Task InsertAsync (CoreMedia.CMTimeRange timeRange, AVAsset asset, CoreMedia.CMTime startTime);
```


#### Type Changed: AVFoundation.AVMutableVideoComposition

Added methods:

```csharp
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVMutableVideoCompositionCreateApplier applier, AVMutableVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction, AVMutableVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVMutableVideoCompositionCreateApplier applier);
public static System.Threading.Tasks.Task<AVMutableVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionInstruction prototypeInstruction);
```


#### Type Changed: AVFoundation.AVOutputSettingsPreset

Added values:

```csharp
PresetMvHevc1440x1440 = 17,
PresetMvHevc960x960 = 16,
```


#### Type Changed: AVFoundation.AVPlayer

Added properties:

```csharp
public virtual float DefaultRate { get; set; }
public virtual AVPlayerVideoOutput VideoOutput { get; set; }
```

Added method:

```csharp
protected override void Dispose (bool disposing);
```


#### Type Changed: AVFoundation.AVPlayerInterstitialEvent

Added interfaces:

```csharp
Foundation.INSCopying
ObjCRuntime.INativeObject
System.IDisposable
```

Modified properties:

```diff
-public virtual Foundation.NSDate Date { get; set; }
+public virtual Foundation.NSDate Date { get; }
-public virtual string Identifier { get; set; }
+public virtual string Identifier { get; }
-public virtual CoreMedia.CMTime PlayoutLimit { get; set; }
+public virtual CoreMedia.CMTime PlayoutLimit { get; }
-public virtual AVPlayerItem PrimaryItem { get; set; }
+public virtual AVPlayerItem PrimaryItem { get; }
-public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; set; }
+public virtual AVPlayerInterstitialEventRestrictions Restrictions { get; }
-public virtual CoreMedia.CMTime ResumptionOffset { get; set; }
+public virtual CoreMedia.CMTime ResumptionOffset { get; }
-public virtual AVPlayerItem[] TemplateItems { get; set; }
+public virtual AVPlayerItem[] TemplateItems { get; }
-public virtual CoreMedia.CMTime Time { get; set; }
+public virtual CoreMedia.CMTime Time { get; }
-public virtual Foundation.NSDictionary UserDefinedAttributes { get; set; }
+public virtual Foundation.NSDictionary UserDefinedAttributes { get; }
```

Added properties:

```csharp
public virtual bool AlignsResumptionWithPrimarySegmentBoundary { get; set; }
public virtual bool AlignsStartWithPrimarySegmentBoundary { get; set; }
public virtual Foundation.NSDictionary AssetListResponse { get; }
public virtual bool ContentMayVary { get; set; }
public virtual string Cue { get; set; }
public virtual CoreMedia.CMTime PlannedDuration { get; set; }
public virtual bool SupplementsPrimaryContent { get; set; }
public virtual AVPlayerInterstitialEventTimelineOccupancy TimelineOccupancy { get; set; }
public virtual bool WillPlayOnce { get; set; }
```

Added methods:

```csharp
public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, CoreMedia.CMTime time);
public static AVPlayerInterstitialEvent Create (AVPlayerItem primaryItem, Foundation.NSDate date);
```


#### Type Changed: AVFoundation.AVPlayerInterstitialEventMonitor

Added properties:

```csharp
public static Foundation.NSString AssetListResponseStatusDidChangeErrorKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeEventKey { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeNotification { get; }
public static Foundation.NSString AssetListResponseStatusDidChangeStatusKey { get; }
```

#### Type Changed: AVFoundation.AVPlayerInterstitialEventMonitor.Notifications

Added methods:

```csharp
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssetListResponseStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
```



#### Type Changed: AVFoundation.AVPlayerItem

Added interface:

```csharp
IAVMetricEventStreamPublisher
```

Added property:

```csharp
public virtual AVPlayerItemIntegratedTimeline IntegratedTimeline { get; }
```


#### Type Changed: AVFoundation.AVPlayerLayer

Added method:

```csharp
public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();
```


#### Type Changed: AVFoundation.AVPlayerLooper

Added constructor:

```csharp
public AVPlayerLooper (AVQueuePlayer player, AVPlayerItem itemToLoop, CoreMedia.CMTimeRange loopRange, AVPlayerLooperItemOrdering itemOrdering);
```


#### Type Changed: AVFoundation.AVSampleBufferDisplayLayer

Added properties:

```csharp
public static Foundation.NSString DisplayLayerReadyForDisplayDidChangeNotification { get; }
public virtual bool ReadyForDisplay { get; }
public virtual AVSampleBufferVideoRenderer SampleBufferRenderer { get; }
```

#### Type Changed: AVFoundation.AVSampleBufferDisplayLayer.Notifications

Added methods:

```csharp
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDisplayLayerReadyForDisplayDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
```



#### Type Changed: AVFoundation.AVSpeechSynthesisVoice

Added properties:

```csharp
public static Foundation.NSString AvailableVoicesDidChangeNotification { get; }
public virtual AVSpeechSynthesisVoiceTraits VoiceTraits { get; }
```


#### Type Changed: AVFoundation.AVSpeechSynthesisVoiceQuality

Added value:

```csharp
Premium = 3,
```


#### Type Changed: AVFoundation.AVSpeechSynthesizer

Added property:

```csharp
public static AVSpeechSynthesisPersonalVoiceAuthorizationStatus PersonalVoiceAuthorizationStatus { get; }
```

Added event:

```csharp
public event System.EventHandler<AVSpeechSynthesizerWillSpeakMarkerEventArgs> WillSpeakMarker;
```

Added methods:

```csharp
public static void RequestPersonalVoiceAuthorization (AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback handler);
public static System.Threading.Tasks.Task<AVSpeechSynthesisPersonalVoiceAuthorizationStatus> RequestPersonalVoiceAuthorizationAsync ();
public virtual void WriteUtterance (AVSpeechUtterance utterance, AVSpeechSynthesizerBufferCallback bufferCallback, AVSpeechSynthesizerMarkerCallback markerCallback);
```


#### Type Changed: AVFoundation.AVSpeechSynthesizerDelegate

Added method:

```csharp
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
```


#### Type Changed: AVFoundation.AVSpeechSynthesizerDelegate_Extensions

Added method:

```csharp
public static void WillSpeakMarker (this IAVSpeechSynthesizerDelegate This, AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
```


#### Type Changed: AVFoundation.AVSpeechUtterance

Added constructor:

```csharp
public AVSpeechUtterance (string string, AVSpeechUtteranceInitializationOption option);
```

Added method:

```csharp
public static AVSpeechUtterance FromSsmlRepresentation (string string);
```


#### Type Changed: AVFoundation.AVUrlAsset

Added properties:

```csharp
public virtual Foundation.NSUuid HttpSessionIdentifier { get; }
public static Foundation.NSString HttpUserAgentKey { get; }
public static Foundation.NSString OverrideMimeTypeKey { get; }
public static Foundation.NSString PrimarySessionIdentifierKey { get; }
```


#### Type Changed: AVFoundation.AVVideoCodecType

Added values:

```csharp
AppleProRes4444XQ = 10,
JpegXl = 11,
```


#### Type Changed: AVFoundation.AVVideoComposition

Added methods:

```csharp
public static void Create (AVAsset asset, AVVideoCompositionCreateCallback completionHandler);
public static void Create (AVAsset asset, AVVideoCompositionCreateApplier applier, AVVideoCompositionCreateCallback completionHandler);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset);
public static System.Threading.Tasks.Task<AVVideoComposition> CreateAsync (AVAsset asset, AVVideoCompositionCreateApplier applier);
public virtual void DetermineValidity (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate, AVVideoCompositionDetermineValidityCallback completionHandler);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DetermineValidityAsync (AVAsset asset, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);
public virtual bool IsValid (AVAssetTrack[] tracks, CoreMedia.CMTime duration, CoreMedia.CMTimeRange timeRange, IAVVideoCompositionValidationHandling validationDelegate);
```


#### Type Changed: AVFoundation.AVVideoTransferFunction

Obsoleted properties:

```diff
 [Obsolete ("Use 'Itu_R_709_2' instead.")]
 public static Foundation.NSString AVVideoTransferFunction_Itu_R_709_2 { get; }
```

Added properties:

```csharp
public static Foundation.NSString Iec_sRgb { get; }
public static Foundation.NSString Itu_R_2100_Hlg { get; }
public static Foundation.NSString Itu_R_709_2 { get; }
public static Foundation.NSString Linear { get; }
public static Foundation.NSString Smpte_St_2084_Pq { get; }
```


#### Type Changed: AVFoundation.IAVContentKeySessionDelegate

Added methods:

```csharp
public virtual void DidProvideContentKeyRequests (AVContentKeySession session, AVContentKeyRequest[] keyRequests, Foundation.NSData initializationData);
public virtual void DidUpdate (AVContentKeySession session, Foundation.NSData persistableContentKey, Foundation.NSObject keyIdentifier);
public virtual void ExternalProtectionStatusDidChange (AVContentKeySession session, AVContentKey contentKey);
```


#### Type Changed: AVFoundation.IAVSpeechSynthesizerDelegate

Added method:

```csharp
public virtual void WillSpeakMarker (AVSpeechSynthesizer synthesizer, AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
```


#### New Type: AVFoundation.AVAUPresetEvent

```csharp
public class AVAUPresetEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVAUPresetEvent ();
	protected AVAUPresetEvent (Foundation.NSObjectFlag t);
	protected AVAUPresetEvent (ObjCRuntime.NativeHandle handle);
	public AVAUPresetEvent (uint scope, uint element, Foundation.NSDictionary presetDictionary);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint Element { get; set; }
	public virtual Foundation.NSDictionary PresetDictionary { get; }
	public virtual uint Scope { get; set; }
}
```

#### New Type: AVFoundation.AVAssetImageGeneratorDynamicRangePolicy

```csharp
[Serializable]
public enum AVAssetImageGeneratorDynamicRangePolicy {
	DynamicRangePolicyForceSdr = 0,
	DynamicRangePolicyMatchSource = 1,
}
```

#### New Type: AVFoundation.AVAssetImageGeneratorDynamicRangePolicyExtensions

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

#### New Type: AVFoundation.AVAssetPlaybackAssistant

```csharp
public class AVAssetPlaybackAssistant : Foundation.NSObject {
	// constructors
	protected AVAssetPlaybackAssistant (Foundation.NSObjectFlag t);
	protected AVAssetPlaybackAssistant (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public static AVAssetPlaybackAssistant Create (AVAsset asset);
	public virtual void LoadPlaybackConfigurationOptions (AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler completionHandler);
	public virtual System.Threading.Tasks.Task<System.String[]> LoadPlaybackConfigurationOptionsAsync ();
}
```

#### New Type: AVFoundation.AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler

```csharp
public sealed delegate AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler : System.MulticastDelegate {
	// constructors
	public AVAssetPlaybackAssistantLoadPlaybackConfigurationOptionsHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (string[] playbackConfigurationOptions, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (string[] playbackConfigurationOptions);
}
```

#### New Type: AVFoundation.AVAssetPlaybackConfigurationOption

```csharp
[Serializable]
public enum AVAssetPlaybackConfigurationOption {
	SpatialVideo = 2,
	StereoMultiviewVideo = 1,
	StereoVideo = 0,
}
```

#### New Type: AVFoundation.AVAssetPlaybackConfigurationOptionExtensions

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

#### New Type: AVFoundation.AVAssetTrackGroupOutputHandling

```csharp
[Serializable]
[Flags]
public enum AVAssetTrackGroupOutputHandling {
	DefaultPolicy = 0,
	None = 0,
	PreserveAlternateTracks = 1,
}
```

#### New Type: AVFoundation.AVAssetVariantVideoLayoutAttributes

```csharp
public class AVAssetVariantVideoLayoutAttributes : Foundation.NSObject {
	// constructors
	protected AVAssetVariantVideoLayoutAttributes (Foundation.NSObjectFlag t);
	protected AVAssetVariantVideoLayoutAttributes (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMStereoViewComponents StereoViewComponents { get; }
}
```

#### New Type: AVFoundation.AVAudioApplicationMicrophoneInjectionPermission

```csharp
[Serializable]
public enum AVAudioApplicationMicrophoneInjectionPermission {
	Denied = 1684369017,
	Granted = 1735552628,
	ServiceDisabled = 1936876659,
	Undetermined = 1970168948,
}
```

#### New Type: AVFoundation.AVAudioInputNodeMutedSpeechEventListener

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

#### New Type: AVFoundation.AVAudioRecorder

```csharp
public class AVAudioRecorder : Foundation.NSObject {
	// constructors
	public AVAudioRecorder ();
	protected AVAudioRecorder (Foundation.NSObjectFlag t);
	protected AVAudioRecorder (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVAudioSessionChannelDescription[] ChannelAssignments { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual double CurrentTime { get; }
	public IAVAudioRecorderDelegate Delegate { get; set; }
	public virtual double DeviceCurrentTime { get; }
	public virtual AVAudioFormat Format { get; }
	public virtual bool MeteringEnabled { get; set; }
	public virtual bool Recording { get; }
	public AudioSettings Settings { get; }
	public virtual Foundation.NSUrl Url { get; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	public virtual Foundation.NSDictionary WeakSettings { get; }

	[Obsolete ("Use the 'CurrentTime' property instead.")]
public virtual double currentTime { get; }
	// methods
	public virtual float AveragePower (UIntPtr channelNumber);
	public virtual bool DeleteRecording ();
	protected override void Dispose (bool disposing);
	public virtual void Pause ();
	public virtual float PeakPower (UIntPtr channelNumber);
	public virtual bool PrepareToRecord ();
	public virtual bool Record ();
	public virtual bool RecordAt (double time);
	public virtual bool RecordAt (double time, double duration);
	public virtual bool RecordFor (double duration);
	public virtual void Stop ();
	public virtual void UpdateMeters ();
}
```

#### New Type: AVFoundation.AVAudioRecorderDelegate

```csharp
public class AVAudioRecorderDelegate : Foundation.NSObject, IAVAudioRecorderDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVAudioRecorderDelegate ();
	protected AVAudioRecorderDelegate (Foundation.NSObjectFlag t);
	protected AVAudioRecorderDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void EncoderError (AVAudioRecorder recorder, Foundation.NSError error);
	public virtual void FinishedRecording (AVAudioRecorder recorder, bool flag);
}
```

#### New Type: AVFoundation.AVAudioRecorderDelegate_Extensions

```csharp
public static class AVAudioRecorderDelegate_Extensions {
	// methods
	public static void EncoderError (this IAVAudioRecorderDelegate This, AVAudioRecorder recorder, Foundation.NSError error);
	public static void FinishedRecording (this IAVAudioRecorderDelegate This, AVAudioRecorder recorder, bool flag);
}
```

#### New Type: AVFoundation.AVAudioSequencerInfoDictionary

```csharp
public class AVAudioSequencerInfoDictionary : Foundation.DictionaryContainer {
	// constructors
	public AVAudioSequencerInfoDictionary ();
	public AVAudioSequencerInfoDictionary (Foundation.NSDictionary dictionary);
	// properties
	public string Album { get; set; }
	public double? ApproximateDurationInSeconds { get; set; }
	public string Artist { get; set; }
	public Foundation.NSObject ChannelLayout { get; set; }
	public string Comments { get; set; }
	public string Composer { get; set; }
	public string Copyright { get; set; }
	public string EncodingApplication { get; set; }
	public string Genre { get; set; }
	public Foundation.NSObject Isrc { get; set; }
	public string KeySignature { get; set; }
	public string Lyricist { get; set; }
	public double? NominalBitRate { get; set; }
	public Foundation.NSObject RecordedDate { get; set; }
	public double? SourceBitDepth { get; set; }
	public string SourceEncoder { get; set; }
	public string SubTitle { get; set; }
	public double? Tempo { get; set; }
	public string TimeSignature { get; set; }
	public string Title { get; set; }
	public int? TrackNumber { get; set; }
	public string Year { get; set; }
}
```

#### New Type: AVFoundation.AVAudioSequencerUserCallback

```csharp
public sealed delegate AVAudioSequencerUserCallback : System.MulticastDelegate {
	// constructors
	public AVAudioSequencerUserCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (AVMusicTrack track, Foundation.NSData userData, double timeStamp);
}
```

#### New Type: AVFoundation.AVAudioSessionMicrophoneInjectionMode

```csharp
[Serializable]
public enum AVAudioSessionMicrophoneInjectionMode {
	None = 0,
	SpokenAudio = 1,
}
```

#### New Type: AVFoundation.AVAudioVoiceProcessingSpeechActivityEvent

```csharp
[Serializable]
public enum AVAudioVoiceProcessingSpeechActivityEvent {
	Ended = 1,
	Started = 0,
}
```

#### New Type: AVFoundation.AVAuthorizationMediaType

```csharp
[Serializable]
public enum AVAuthorizationMediaType {
	Audio = 1,
	Video = 0,
}
```

#### New Type: AVFoundation.AVAuthorizationStatus

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

#### New Type: AVFoundation.AVCaptureAudioDataOutput

```csharp
public class AVCaptureAudioDataOutput : AVFoundation.AVCaptureOutput {
	// constructors
	public AVCaptureAudioDataOutput ();
	protected AVCaptureAudioDataOutput (Foundation.NSObjectFlag t);
	protected AVCaptureAudioDataOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public AudioSettings AudioSettings { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreFoundation.DispatchQueue SampleBufferCallbackQueue { get; }
	public virtual IAVCaptureAudioDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
	public virtual Foundation.NSDictionary WeakAudioSettings { get; set; }
	// methods
	public virtual Foundation.NSDictionary GetRecommendedAudioSettingsForAssetWriter (string outputFileType);
	public virtual void SetSampleBufferDelegate (IAVCaptureAudioDataOutputSampleBufferDelegate sampleBufferDelegate, CoreFoundation.DispatchQueue sampleBufferCallbackDispatchQueue);
}
```

#### New Type: AVFoundation.AVCaptureAudioDataOutputSampleBufferDelegate

```csharp
public class AVCaptureAudioDataOutputSampleBufferDelegate : Foundation.NSObject, IAVCaptureAudioDataOutputSampleBufferDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCaptureAudioDataOutputSampleBufferDelegate ();
	protected AVCaptureAudioDataOutputSampleBufferDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureAudioDataOutputSampleBufferDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureAudioDataOutputSampleBufferDelegate_Extensions

```csharp
public static class AVCaptureAudioDataOutputSampleBufferDelegate_Extensions {
	// methods
	public static void DidOutputSampleBuffer (this IAVCaptureAudioDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureAutoExposureBracketedStillImageSettings

```csharp
public class AVCaptureAutoExposureBracketedStillImageSettings : AVFoundation.AVCaptureBracketedStillImageSettings {
	// constructors
	protected AVCaptureAutoExposureBracketedStillImageSettings (Foundation.NSObjectFlag t);
	protected AVCaptureAutoExposureBracketedStillImageSettings (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual float ExposureTargetBias { get; }
	// methods
	public static AVCaptureAutoExposureBracketedStillImageSettings Create (float exposureTargetBias);
}
```

#### New Type: AVFoundation.AVCaptureAutoFocusRangeRestriction

```csharp
[Serializable]
public enum AVCaptureAutoFocusRangeRestriction {
	Far = 2,
	Near = 1,
	None = 0,
}
```

#### New Type: AVFoundation.AVCaptureAutoFocusSystem

```csharp
[Serializable]
public enum AVCaptureAutoFocusSystem {
	ContrastDetection = 1,
	None = 0,
	PhaseDetection = 2,
}
```

#### New Type: AVFoundation.AVCaptureBracketedStillImageSettings

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

#### New Type: AVFoundation.AVCaptureCenterStageControlMode

```csharp
[Serializable]
public enum AVCaptureCenterStageControlMode {
	App = 1,
	Cooperative = 2,
	User = 0,
}
```

#### New Type: AVFoundation.AVCaptureColorSpace

```csharp
[Serializable]
public enum AVCaptureColorSpace {
	AppleLog = 3,
	HlgBT2020 = 2,
	P3D65 = 1,
	Srgb = 0,
}
```

#### New Type: AVFoundation.AVCaptureControl

```csharp
public class AVCaptureControl : Foundation.NSObject {
	// constructors
	protected AVCaptureControl (Foundation.NSObjectFlag t);
	protected AVCaptureControl (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool Enabled { get; set; }
}
```

#### New Type: AVFoundation.AVCaptureDataOutputSynchronizer

```csharp
public class AVCaptureDataOutputSynchronizer : Foundation.NSObject {
	// constructors
	public AVCaptureDataOutputSynchronizer (AVCaptureOutput[] dataOutputs);
	protected AVCaptureDataOutputSynchronizer (Foundation.NSObjectFlag t);
	protected AVCaptureDataOutputSynchronizer (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureOutput[] DataOutputs { get; }
	public IAVCaptureDataOutputSynchronizerDelegate Delegate { get; }
	public virtual CoreFoundation.DispatchQueue DelegateCallbackQueue { get; }
	public virtual Foundation.NSObject WeakDelegate { get; }
	// methods
	public virtual void SetDelegate (IAVCaptureDataOutputSynchronizerDelegate del, CoreFoundation.DispatchQueue delegateCallbackQueue);
}
```

#### New Type: AVFoundation.AVCaptureDataOutputSynchronizerDelegate

```csharp
public abstract class AVCaptureDataOutputSynchronizerDelegate : Foundation.NSObject, IAVCaptureDataOutputSynchronizerDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected AVCaptureDataOutputSynchronizerDelegate ();
	protected AVCaptureDataOutputSynchronizerDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureDataOutputSynchronizerDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidOutputSynchronizedDataCollection (AVCaptureDataOutputSynchronizer synchronizer, AVCaptureSynchronizedDataCollection synchronizedDataCollection);
}
```

#### New Type: AVFoundation.AVCaptureDepthDataOutput

```csharp
public class AVCaptureDepthDataOutput : AVFoundation.AVCaptureOutput {
	// constructors
	public AVCaptureDepthDataOutput ();
	protected AVCaptureDepthDataOutput (Foundation.NSObjectFlag t);
	protected AVCaptureDepthDataOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual bool AlwaysDiscardsLateDepthData { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public IAVCaptureDepthDataOutputDelegate Delegate { get; }
	public virtual CoreFoundation.DispatchQueue DelegateCallbackQueue { get; }
	public virtual bool FilteringEnabled { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; }
	// methods
	public virtual void SetDelegate (IAVCaptureDepthDataOutputDelegate del, CoreFoundation.DispatchQueue callbackQueue);
}
```

#### New Type: AVFoundation.AVCaptureDepthDataOutputDelegate

```csharp
public class AVCaptureDepthDataOutputDelegate : Foundation.NSObject, IAVCaptureDepthDataOutputDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCaptureDepthDataOutputDelegate ();
	protected AVCaptureDepthDataOutputDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureDepthDataOutputDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidDropDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
	public virtual void DidOutputDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureDepthDataOutputDelegate_Extensions

```csharp
public static class AVCaptureDepthDataOutputDelegate_Extensions {
	// methods
	public static void DidDropDepthData (this IAVCaptureDepthDataOutputDelegate This, AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
	public static void DidOutputDepthData (this IAVCaptureDepthDataOutputDelegate This, AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureDevice

```csharp
public class AVCaptureDevice : Foundation.NSObject {
	// constructors
	protected AVCaptureDevice (Foundation.NSObjectFlag t);
	protected AVCaptureDevice (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVCaptureColorSpace ActiveColorSpace { get; set; }
	public virtual AVCaptureDeviceFormat ActiveDepthDataFormat { get; set; }
	public virtual CoreMedia.CMTime ActiveDepthDataMinFrameDuration { get; set; }
	public virtual AVCaptureDeviceFormat ActiveFormat { get; set; }
	public virtual CoreMedia.CMTime ActiveMaxExposureDuration { get; set; }
	public static AVCaptureMicrophoneMode ActiveMicrophoneMode { get; }
	public virtual AVCaptureDevice ActivePrimaryConstituentDevice { get; }
	public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions ActivePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions { get; }
	public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior ActivePrimaryConstituentDeviceSwitchingBehavior { get; }
	public virtual CoreMedia.CMTime ActiveVideoMaxFrameDuration { get; set; }
	public virtual CoreMedia.CMTime ActiveVideoMinFrameDuration { get; set; }
	public virtual bool AdjustingExposure { get; }
	public virtual bool AdjustingFocus { get; }
	public virtual bool AdjustingWhiteBalance { get; }
	public virtual AVCaptureAutoFocusRangeRestriction AutoFocusRangeRestriction { get; set; }
	public virtual bool AutoFocusRangeRestrictionSupported { get; }
	public virtual bool AutoVideoFrameRateEnabled { get; set; }
	public virtual bool AutomaticallyAdjustsFaceDrivenAutoExposureEnabled { get; set; }
	public virtual bool AutomaticallyAdjustsFaceDrivenAutoFocusEnabled { get; set; }
	public virtual bool AutomaticallyAdjustsVideoHdrEnabled { get; set; }
	public virtual bool AutomaticallyEnablesLowLightBoostWhenAvailable { get; set; }
	public virtual Foundation.NSSet<Foundation.NSString> AvailableReactionTypes { get; }
	public virtual bool BackgroundReplacementActive { get; }
	public static bool BackgroundReplacementEnabled { get; }
	public virtual bool CanPerformReactionEffects { get; }
	public virtual bool CenterStageActive { get; }
	public static AVCaptureCenterStageControlMode CenterStageControlMode { get; set; }
	public static bool CenterStageEnabled { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureDevice CompanionDeskViewCamera { get; }
	public virtual bool Connected { get; }
	public virtual AVCaptureDevice[] ConstituentDevices { get; }
	public virtual bool ContinuityCamera { get; }
	public AVCaptureDeviceType DeviceType { get; }
	public virtual AVCaptureWhiteBalanceGains DeviceWhiteBalanceGains { get; }
	public static AVCaptureDevice[] Devices { get; }
	public virtual System.Runtime.InteropServices.NFloat DisplayVideoZoomFactorMultiplier { get; }
	public virtual System.Runtime.InteropServices.NFloat DualCameraSwitchOverVideoZoomFactor { get; }
	public virtual CoreMedia.CMTime ExposureDuration { get; }
	public static CoreMedia.CMTime ExposureDurationCurrent { get; }
	public virtual AVCaptureExposureMode ExposureMode { get; set; }
	public virtual CoreGraphics.CGPoint ExposurePointOfInterest { get; set; }
	public virtual bool ExposurePointOfInterestSupported { get; }
	public virtual float ExposureTargetBias { get; }
	public static float ExposureTargetBiasCurrent { get; }
	public virtual float ExposureTargetOffset { get; }
	public virtual bool FaceDrivenAutoExposureEnabled { get; set; }
	public virtual bool FaceDrivenAutoFocusEnabled { get; set; }
	public virtual AVCaptureDevice[] FallbackPrimaryConstituentDevices { get; set; }
	public virtual bool FlashActive { get; }
	public virtual bool FlashAvailable { get; }
	public virtual AVCaptureFocusMode FocusMode { get; set; }
	public static float FocusModeLensPositionCurrent { get; }
	public virtual CoreGraphics.CGPoint FocusPointOfInterest { get; set; }
	public virtual bool FocusPointOfInterestSupported { get; }
	public virtual AVCaptureDeviceFormat[] Formats { get; }
	public virtual bool GeometricDistortionCorrectionEnabled { get; set; }
	public virtual bool GeometricDistortionCorrectionSupported { get; }
	public virtual bool GlobalToneMappingEnabled { get; set; }
	public virtual AVCaptureWhiteBalanceGains GrayWorldDeviceWhiteBalanceGains { get; }
	public virtual bool HasFlash { get; }
	public virtual bool HasTorch { get; }
	public virtual float ISO { get; }
	public static float ISOCurrent { get; }
	public virtual bool InUseByAnotherApplication { get; }
	public virtual float LensAperture { get; }
	public virtual float LensPosition { get; }
	public static float LensPositionCurrent { get; }
	public virtual AVCaptureDevice[] LinkedDevices { get; }
	public virtual string LocalizedName { get; }
	public virtual bool LockingFocusWithCustomLensPositionSupported { get; }
	public virtual bool LockingWhiteBalanceWithCustomDeviceGainsSupported { get; }
	public virtual bool LowLightBoostEnabled { get; }
	public virtual bool LowLightBoostSupported { get; }
	public virtual string Manufacturer { get; }
	public static float MaxAvailableTorchLevel { get; }
	public virtual System.Runtime.InteropServices.NFloat MaxAvailableVideoZoomFactor { get; }
	public virtual float MaxExposureTargetBias { get; }
	public virtual float MaxWhiteBalanceGain { get; }
	public virtual System.Runtime.InteropServices.NFloat MinAvailableVideoZoomFactor { get; }
	public virtual float MinExposureTargetBias { get; }
	public virtual IntPtr MinimumFocusDistance { get; }
	public virtual string ModelID { get; }
	public virtual bool PortraitEffectActive { get; }
	public static bool PortraitEffectEnabled { get; }
	public virtual AVCaptureDevicePosition Position { get; }
	public static AVCaptureMicrophoneMode PreferredMicrophoneMode { get; }
	public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions PrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions { get; }
	public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior PrimaryConstituentDeviceSwitchingBehavior { get; }
	public virtual bool RampingVideoZoom { get; }
	public static bool ReactionEffectGesturesEnabled { get; }
	public static bool ReactionEffectsEnabled { get; }
	public virtual AVCaptureReactionEffectState[] ReactionEffectsInProgress { get; }
	public virtual bool SmoothAutoFocusEnabled { get; set; }
	public virtual bool SmoothAutoFocusSupported { get; }
	public virtual Foundation.NSSet<Foundation.NSString> SpatialCaptureDiscomfortReasons { get; }
	public virtual bool StudioLightActive { get; }
	public static bool StudioLightEnabled { get; }
	public virtual bool SubjectAreaChangeMonitoringEnabled { get; set; }
	public static Foundation.NSString SubjectAreaDidChangeNotification { get; }
	public virtual AVCaptureDevice[] SupportedFallbackPrimaryConstituentDevices { get; }
	public virtual bool Suspended { get; }
	public static AVCaptureDevice SystemPreferredCamera { get; }
	public virtual AVCaptureSystemPressureState SystemPressureState { get; }
	public virtual bool TorchActive { get; }
	public virtual bool TorchAvailable { get; }
	public virtual float TorchLevel { get; }
	public virtual AVCaptureTorchMode TorchMode { get; set; }
	public virtual string UniqueID { get; }
	public static AVCaptureDevice UserPreferredCamera { get; set; }
	public virtual bool VideoHdrEnabled { get; set; }
	public virtual System.Runtime.InteropServices.NFloat VideoZoomFactor { get; set; }
	public virtual bool VirtualDevice { get; }
	public virtual Foundation.NSNumber[] VirtualDeviceSwitchOverVideoZoomFactors { get; }
	public static Foundation.NSString WasConnectedNotification { get; }
	public static Foundation.NSString WasDisconnectedNotification { get; }
	public virtual int WeakTransportType { get; }
	public static AVCaptureWhiteBalanceGains WhiteBalanceGainsCurrent { get; }
	public virtual AVCaptureWhiteBalanceMode WhiteBalanceMode { get; set; }
	// methods
	public virtual void CancelVideoZoomRamp ();
	public static AVCaptureDevice DeviceWithUniqueID (string deviceUniqueID);
	public static AVCaptureDevice[] DevicesWithMediaType (string mediaType);
	protected override void Dispose (bool disposing);
	public static AVAuthorizationStatus GetAuthorizationStatus (AVAuthorizationMediaType mediaType);
	public static AVAuthorizationStatus GetAuthorizationStatus (Foundation.NSString avMediaTypeToken);
	public virtual AVCaptureWhiteBalanceChromaticityValues GetChromaticityValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
	public static AVCaptureDevice GetDefaultDevice (AVMediaTypes mediaType);
	public static AVCaptureDevice GetDefaultDevice (Foundation.NSString mediaType);
	public static AVCaptureDevice GetDefaultDevice (AVCaptureDeviceType deviceType, string mediaType, AVCaptureDevicePosition position);
	public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceChromaticityValues chromaticityValues);
	public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceTemperatureAndTintValues tempAndTintValues);
	public static Foundation.NSData GetExtrinsicMatrix (AVCaptureDevice fromDevice, AVCaptureDevice toDevice);
	public virtual AVCaptureWhiteBalanceTemperatureAndTintValues GetTemperatureAndTintValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
	public bool HasMediaType (AVMediaTypes mediaType);
	public virtual bool HasMediaType (string mediaType);
	public virtual bool IsExposureModeSupported (AVCaptureExposureMode exposureMode);
	public virtual bool IsFocusModeSupported (AVCaptureFocusMode focusMode);
	public virtual bool IsTorchModeSupported (AVCaptureTorchMode torchMode);
	public virtual bool IsWhiteBalanceModeSupported (AVCaptureWhiteBalanceMode whiteBalanceMode);
	public virtual void LockExposure (CoreMedia.CMTime duration, float ISO, System.Action<CoreMedia.CMTime> completionHandler);
	public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> LockExposureAsync (CoreMedia.CMTime duration, float ISO);
	public virtual bool LockForConfiguration (out Foundation.NSError error);
	public virtual void PerformEffect (string reactionType);
	public virtual void RampToVideoZoom (System.Runtime.InteropServices.NFloat factor, float rate);
	public static void RequestAccessForMediaType (AVAuthorizationMediaType mediaType, AVRequestAccessStatus completion);
	public static void RequestAccessForMediaType (Foundation.NSString avMediaTypeToken, AVRequestAccessStatus completion);
	public static System.Threading.Tasks.Task<bool> RequestAccessForMediaTypeAsync (AVAuthorizationMediaType mediaType);
	public static System.Threading.Tasks.Task<bool> RequestAccessForMediaTypeAsync (Foundation.NSString avMediaTypeToken);
	public virtual void SetExposureTargetBias (float bias, System.Action<CoreMedia.CMTime> completionHandler);
	public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetExposureTargetBiasAsync (float bias);
	public virtual void SetFocusModeLocked (float lensPosition, System.Action<CoreMedia.CMTime> completionHandler);
	public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetFocusModeLockedAsync (float lensPosition);
	public virtual void SetPrimaryConstituentDeviceSwitchingBehavior (AVCapturePrimaryConstituentDeviceSwitchingBehavior switchingBehavior, AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions restrictedSwitchingBehaviorConditions);
	public virtual bool SetTorchModeLevel (float torchLevel, out Foundation.NSError outError);
	public virtual void SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains (AVCaptureWhiteBalanceGains whiteBalanceGains, System.Action<CoreMedia.CMTime> completionHandler);
	public virtual System.Threading.Tasks.Task<CoreMedia.CMTime> SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGainsAsync (AVCaptureWhiteBalanceGains whiteBalanceGains);
	public static void ShowSystemUserInterface (AVCaptureSystemUserInterface systemUserInterface);
	public virtual bool SupportsAVCaptureSessionPreset (string preset);
	public virtual void UnlockForConfiguration ();

	// inner types
	public static class Notifications {
		// methods
		public static Foundation.NSObject ObserveSubjectAreaDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveSubjectAreaDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveWasConnected (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveWasConnected (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveWasDisconnected (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveWasDisconnected (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
	}
}
```

#### New Type: AVFoundation.AVCaptureDeviceDiscoverySession

```csharp
public class AVCaptureDeviceDiscoverySession : Foundation.NSObject {
	// constructors
	protected AVCaptureDeviceDiscoverySession (Foundation.NSObjectFlag t);
	protected AVCaptureDeviceDiscoverySession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureDevice[] Devices { get; }
	public virtual Foundation.NSSet<AVCaptureDevice>[] SupportedMultiCamDeviceSets { get; }
	// methods
	public static AVCaptureDeviceDiscoverySession Create (AVCaptureDeviceType[] deviceTypes, AVMediaTypes mediaType, AVCaptureDevicePosition position);
}
```

#### New Type: AVFoundation.AVCaptureDeviceFormat

```csharp
public class AVCaptureDeviceFormat : Foundation.NSObject {
	// constructors
	protected AVCaptureDeviceFormat (Foundation.NSObjectFlag t);
	protected AVCaptureDeviceFormat (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVCaptureAutoFocusSystem AutoFocusSystem { get; }
	public virtual bool AutoVideoFrameRateSupported { get; }
	public virtual bool BackgroundReplacementSupported { get; }
	public virtual bool CenterStageSupported { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMFormatDescription FormatDescription { get; }
	public virtual float GeometricDistortionCorrectedVideoFieldOfView { get; }
	public virtual bool GlobalToneMappingSupported { get; }
	public virtual bool HighPhotoQualitySupported { get; }
	public virtual CoreMedia.CMVideoDimensions HighResolutionStillImageDimensions { get; }
	public virtual bool HighestPhotoQualitySupported { get; }
	public virtual bool IsVideoHdrSupported { get; }
	public virtual CoreMedia.CMTime MaxExposureDuration { get; }
	public virtual float MaxISO { get; }
	public virtual Foundation.NSString MediaType { get; }
	public virtual CoreMedia.CMTime MinExposureDuration { get; }
	public virtual float MinISO { get; }
	public virtual bool MultiCamSupported { get; }
	public virtual bool PortraitEffectSupported { get; }
	public virtual bool PortraitEffectsMatteStillImageDeliverySupported { get; }
	public virtual bool ReactionEffectsSupported { get; }
	public virtual System.Runtime.InteropServices.NFloat[] SecondaryNativeResolutionZoomFactors { get; }
	public virtual bool SpatialVideoCaptureSupported { get; }
	public virtual bool StudioLightSupported { get; }
	public virtual AVCaptureColorSpace[] SupportedColorSpaces { get; }
	public virtual AVCaptureDeviceFormat[] SupportedDepthDataFormats { get; }
	public virtual CoreMedia.CMVideoDimensions[] SupportedMaxPhotoDimensions { get; }
	public virtual System.Runtime.InteropServices.NFloat[] SupportedVideoZoomFactorsForDepthDataDelivery { get; }
	public virtual AVZoomRange[] SupportedVideoZoomRangesForDepthDataDelivery { get; }
	public virtual AVExposureBiasRange SystemRecommendedExposureBiasRange { get; }
	public virtual AVZoomRange SystemRecommendedVideoZoomRange { get; }
	public virtual ObjCRuntime.Class[] UnsupportedCaptureOutputClasses { get; }
	public virtual bool VideoBinned { get; }
	public virtual float VideoFieldOfView { get; }
	public virtual AVFrameRateRange VideoFrameRateRangeForBackgroundReplacement { get; }
	public virtual AVFrameRateRange VideoFrameRateRangeForCenterStage { get; }
	public virtual AVFrameRateRange VideoFrameRateRangeForPortraitEffect { get; }
	public virtual AVFrameRateRange VideoFrameRateRangeForReactionEffectsInProgress { get; }
	public virtual AVFrameRateRange VideoFrameRateRangeForStudioLight { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactor { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactorForCenterStage { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoMaxZoomFactorForDepthDataDelivery { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoMinZoomFactorForCenterStage { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoMinZoomFactorForDepthDataDelivery { get; }
	public virtual bool VideoStabilizationSupported { get; }
	public virtual AVFrameRateRange[] VideoSupportedFrameRateRanges { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoZoomFactorUpscaleThreshold { get; }
	public virtual bool ZoomFactorsOutsideOfVideoZoomRangesForDepthDeliverySupported { get; }

	[Obsolete ("Use the 'IsVideoHdrSupported' property instead.")]
public virtual bool videoHDRSupportedVideoHDREnabled { get; }
	// methods
	public virtual bool IsVideoStabilizationModeSupported (AVCaptureVideoStabilizationMode mode);
}
```

#### New Type: AVFoundation.AVCaptureDeviceInput

```csharp
public class AVCaptureDeviceInput : AVFoundation.AVCaptureInput {
	// constructors
	protected AVCaptureDeviceInput (Foundation.NSObjectFlag t);
	protected AVCaptureDeviceInput (ObjCRuntime.NativeHandle handle);
	public AVCaptureDeviceInput (AVCaptureDevice device, out Foundation.NSError error);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureDevice Device { get; }
	public virtual AVCaptureMultichannelAudioMode MultichannelAudioMode { get; set; }
	public virtual bool UnifiedAutoExposureDefaultsEnabled { get; set; }
	public virtual CoreMedia.CMTime VideoMinFrameDurationOverride { get; set; }
	public virtual bool WindNoiseRemovalEnabled { get; set; }
	public virtual bool WindNoiseRemovalSupported { get; }
	// methods
	public static AVCaptureDeviceInput FromDevice (AVCaptureDevice device, out Foundation.NSError error);
	public virtual AVCaptureInputPort[] GetPorts (AVMediaTypes mediaType, AVCaptureDeviceType sourceDeviceType, AVCaptureDevicePosition sourceDevicePosition);
	public virtual bool IsMultichannelAudioModeSupported (AVCaptureMultichannelAudioMode multichannelAudioMode);
}
```

#### New Type: AVFoundation.AVCaptureDeviceRotationCoordinator

```csharp
public class AVCaptureDeviceRotationCoordinator : Foundation.NSObject {
	// constructors
	protected AVCaptureDeviceRotationCoordinator (Foundation.NSObjectFlag t);
	protected AVCaptureDeviceRotationCoordinator (ObjCRuntime.NativeHandle handle);
	public AVCaptureDeviceRotationCoordinator (AVCaptureDevice device, CoreAnimation.CALayer previewLayer);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureDevice Device { get; }
	public virtual CoreAnimation.CALayer PreviewLayer { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelCapture { get; }
	public virtual System.Runtime.InteropServices.NFloat VideoRotationAngleForHorizonLevelPreview { get; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: AVFoundation.AVCaptureExposureMode

```csharp
[Serializable]
public enum AVCaptureExposureMode {
	AutoExpose = 1,
	ContinuousAutoExposure = 2,
	Custom = 3,
	Locked = 0,
}
```

#### New Type: AVFoundation.AVCaptureFlashMode

```csharp
[Serializable]
public enum AVCaptureFlashMode {
	Auto = 2,
	Off = 0,
	On = 1,
}
```

#### New Type: AVFoundation.AVCaptureFocusMode

```csharp
[Serializable]
public enum AVCaptureFocusMode {
	AutoFocus = 1,
	ContinuousAutoFocus = 2,
	Locked = 0,
}
```

#### New Type: AVFoundation.AVCaptureIndexPicker

```csharp
public class AVCaptureIndexPicker : AVFoundation.AVCaptureControl {
	// constructors
	public AVCaptureIndexPicker ();
	protected AVCaptureIndexPicker (Foundation.NSObjectFlag t);
	protected AVCaptureIndexPicker (ObjCRuntime.NativeHandle handle);
	public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes);
	public AVCaptureIndexPicker (string localizedTitle, string symbolName, string[] localizedIndexTitles);
	public AVCaptureIndexPicker (string localizedTitle, string symbolName, IntPtr numberOfIndexes, AVCaptureIndexPickerTitleTransform localizedTitleTransform);
	// properties
	public virtual string AccessibilityIdentifier { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string[] LocalizedIndexTitles { get; }
	public virtual string LocalizedTitle { get; }
	public virtual IntPtr NumberOfIndexes { get; }
	public virtual IntPtr SelectedIndex { get; set; }
	public virtual string SymbolName { get; }
	// methods
	public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureIndexPickerCallback action);
}
```

#### New Type: AVFoundation.AVCaptureIndexPickerCallback

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

#### New Type: AVFoundation.AVCaptureIndexPickerTitleTransform

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

#### New Type: AVFoundation.AVCaptureLensStabilizationStatus

```csharp
[Serializable]
public enum AVCaptureLensStabilizationStatus {
	Active = 2,
	Off = 1,
	OutOfRange = 3,
	Unavailable = 4,
	Unsupported = 0,
}
```

#### New Type: AVFoundation.AVCaptureManualExposureBracketedStillImageSettings

```csharp
public class AVCaptureManualExposureBracketedStillImageSettings : AVFoundation.AVCaptureBracketedStillImageSettings {
	// constructors
	protected AVCaptureManualExposureBracketedStillImageSettings (Foundation.NSObjectFlag t);
	protected AVCaptureManualExposureBracketedStillImageSettings (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMTime ExposureDuration { get; }
	public virtual float ISO { get; }
	// methods
	public static AVCaptureManualExposureBracketedStillImageSettings Create (CoreMedia.CMTime duration, float ISO);
}
```

#### New Type: AVFoundation.AVCaptureMetadataInput

```csharp
public class AVCaptureMetadataInput : AVFoundation.AVCaptureInput {
	// constructors
	protected AVCaptureMetadataInput (Foundation.NSObjectFlag t);
	protected AVCaptureMetadataInput (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual bool AppendTimedMetadataGroup (AVTimedMetadataGroup metadata, out Foundation.NSError outError);
}
```

#### New Type: AVFoundation.AVCaptureMetadataOutput

```csharp
public class AVCaptureMetadataOutput : AVFoundation.AVCaptureOutput {
	// constructors
	public AVCaptureMetadataOutput ();
	protected AVCaptureMetadataOutput (Foundation.NSObjectFlag t);
	protected AVCaptureMetadataOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual CoreFoundation.DispatchQueue CallbackQueue { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IAVCaptureMetadataOutputObjectsDelegate Delegate { get; }
	public virtual CoreGraphics.CGRect RectOfInterest { get; set; }
	public virtual Foundation.NSString[] WeakAvailableMetadataObjectTypes { get; }
	public virtual Foundation.NSString[] WeakMetadataObjectTypes { get; set; }
	// methods
	public virtual void SetDelegate (IAVCaptureMetadataOutputObjectsDelegate objectsDelegate, CoreFoundation.DispatchQueue objectsCallbackQueue);
}
```

#### New Type: AVFoundation.AVCaptureMetadataOutputObjectsDelegate

```csharp
public class AVCaptureMetadataOutputObjectsDelegate : Foundation.NSObject, IAVCaptureMetadataOutputObjectsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCaptureMetadataOutputObjectsDelegate ();
	protected AVCaptureMetadataOutputObjectsDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureMetadataOutputObjectsDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureMetadataOutputObjectsDelegate_Extensions

```csharp
public static class AVCaptureMetadataOutputObjectsDelegate_Extensions {
	// methods
	public static void DidOutputMetadataObjects (this IAVCaptureMetadataOutputObjectsDelegate This, AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureMicrophoneMode

```csharp
[Serializable]
public enum AVCaptureMicrophoneMode {
	Standard = 0,
	VoiceIsolation = 2,
	WideSpectrum = 1,
}
```

#### New Type: AVFoundation.AVCaptureMovieFileOutput

```csharp
public class AVCaptureMovieFileOutput : AVFoundation.AVCaptureFileOutput {
	// constructors
	public AVCaptureMovieFileOutput ();
	protected AVCaptureMovieFileOutput (Foundation.NSObjectFlag t);
	protected AVCaptureMovieFileOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSString[] AvailableVideoCodecTypes { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMetadataItem[] Metadata { get; set; }
	public virtual CoreMedia.CMTime MovieFragmentInterval { get; set; }
	public virtual AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions PrimaryConstituentDeviceRestrictedSwitchingBehaviorConditionsForRecording { get; }
	public virtual AVCapturePrimaryConstituentDeviceSwitchingBehavior PrimaryConstituentDeviceSwitchingBehaviorForRecording { get; }
	public virtual bool PrimaryConstituentDeviceSwitchingBehaviorForRecordingEnabled { get; set; }
	public virtual bool SpatialVideoCaptureEnabled { get; set; }
	public virtual bool SpatialVideoCaptureSupported { get; }
	// methods
	public virtual Foundation.NSDictionary GetOutputSettings (AVCaptureConnection connection);
	public virtual string[] GetSupportedOutputSettingsKeys (AVCaptureConnection connection);
	public virtual bool RecordsVideoOrientationAndMirroringChangesAsMetadataTrack (AVCaptureConnection connection);
	public virtual void SetOutputSettings (Foundation.NSDictionary outputSettings, AVCaptureConnection connection);
	public virtual void SetPrimaryConstituentDeviceSwitchingBehaviorForRecording (AVCapturePrimaryConstituentDeviceSwitchingBehavior switchingBehavior, AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions restrictedSwitchingBehaviorConditions);
	public virtual void SetRecordsVideoOrientationAndMirroringChanges (bool doRecordChanges, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureMultiCamSession

```csharp
public class AVCaptureMultiCamSession : AVFoundation.AVCaptureSession {
	// constructors
	public AVCaptureMultiCamSession ();
	protected AVCaptureMultiCamSession (Foundation.NSObjectFlag t);
	protected AVCaptureMultiCamSession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual float HardwareCost { get; }
	public static bool MultiCamSupported { get; }
	public virtual float SystemPressureCost { get; }
}
```

#### New Type: AVFoundation.AVCaptureMultichannelAudioMode

```csharp
[Serializable]
public enum AVCaptureMultichannelAudioMode {
	FirstOrderAmbisonics = 2,
	None = 0,
	Stereo = 1,
}
```

#### New Type: AVFoundation.AVCapturePhoto

```csharp
public class AVCapturePhoto : Foundation.NSObject {
	// constructors
	protected AVCapturePhoto (Foundation.NSObjectFlag t);
	protected AVCapturePhoto (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVCaptureBracketedStillImageSettings BracketSettings { get; }
	public virtual CoreGraphics.CGImage CGImageRepresentation { get; }
	public virtual AVCameraCalibrationData CameraCalibrationData { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual float ConstantColorCenterWeightedMeanConfidenceLevel { get; }
	public virtual CoreVideo.CVPixelBuffer ConstantColorConfidenceMap { get; }
	public virtual bool ConstantColorFallbackPhoto { get; }
	public virtual AVDepthData DepthData { get; }
	public AVVideoSettingsCompressed EmbeddedThumbnailPhotoFormat { get; }
	public virtual Foundation.NSData FileDataRepresentation { get; }
	public virtual AVCaptureLensStabilizationStatus LensStabilizationStatus { get; }
	public virtual IntPtr PhotoCount { get; }
	public virtual CoreVideo.CVPixelBuffer PixelBuffer { get; }
	public virtual AVPortraitEffectsMatte PortraitEffectsMatte { get; }
	public virtual CoreGraphics.CGImage PreviewCGImageRepresentation { get; }
	public virtual CoreVideo.CVPixelBuffer PreviewPixelBuffer { get; }
	public CoreGraphics.CGImageProperties Properties { get; }
	public virtual bool RawPhoto { get; }
	public virtual AVCaptureResolvedPhotoSettings ResolvedSettings { get; }
	public virtual IntPtr SequenceCount { get; }
	public AVCaptureDeviceType SourceDeviceType { get; }
	public virtual CoreMedia.CMTime Timestamp { get; }
	public virtual Foundation.NSDictionary WeakEmbeddedThumbnailPhotoFormat { get; }
	public virtual Foundation.NSDictionary WeakMetadata { get; }
	public virtual Foundation.NSString WeakSourceDeviceType { get; }
	// methods
	public virtual Foundation.NSData GetFileDataRepresentation (IAVCapturePhotoFileDataRepresentationCustomizer customizer);
	public virtual Foundation.NSData GetFileDataRepresentation (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementMetadata, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormat, CoreVideo.CVPixelBuffer replacementEmbeddedThumbnailPixelBuffer, AVDepthData replacementDepthData);
	public virtual AVSemanticSegmentationMatte GetSemanticSegmentationMatte (AVSemanticSegmentationMatteType semanticSegmentationMatteType);
}
```

#### New Type: AVFoundation.AVCapturePhotoBracketSettings

```csharp
public class AVCapturePhotoBracketSettings : AVFoundation.AVCapturePhotoSettings {
	// constructors
	protected AVCapturePhotoBracketSettings (Foundation.NSObjectFlag t);
	protected AVCapturePhotoBracketSettings (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVCaptureBracketedStillImageSettings[] BracketedSettings { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool IsLensStabilizationEnabled { get; set; }
	// methods
	public static AVCapturePhotoBracketSettings FromPhotoBracketSettings (uint rawPixelFormatType, string rawFileType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat, string processedFileType, AVCaptureBracketedStillImageSettings[] bracketedSettings);
	public static AVCapturePhotoBracketSettings FromRawPixelFormatType (uint rawPixelFormatType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> format, AVCaptureBracketedStillImageSettings[] bracketedSettings);
}
```

#### New Type: AVFoundation.AVCapturePhotoCaptureDelegate

```csharp
public class AVCapturePhotoCaptureDelegate : Foundation.NSObject, IAVCapturePhotoCaptureDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCapturePhotoCaptureDelegate ();
	protected AVCapturePhotoCaptureDelegate (Foundation.NSObjectFlag t);
	protected AVCapturePhotoCaptureDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void DidFinishCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public virtual void DidFinishProcessingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public virtual void DidFinishProcessingPhoto (AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
	public virtual void DidFinishRecordingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void WillBeginCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void WillCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
```

#### New Type: AVFoundation.AVCapturePhotoCaptureDelegate_Extensions

```csharp
public static class AVCapturePhotoCaptureDelegate_Extensions {
	// methods
	public static void DidCapturePhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public static void DidFinishCapture (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public static void DidFinishProcessingLivePhotoMovie (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public static void DidFinishProcessingPhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
	public static void DidFinishRecordingLivePhotoMovie (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
	public static void WillBeginCapture (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public static void WillCapturePhoto (this IAVCapturePhotoCaptureDelegate This, AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
```

#### New Type: AVFoundation.AVCapturePhotoFileDataRepresentationCustomizer_Extensions

```csharp
public static class AVCapturePhotoFileDataRepresentationCustomizer_Extensions {
	// methods
	public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementAppleProRawCompressionSettings (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> defaultSettings, IntPtr maximumBitDepth);
	public static AVDepthData GetReplacementDepthData (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
	public static CoreVideo.CVPixelBuffer GetReplacementEmbeddedThumbnail (this IAVCapturePhotoFileDataRepresentationCustomizer This, out Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormatOut, AVCapturePhoto photo);
	public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementMetadata (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
	public static AVPortraitEffectsMatte GetReplacementPortraitEffectsMatte (this IAVCapturePhotoFileDataRepresentationCustomizer This, AVCapturePhoto photo);
	public static AVSemanticSegmentationMatte GetReplacementSemanticSegmentationMatte (this IAVCapturePhotoFileDataRepresentationCustomizer This, Foundation.NSString semanticSegmentationMatteType, AVCapturePhoto photo);
}
```

#### New Type: AVFoundation.AVCapturePhotoOutput

```csharp
public class AVCapturePhotoOutput : AVFoundation.AVCaptureOutput {
	// constructors
	public AVCapturePhotoOutput ();
	protected AVCapturePhotoOutput (Foundation.NSObjectFlag t);
	protected AVCapturePhotoOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual bool AppleProRawEnabled { get; set; }
	public virtual bool AppleProRawSupported { get; }
	public virtual bool AutoRedEyeReductionSupported { get; }
	public virtual string[] AvailableLivePhotoVideoCodecTypes { get; }
	public virtual string[] AvailablePhotoCodecTypes { get; }
	public virtual Foundation.NSNumber[] AvailablePhotoPixelFormatTypes { get; }
	public virtual AVVideoCodecType[] AvailableRawPhotoCodecTypes { get; }
	public virtual Foundation.NSNumber[] AvailableRawPhotoPixelFormatTypes { get; }
	public virtual AVSemanticSegmentationMatteType[] AvailableSemanticSegmentationMatteTypes { get; }
	public virtual bool CameraCalibrationDataDeliverySupported { get; }
	public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool ConstantColorEnabled { get; set; }
	public virtual bool ConstantColorSupported { get; }
	public virtual bool ContentAwareDistortionCorrectionEnabled { get; set; }
	public virtual bool ContentAwareDistortionCorrectionSupported { get; }
	public virtual bool DepthDataDeliveryEnabled { get; set; }
	public virtual bool DepthDataDeliverySupported { get; }
	public virtual bool DualCameraDualPhotoDeliveryEnabled { get; set; }
	public virtual bool DualCameraDualPhotoDeliverySupported { get; }
	public virtual bool DualCameraFusionSupported { get; }
	public virtual AVSemanticSegmentationMatteType[] EnabledSemanticSegmentationMatteTypes { get; set; }
	public virtual bool FastCapturePrioritizationEnabled { get; set; }
	public virtual bool FastCapturePrioritizationSupported { get; set; }
	public AVFileTypes[] GetAvailablePhotoFileTypes { get; }
	public AVFileTypes[] GetAvailableRawPhotoFileTypes { get; }
	public virtual bool IsFlashScene { get; }
	public virtual bool IsHighResolutionCaptureEnabled { get; set; }
	public virtual bool IsLensStabilizationDuringBracketedCaptureSupported { get; }
	public virtual bool IsLivePhotoAutoTrimmingEnabled { get; set; }
	public virtual bool IsLivePhotoCaptureEnabled { get; set; }
	public virtual bool IsLivePhotoCaptureSupported { get; }
	public virtual bool IsLivePhotoCaptureSuspended { get; set; }
	public virtual bool IsStillImageStabilizationScene { get; }
	public virtual bool IsStillImageStabilizationSupported { get; }
	public virtual UIntPtr MaxBracketedCapturePhotoCount { get; }
	public virtual CoreMedia.CMVideoDimensions MaxPhotoDimensions { get; set; }
	public virtual AVCapturePhotoQualityPrioritization MaxPhotoQualityPrioritization { get; set; }
	public virtual AVCapturePhotoSettings PhotoSettingsForSceneMonitoring { get; set; }
	public virtual bool PortraitEffectsMatteDeliveryEnabled { get; set; }
	public virtual bool PortraitEffectsMatteDeliverySupported { get; }
	public virtual AVCapturePhotoSettings[] PreparedPhotoSettings { get; }
	public virtual bool PreservesLivePhotoCaptureSuspendedOnSessionStop { get; set; }
	public virtual bool ResponsiveCaptureEnabled { get; set; }
	public virtual bool ResponsiveCaptureSupported { get; }
	public virtual bool ShutterSoundSuppressionSupported { get; }
	public virtual AVCaptureFlashMode[] SupportedFlashModes { get; }
	public virtual bool VirtualDeviceConstituentPhotoDeliveryEnabled { get; set; }
	public virtual bool VirtualDeviceConstituentPhotoDeliverySupported { get; }
	public virtual bool VirtualDeviceFusionSupported { get; }
	public virtual bool ZeroShutterLagEnabled { get; set; }
	public virtual bool ZeroShutterLagSupported { get; }
	// methods
	public virtual void CapturePhoto (AVCapturePhotoSettings settings, IAVCapturePhotoCaptureDelegate cb);
	protected override void Dispose (bool disposing);
	public static Foundation.NSData GetDngPhotoDataRepresentation (CoreMedia.CMSampleBuffer rawSampleBuffer, CoreMedia.CMSampleBuffer previewPhotoSampleBuffer);
	public static Foundation.NSData GetJpegPhotoDataRepresentation (CoreMedia.CMSampleBuffer JPEGSampleBuffer, CoreMedia.CMSampleBuffer previewPhotoSampleBuffer);
	public AVVideoCodecType[] GetSupportedPhotoCodecTypesForFileType (string fileType);
	public virtual Foundation.NSNumber[] GetSupportedPhotoPixelFormatTypesForFileType (string fileType);
	public virtual AVVideoCodecType[] GetSupportedRawPhotoCodecTypes (CoreVideo.CVPixelFormatType rawPixelFormatType, AVFileTypes fileType);
	public virtual Foundation.NSNumber[] GetSupportedRawPhotoPixelFormatTypesForFileType (string fileType);
	public static bool IsAppleProRawPixelFormat (CoreVideo.CVPixelFormatType pixelFormat);
	public static bool IsBayerRawPixelFormat (CoreVideo.CVPixelFormatType pixelFormat);
	public virtual void SetPreparedPhotoSettings (AVCapturePhotoSettings[] preparedPhotoSettingsArray, System.Action<System.Boolean,Foundation.NSError> completionHandler);
	public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> SetPreparedPhotoSettingsAsync (AVCapturePhotoSettings[] preparedPhotoSettingsArray);
}
```

#### New Type: AVFoundation.AVCapturePhotoOutputCaptureReadiness

```csharp
[Serializable]
public enum AVCapturePhotoOutputCaptureReadiness {
	NotReadyMomentarily = 2,
	NotReadyWaitingForCapture = 3,
	NotReadyWaitingForProcessing = 4,
	Ready = 1,
	SessionNotRunning = 0,
}
```

#### New Type: AVFoundation.AVCapturePhotoOutputReadinessCoordinator

```csharp
public class AVCapturePhotoOutputReadinessCoordinator : Foundation.NSObject {
	// constructors
	public AVCapturePhotoOutputReadinessCoordinator (AVCapturePhotoOutput photoOutput);
	protected AVCapturePhotoOutputReadinessCoordinator (Foundation.NSObjectFlag t);
	protected AVCapturePhotoOutputReadinessCoordinator (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVCapturePhotoOutputCaptureReadiness CaptureReadiness { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public IAVCapturePhotoOutputReadinessCoordinatorDelegate Delegate { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
	public virtual void StartTrackingCaptureRequest (AVCapturePhotoSettings settings);
	public virtual void StopTrackingCaptureRequest (long settingsUniqueId);
}
```

#### New Type: AVFoundation.AVCapturePhotoOutputReadinessCoordinatorDelegate

```csharp
public class AVCapturePhotoOutputReadinessCoordinatorDelegate : Foundation.NSObject, IAVCapturePhotoOutputReadinessCoordinatorDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCapturePhotoOutputReadinessCoordinatorDelegate ();
	protected AVCapturePhotoOutputReadinessCoordinatorDelegate (Foundation.NSObjectFlag t);
	protected AVCapturePhotoOutputReadinessCoordinatorDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}
```

#### New Type: AVFoundation.AVCapturePhotoQualityPrioritization

```csharp
[Serializable]
public enum AVCapturePhotoQualityPrioritization {
	Balanced = 2,
	Quality = 3,
	Speed = 1,
}
```

#### New Type: AVFoundation.AVCapturePhotoSettings

```csharp
public class AVCapturePhotoSettings : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected AVCapturePhotoSettings (Foundation.NSObjectFlag t);
	protected AVCapturePhotoSettings (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual bool AutoContentAwareDistortionCorrectionEnabled { get; set; }
	public virtual bool AutoDualCameraFusionEnabled { get; set; }
	public virtual bool AutoRedEyeReductionEnabled { get; set; }
	public virtual bool AutoVirtualDeviceFusionEnabled { get; set; }
	public virtual AVVideoCodecType[] AvailableEmbeddedThumbnailPhotoCodecTypes { get; }
	public virtual Foundation.NSNumber[] AvailablePreviewPhotoPixelFormatTypes { get; }
	public virtual AVVideoCodecType[] AvailableRawEmbeddedThumbnailPhotoCodecTypes { get; }
	public virtual bool CameraCalibrationDataDeliveryEnabled { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool ConstantColorEnabled { get; set; }
	public virtual bool ConstantColorFallbackPhotoDeliveryEnabled { get; set; }
	public virtual bool DepthDataDeliveryEnabled { get; set; }
	public virtual bool DepthDataFiltered { get; set; }
	public virtual bool DualCameraDualPhotoDeliveryEnabled { get; set; }
	public AVCapturePhotoSettingsThumbnailFormat EmbeddedThumbnailPhotoFormat { get; set; }
	public virtual bool EmbedsDepthDataInPhoto { get; set; }
	public virtual bool EmbedsPortraitEffectsMatteInPhoto { get; set; }
	public virtual bool EmbedsSemanticSegmentationMattesInPhoto { get; set; }
	public virtual AVSemanticSegmentationMatteType[] EnabledSemanticSegmentationMatteTypes { get; set; }
	public virtual AVCaptureFlashMode FlashMode { get; set; }
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> Format { get; }
	public virtual bool IsAutoStillImageStabilizationEnabled { get; set; }
	public virtual bool IsHighResolutionPhotoEnabled { get; set; }
	public virtual Foundation.NSUrl LivePhotoMovieFileUrl { get; set; }
	public virtual AVMetadataItem[] LivePhotoMovieMetadata { get; set; }
	public virtual string LivePhotoVideoCodecType { get; set; }
	public virtual CoreMedia.CMVideoDimensions MaxPhotoDimensions { get; set; }
	public virtual Foundation.NSDictionary Metadata { get; set; }
	public virtual AVCapturePhotoQualityPrioritization PhotoQualityPrioritization { get; set; }
	public virtual bool PortraitEffectsMatteDeliveryEnabled { get; set; }
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> PreviewPhotoFormat { get; set; }
	public virtual string ProcessedFileType { get; }
	public AVCapturePhotoSettingsThumbnailFormat RawEmbeddedThumbnailPhotoFormat { get; set; }
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> RawFileFormat { get; set; }
	public virtual string RawFileType { get; }
	public virtual uint RawPhotoPixelFormatType { get; }
	public virtual bool ShutterSoundSuppressionEnabled { get; set; }
	public virtual long UniqueID { get; }
	public virtual AVCaptureDevice[] VirtualDeviceConstituentPhotoDeliveryEnabledDevices { get; set; }
	public virtual Foundation.NSDictionary WeakEmbeddedThumbnailPhotoFormat { get; set; }
	public virtual Foundation.NSDictionary WeakRawEmbeddedThumbnailPhotoFormat { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static AVCapturePhotoSettings Create ();
	protected override void Dispose (bool disposing);
	public static AVCapturePhotoSettings FromFormat (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> format);
	public static AVCapturePhotoSettings FromPhotoSettings (AVCapturePhotoSettings photoSettings);
	public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType);
	public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat);
	public static AVCapturePhotoSettings FromRawPixelFormatType (uint rawPixelFormatType, string rawFileType, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> processedFormat, string processedFileType);
}
```

#### New Type: AVFoundation.AVCapturePhotoSettingsThumbnailFormat

```csharp
public class AVCapturePhotoSettingsThumbnailFormat : Foundation.DictionaryContainer {
	// constructors
	public AVCapturePhotoSettingsThumbnailFormat ();
	public AVCapturePhotoSettingsThumbnailFormat (Foundation.NSDictionary dictionary);
	// properties
	public Foundation.NSString Codec { get; set; }
	public Foundation.NSNumber Height { get; set; }
	public Foundation.NSNumber Width { get; set; }
}
```

#### New Type: AVFoundation.AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions

```csharp
[Serializable]
[Flags]
public enum AVCapturePrimaryConstituentDeviceRestrictedSwitchingBehaviorConditions {
	ExposureModeChanged = 4,
	FocusModeChanged = 2,
	None = 0,
	VideoZoomChanged = 1,
}
```

#### New Type: AVFoundation.AVCapturePrimaryConstituentDeviceSwitchingBehavior

```csharp
[Serializable]
public enum AVCapturePrimaryConstituentDeviceSwitchingBehavior {
	Auto = 1,
	Locked = 3,
	Restricted = 2,
	Unsupported = 0,
}
```

#### New Type: AVFoundation.AVCaptureReactionEffectState

```csharp
public class AVCaptureReactionEffectState : Foundation.NSObject {
	// constructors
	public AVCaptureReactionEffectState ();
	protected AVCaptureReactionEffectState (Foundation.NSObjectFlag t);
	protected AVCaptureReactionEffectState (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMTime EndTime { get; }
	public virtual string ReactionType { get; }
	public virtual CoreMedia.CMTime StartTime { get; }
}
```

#### New Type: AVFoundation.AVCaptureReactionType_Extensions

```csharp
public static class AVCaptureReactionType_Extensions {
	// methods
	public static string GetSystemImage (this AVCaptureReactionType reactionType);
}
```

#### New Type: AVFoundation.AVCaptureResolvedPhotoSettings

```csharp
public class AVCaptureResolvedPhotoSettings : Foundation.NSObject {
	// constructors
	protected AVCaptureResolvedPhotoSettings (Foundation.NSObjectFlag t);
	protected AVCaptureResolvedPhotoSettings (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool ContentAwareDistortionCorrectionEnabled { get; }
	public virtual bool DualCameraFusionEnabled { get; }
	public virtual CoreMedia.CMVideoDimensions EmbeddedThumbnailDimensions { get; }
	public virtual UIntPtr ExpectedPhotoCount { get; }
	public virtual bool FastCapturePrioritizationEnabled { get; }
	public virtual bool IsFlashEnabled { get; }
	public virtual CoreMedia.CMVideoDimensions LivePhotoMovieDimensions { get; }
	public virtual CoreMedia.CMVideoDimensions PhotoDimensions { get; }
	public virtual CoreMedia.CMTimeRange PhotoProcessingTimeRange { get; }
	public virtual CoreMedia.CMVideoDimensions PortraitEffectsMatteDimensions { get; }
	public virtual CoreMedia.CMVideoDimensions PreviewDimensions { get; }
	public virtual CoreMedia.CMVideoDimensions RawEmbeddedThumbnailDimensions { get; }
	public virtual CoreMedia.CMVideoDimensions RawPhotoDimensions { get; }
	public virtual bool RedEyeReductionEnabled { get; }
	public virtual long UniqueID { get; }
	public virtual bool VirtualDeviceFusionEnabled { get; }
	// methods
	public virtual CoreMedia.CMVideoDimensions GetDimensions (AVSemanticSegmentationMatteType semanticSegmentationMatteType);
}
```

#### New Type: AVFoundation.AVCaptureSessionControlsDelegate

```csharp
public abstract class AVCaptureSessionControlsDelegate : Foundation.NSObject, IAVCaptureSessionControlsDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected AVCaptureSessionControlsDelegate ();
	protected AVCaptureSessionControlsDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureSessionControlsDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidBecomeActive (AVCaptureSession session);
	public virtual void DidBecomeInactive (AVCaptureSession session);
	public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
	public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}
```

#### New Type: AVFoundation.AVCaptureSessionInterruptionReason

```csharp
[Serializable]
public enum AVCaptureSessionInterruptionReason {
	AudioDeviceInUseByAnotherClient = 2,
	VideoDeviceInUseByAnotherClient = 3,
	VideoDeviceNotAvailableDueToSystemPressure = 5,
	VideoDeviceNotAvailableInBackground = 1,
	VideoDeviceNotAvailableWithMultipleForegroundApps = 4,
}
```

#### New Type: AVFoundation.AVCaptureSlider

```csharp
public class AVCaptureSlider : AVFoundation.AVCaptureControl {
	// constructors
	protected AVCaptureSlider (Foundation.NSObjectFlag t);
	protected AVCaptureSlider (ObjCRuntime.NativeHandle handle);
	public AVCaptureSlider (string localizedTitle, string symbolName, float[] values);
	public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue);
	public AVCaptureSlider (string localizedTitle, string symbolName, float minValue, float maxValue, float step);
	// properties
	public virtual string AccessibilityIdentifier { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string LocalizedTitle { get; }
	public virtual string LocalizedValueFormat { get; set; }
	public virtual float[] ProminentValues { get; set; }
	public virtual string SymbolName { get; }
	public virtual float Value { get; set; }
	// methods
	public virtual void SetActionQueue (CoreFoundation.DispatchQueue actionQueue, AVCaptureSliderCallback action);
}
```

#### New Type: AVFoundation.AVCaptureSliderCallback

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

#### New Type: AVFoundation.AVCaptureSynchronizedData

```csharp
public class AVCaptureSynchronizedData : Foundation.NSObject {
	// constructors
	protected AVCaptureSynchronizedData (Foundation.NSObjectFlag t);
	protected AVCaptureSynchronizedData (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMTime Timestamp { get; }
}
```

#### New Type: AVFoundation.AVCaptureSynchronizedDataCollection

```csharp
public class AVCaptureSynchronizedDataCollection : Foundation.NSObject {
	// constructors
	protected AVCaptureSynchronizedDataCollection (Foundation.NSObjectFlag t);
	protected AVCaptureSynchronizedDataCollection (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual UIntPtr Count { get; }
	// methods
	public virtual AVCaptureSynchronizedData GetSynchronizedData (AVCaptureOutput captureOutput);
}
```

#### New Type: AVFoundation.AVCaptureSynchronizedDepthData

```csharp
public class AVCaptureSynchronizedDepthData : AVFoundation.AVCaptureSynchronizedData {
	// constructors
	protected AVCaptureSynchronizedDepthData (Foundation.NSObjectFlag t);
	protected AVCaptureSynchronizedDepthData (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVDepthData DepthData { get; }
	public virtual bool DepthDataWasDropped { get; }
	public virtual AVCaptureOutputDataDroppedReason DroppedReason { get; }
}
```

#### New Type: AVFoundation.AVCaptureSynchronizedMetadataObjectData

```csharp
public class AVCaptureSynchronizedMetadataObjectData : AVFoundation.AVCaptureSynchronizedData {
	// constructors
	public AVCaptureSynchronizedMetadataObjectData ();
	protected AVCaptureSynchronizedMetadataObjectData (Foundation.NSObjectFlag t);
	protected AVCaptureSynchronizedMetadataObjectData (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMetadataObject[] MetadataObjects { get; }
}
```

#### New Type: AVFoundation.AVCaptureSynchronizedSampleBufferData

```csharp
public class AVCaptureSynchronizedSampleBufferData : AVFoundation.AVCaptureSynchronizedData {
	// constructors
	public AVCaptureSynchronizedSampleBufferData ();
	protected AVCaptureSynchronizedSampleBufferData (Foundation.NSObjectFlag t);
	protected AVCaptureSynchronizedSampleBufferData (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureOutputDataDroppedReason DroppedReason { get; }
	public virtual CoreMedia.CMSampleBuffer SampleBuffer { get; }
	public virtual bool SampleBufferWasDropped { get; }
}
```

#### New Type: AVFoundation.AVCaptureSystemExposureBiasSlider

```csharp
public class AVCaptureSystemExposureBiasSlider : AVFoundation.AVCaptureControl {
	// constructors
	public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device);
	protected AVCaptureSystemExposureBiasSlider (Foundation.NSObjectFlag t);
	protected AVCaptureSystemExposureBiasSlider (ObjCRuntime.NativeHandle handle);
	public AVCaptureSystemExposureBiasSlider (AVCaptureDevice device, AVCaptureSystemExposureBiasSliderCallback action);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: AVFoundation.AVCaptureSystemExposureBiasSliderCallback

```csharp
public sealed delegate AVCaptureSystemExposureBiasSliderCallback : System.MulticastDelegate {
	// constructors
	public AVCaptureSystemExposureBiasSliderCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat exposureTargetBias, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (System.Runtime.InteropServices.NFloat exposureTargetBias);
}
```

#### New Type: AVFoundation.AVCaptureSystemPressureFactors

```csharp
[Serializable]
[Flags]
public enum AVCaptureSystemPressureFactors {
	CameraTemperature = 8,
	DepthModuleTemperature = 4,
	None = 0,
	PeakPower = 2,
	SystemTemperature = 1,
}
```

#### New Type: AVFoundation.AVCaptureSystemPressureLevel

```csharp
[Serializable]
public enum AVCaptureSystemPressureLevel {
	Critical = 3,
	Fair = 1,
	Nominal = 0,
	Serious = 2,
	Shutdown = 4,
}
```

#### New Type: AVFoundation.AVCaptureSystemPressureLevelExtensions

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

#### New Type: AVFoundation.AVCaptureSystemPressureState

```csharp
public class AVCaptureSystemPressureState : Foundation.NSObject {
	// constructors
	protected AVCaptureSystemPressureState (Foundation.NSObjectFlag t);
	protected AVCaptureSystemPressureState (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVCaptureSystemPressureFactors Factors { get; }
	public AVCaptureSystemPressureLevel Level { get; }
}
```

#### New Type: AVFoundation.AVCaptureSystemUserInterface

```csharp
[Serializable]
public enum AVCaptureSystemUserInterface {
	MicrophoneModes = 2,
	VideoEffects = 1,
}
```

#### New Type: AVFoundation.AVCaptureSystemZoomSlider

```csharp
public class AVCaptureSystemZoomSlider : AVFoundation.AVCaptureControl {
	// constructors
	public AVCaptureSystemZoomSlider (AVCaptureDevice device);
	protected AVCaptureSystemZoomSlider (Foundation.NSObjectFlag t);
	protected AVCaptureSystemZoomSlider (ObjCRuntime.NativeHandle handle);
	public AVCaptureSystemZoomSlider (AVCaptureDevice device, AVCaptureSystemZoomSliderCallback action);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: AVFoundation.AVCaptureSystemZoomSliderCallback

```csharp
public sealed delegate AVCaptureSystemZoomSliderCallback : System.MulticastDelegate {
	// constructors
	public AVCaptureSystemZoomSliderCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (System.Runtime.InteropServices.NFloat videoZoomFactor, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (System.Runtime.InteropServices.NFloat videoZoomFactor);
}
```

#### New Type: AVFoundation.AVCaptureTorchMode

```csharp
[Serializable]
public enum AVCaptureTorchMode {
	Auto = 2,
	Off = 0,
	On = 1,
}
```

#### New Type: AVFoundation.AVCaptureVideoDataOutput

```csharp
public class AVCaptureVideoDataOutput : AVFoundation.AVCaptureOutput {
	// constructors
	public AVCaptureVideoDataOutput ();
	protected AVCaptureVideoDataOutput (Foundation.NSObjectFlag t);
	protected AVCaptureVideoDataOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual bool AlwaysDiscardsLateVideoFrames { get; set; }
	public virtual bool AutomaticallyConfiguresOutputBufferDimensions { get; set; }
	public virtual CoreVideo.CVPixelFormatType[] AvailableVideoCVPixelFormatTypes { get; }
	public virtual Foundation.NSString[] AvailableVideoCodecTypes { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public AVVideoSettingsCompressed CompressedVideoSetting { get; set; }
	public virtual bool DeliversPreviewSizedOutputBuffers { get; set; }
	public virtual CoreMedia.CMTime MinFrameDuration { get; set; }
	public virtual CoreFoundation.DispatchQueue SampleBufferCallbackQueue { get; }
	public virtual IAVCaptureVideoDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
	public AVVideoSettingsUncompressed UncompressedVideoSetting { get; set; }
	public virtual Foundation.NSDictionary WeakVideoSettings { get; set; }
	// methods
	public virtual string[] GetAvailableVideoCodecTypes (string outputFileType);
	public AVPlayerItemVideoOutputSettings GetRecommendedVideoSettings (string videoCodecType, string outputFileType);
	public AVPlayerItemVideoOutputSettings GetRecommendedVideoSettings (AVVideoCodecType videoCodecType, AVFileTypes outputFileType, Foundation.NSUrl outputFileUrl);
	public virtual Foundation.NSDictionary GetRecommendedVideoSettings (string videoCodecType, string outputFileType, Foundation.NSUrl outputFileUrl);
	public virtual Foundation.NSDictionary GetRecommendedVideoSettingsForAssetWriter (string outputFileType);
	public virtual void SetSampleBufferDelegate (IAVCaptureVideoDataOutputSampleBufferDelegate sampleBufferDelegate, CoreFoundation.DispatchQueue sampleBufferCallbackQueue);
}
```

#### New Type: AVFoundation.AVCaptureVideoDataOutputSampleBufferDelegate

```csharp
public class AVCaptureVideoDataOutputSampleBufferDelegate : Foundation.NSObject, IAVCaptureVideoDataOutputSampleBufferDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVCaptureVideoDataOutputSampleBufferDelegate ();
	protected AVCaptureVideoDataOutputSampleBufferDelegate (Foundation.NSObjectFlag t);
	protected AVCaptureVideoDataOutputSampleBufferDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidDropSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureVideoDataOutputSampleBufferDelegate_Extensions

```csharp
public static class AVCaptureVideoDataOutputSampleBufferDelegate_Extensions {
	// methods
	public static void DidDropSampleBuffer (this IAVCaptureVideoDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
	public static void DidOutputSampleBuffer (this IAVCaptureVideoDataOutputSampleBufferDelegate This, AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.AVCaptureWhiteBalanceMode

```csharp
[Serializable]
public enum AVCaptureWhiteBalanceMode {
	AutoWhiteBalance = 1,
	ContinuousAutoWhiteBalance = 2,
	Locked = 0,
}
```

#### New Type: AVFoundation.AVContinuityDevice

```csharp
public class AVContinuityDevice : Foundation.NSObject {
	// constructors
	protected AVContinuityDevice (Foundation.NSObjectFlag t);
	protected AVContinuityDevice (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual AVAudioSessionPortDescription[] AudioSessionInputs { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool Connected { get; }
	public virtual Foundation.NSUuid ConnectionId { get; }
	public virtual AVCaptureDevice[] VideoDevices { get; }
}
```

#### New Type: AVFoundation.AVExposureBiasRange

```csharp
public class AVExposureBiasRange : Foundation.NSObject {
	// constructors
	protected AVExposureBiasRange (Foundation.NSObjectFlag t);
	protected AVExposureBiasRange (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual float MaxExposureBias { get; }
	public virtual float MinExposureBias { get; }
	// methods
	public virtual bool ContainsExposureBias (float exposureBias);
}
```

#### New Type: AVFoundation.AVExtendedNoteOnEvent

```csharp
public class AVExtendedNoteOnEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVExtendedNoteOnEvent ();
	protected AVExtendedNoteOnEvent (Foundation.NSObjectFlag t);
	protected AVExtendedNoteOnEvent (ObjCRuntime.NativeHandle handle);
	public AVExtendedNoteOnEvent (float midiNote, float velocity, uint groupId, double duration);
	public AVExtendedNoteOnEvent (float midiNote, float velocity, uint instrumentId, uint groupId, double duration);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public static uint DefaultInstrument { get; }
	public virtual double Duration { get; set; }
	public virtual uint GroupId { get; set; }
	public virtual uint InstrumentId { get; set; }
	public virtual float MidiNote { get; set; }
	public virtual float Velocity { get; set; }
}
```

#### New Type: AVFoundation.AVExtendedTempoEvent

```csharp
public class AVExtendedTempoEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVExtendedTempoEvent ();
	protected AVExtendedTempoEvent (Foundation.NSObjectFlag t);
	protected AVExtendedTempoEvent (ObjCRuntime.NativeHandle handle);
	public AVExtendedTempoEvent (double tempo);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual double Tempo { get; set; }
}
```

#### New Type: AVFoundation.AVExternalContentProtectionStatus

```csharp
[Serializable]
public enum AVExternalContentProtectionStatus {
	Insufficient = 2,
	Pending = 0,
	Sufficient = 1,
}
```

#### New Type: AVFoundation.AVExternalStorageDevice

```csharp
public class AVExternalStorageDevice : Foundation.NSObject {
	// constructors
	protected AVExternalStorageDevice (Foundation.NSObjectFlag t);
	protected AVExternalStorageDevice (ObjCRuntime.NativeHandle handle);
	// properties
	public static AVAuthorizationStatus AuthorizationStatus { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool Connected { get; }
	public virtual string DisplayName { get; }
	public virtual IntPtr FreeSize { get; }
	public virtual bool NotRecommendedForCaptureUse { get; }
	public virtual IntPtr TotalSize { get; }
	public virtual Foundation.NSUuid Uuid { get; }
	// methods
	public virtual Foundation.NSUrl[] GetNextAvailableUrls (string[] extensionArray, out Foundation.NSError outError);
	public static void RequestAccess (AVExternalStorageDeviceRequestAccessCallback handler);
	public static System.Threading.Tasks.Task<bool> RequestAccessAsync ();
}
```

#### New Type: AVFoundation.AVExternalStorageDeviceDiscoverySession

```csharp
public class AVExternalStorageDeviceDiscoverySession : Foundation.NSObject {
	// constructors
	protected AVExternalStorageDeviceDiscoverySession (Foundation.NSObjectFlag t);
	protected AVExternalStorageDeviceDiscoverySession (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVExternalStorageDevice[] ExternalStorageDevices { get; }
	public static AVExternalStorageDeviceDiscoverySession SharedSession { get; }
	public static bool Supported { get; }
}
```

#### New Type: AVFoundation.AVExternalStorageDeviceRequestAccessCallback

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

#### New Type: AVFoundation.AVFrameRateRange

```csharp
public class AVFrameRateRange : Foundation.NSObject {
	// constructors
	protected AVFrameRateRange (Foundation.NSObjectFlag t);
	protected AVFrameRateRange (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMTime MaxFrameDuration { get; }
	public virtual double MaxFrameRate { get; }
	public virtual CoreMedia.CMTime MinFrameDuration { get; }
	public virtual double MinFrameRate { get; }
}
```

#### New Type: AVFoundation.AVMetadataBodyObject

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

#### New Type: AVFoundation.AVMetadataCatBodyObject

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

#### New Type: AVFoundation.AVMetadataDogBodyObject

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

#### New Type: AVFoundation.AVMetadataHumanBodyObject

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

#### New Type: AVFoundation.AVMetadataHumanFullBodyObject

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

#### New Type: AVFoundation.AVMetadataSalientObject

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

#### New Type: AVFoundation.AVMetricContentKeyRequestEvent

```csharp
public class AVMetricContentKeyRequestEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricContentKeyRequestEvent (Foundation.NSCoder coder);
	protected AVMetricContentKeyRequestEvent (Foundation.NSObjectFlag t);
	protected AVMetricContentKeyRequestEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVContentKeySpecifier ContentKeySpecifier { get; }
	public virtual bool IsClientInitiated { get; }
	public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
	public virtual string MediaType { get; }
}
```

#### New Type: AVFoundation.AVMetricErrorEvent

```csharp
public class AVMetricErrorEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricErrorEvent (Foundation.NSCoder coder);
	protected AVMetricErrorEvent (Foundation.NSObjectFlag t);
	protected AVMetricErrorEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool DidRecover { get; }
	public virtual Foundation.NSError Error { get; }
}
```

#### New Type: AVFoundation.AVMetricEvent

```csharp
public class AVMetricEvent : Foundation.NSObject, Foundation.INSCoding, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVMetricEvent (Foundation.NSCoder coder);
	protected AVMetricEvent (Foundation.NSObjectFlag t);
	protected AVMetricEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDate Date { get; }
	public virtual CoreMedia.CMTime MediaTime { get; }
	public virtual string SessionId { get; }
	// methods
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}
```

#### New Type: AVFoundation.AVMetricEventStream

```csharp
public class AVMetricEventStream : Foundation.NSObject {
	// constructors
	protected AVMetricEventStream (Foundation.NSObjectFlag t);
	protected AVMetricEventStream (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual bool AddPublisher (IAVMetricEventStreamPublisher publisher);
	public static AVMetricEventStream Create ();
	public virtual bool SetSubscriber (IAVMetricEventStreamSubscriber subscriber, CoreFoundation.DispatchQueue queue);
	public virtual void SubscribeTo (ObjCRuntime.Class metricEventClass);
	public virtual void SubscribeTo (ObjCRuntime.Class[] metricEventsClasses);
	public void SubscribeTo (System.Type metricEventType);
	public void SubscribeTo (System.Type[] metricEventsTypes);
	public virtual void SubscribeToAll ();
}
```

#### New Type: AVFoundation.AVMetricHlsMediaSegmentRequestEvent

```csharp
public class AVMetricHlsMediaSegmentRequestEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricHlsMediaSegmentRequestEvent (Foundation.NSCoder coder);
	protected AVMetricHlsMediaSegmentRequestEvent (Foundation.NSObjectFlag t);
	protected AVMetricHlsMediaSegmentRequestEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSRange ByteRange { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSUrl IndexFileUrl { get; }
	public virtual bool IsMapSegment { get; }
	public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
	public virtual string MediaType { get; }
	public virtual Foundation.NSUrl Url { get; }
}
```

#### New Type: AVFoundation.AVMetricHlsPlaylistRequestEvent

```csharp
public class AVMetricHlsPlaylistRequestEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricHlsPlaylistRequestEvent (Foundation.NSCoder coder);
	protected AVMetricHlsPlaylistRequestEvent (Foundation.NSObjectFlag t);
	protected AVMetricHlsPlaylistRequestEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool IsMultivariantPlaylist { get; }
	public virtual AVMetricMediaResourceRequestEvent MediaResourceRequestEvent { get; }
	public virtual string MediaType { get; }
	public virtual Foundation.NSUrl Url { get; }
}
```

#### New Type: AVFoundation.AVMetricMediaResourceRequestEvent

```csharp
public class AVMetricMediaResourceRequestEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricMediaResourceRequestEvent (Foundation.NSCoder coder);
	protected AVMetricMediaResourceRequestEvent (Foundation.NSObjectFlag t);
	protected AVMetricMediaResourceRequestEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual Foundation.NSRange ByteRange { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMetricErrorEvent ErrorEvent { get; }
	public virtual Foundation.NSUrlSessionTaskMetrics NetworkTransactionMetrics { get; }
	public virtual bool ReadFromCache { get; }
	public virtual Foundation.NSDate RequestEndTime { get; }
	public virtual Foundation.NSDate RequestStartTime { get; }
	public virtual Foundation.NSDate ResponseEndTime { get; }
	public virtual Foundation.NSDate ResponseStartTime { get; }
	public virtual string ServerAddress { get; }
	public virtual Foundation.NSUrl Url { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemInitialLikelyToKeepUpEvent

```csharp
public class AVMetricPlayerItemInitialLikelyToKeepUpEvent : AVFoundation.AVMetricPlayerItemLikelyToKeepUpEvent {
	// constructors
	public AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemInitialLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMetricContentKeyRequestEvent[] ContentKeyRequestEvents { get; }
	public virtual AVMetricHlsMediaSegmentRequestEvent[] MediaSegmentRequestEvents { get; }
	public virtual AVMetricHlsPlaylistRequestEvent[] PlaylistRequestEvents { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemLikelyToKeepUpEvent

```csharp
public class AVMetricPlayerItemLikelyToKeepUpEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemLikelyToKeepUpEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemLikelyToKeepUpEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
	public virtual double TimeTaken { get; }
	public virtual AVAssetVariant Variant { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemPlaybackSummaryEvent

```csharp
public class AVMetricPlayerItemPlaybackSummaryEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemPlaybackSummaryEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemPlaybackSummaryEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMetricErrorEvent ErrorEvent { get; }
	public virtual IntPtr MediaResourceRequestCount { get; }
	public virtual IntPtr PlaybackDuration { get; }
	public virtual IntPtr RecoverableErrorCount { get; }
	public virtual IntPtr StallCount { get; }
	public virtual double TimeSpentInInitialStartup { get; }
	public virtual double TimeSpentRecoveringFromStall { get; }
	public virtual IntPtr TimeWeightedAverageBitrate { get; }
	public virtual IntPtr TimeWeightedPeakBitrate { get; }
	public virtual IntPtr VariantSwitchCount { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemRateChangeEvent

```csharp
public class AVMetricPlayerItemRateChangeEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricPlayerItemRateChangeEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemRateChangeEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemRateChangeEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual double PreviousRate { get; }
	public virtual double Rate { get; }
	public virtual AVAssetVariant Variant { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemSeekDidCompleteEvent

```csharp
public class AVMetricPlayerItemSeekDidCompleteEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
	// constructors
	public AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemSeekDidCompleteEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemSeekDidCompleteEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool DidSeekInBuffer { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemSeekEvent

```csharp
public class AVMetricPlayerItemSeekEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
	// constructors
	public AVMetricPlayerItemSeekEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemSeekEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemSeekEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemStallEvent

```csharp
public class AVMetricPlayerItemStallEvent : AVFoundation.AVMetricPlayerItemRateChangeEvent {
	// constructors
	public AVMetricPlayerItemStallEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemStallEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemStallEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemVariantSwitchEvent

```csharp
public class AVMetricPlayerItemVariantSwitchEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricPlayerItemVariantSwitchEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemVariantSwitchEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemVariantSwitchEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual bool DidSucceed { get; }
	public virtual AVAssetVariant FromVariant { get; }
	public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
	public virtual AVAssetVariant ToVariant { get; }
}
```

#### New Type: AVFoundation.AVMetricPlayerItemVariantSwitchStartEvent

```csharp
public class AVMetricPlayerItemVariantSwitchStartEvent : AVFoundation.AVMetricEvent {
	// constructors
	public AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSCoder coder);
	protected AVMetricPlayerItemVariantSwitchStartEvent (Foundation.NSObjectFlag t);
	protected AVMetricPlayerItemVariantSwitchStartEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVAssetVariant FromVariant { get; }
	public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
	public virtual AVAssetVariant ToVariant { get; }
}
```

#### New Type: AVFoundation.AVMidiChannelEvent

```csharp
public class AVMidiChannelEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVMidiChannelEvent ();
	protected AVMidiChannelEvent (Foundation.NSObjectFlag t);
	protected AVMidiChannelEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual uint Channel { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
}
```

#### New Type: AVFoundation.AVMidiChannelPressureEvent

```csharp
public class AVMidiChannelPressureEvent : AVFoundation.AVMidiChannelEvent {
	// constructors
	public AVMidiChannelPressureEvent ();
	protected AVMidiChannelPressureEvent (Foundation.NSObjectFlag t);
	protected AVMidiChannelPressureEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiChannelPressureEvent (uint channel, uint pressure);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint Pressure { get; set; }
}
```

#### New Type: AVFoundation.AVMidiControlChangeEvent

```csharp
public class AVMidiControlChangeEvent : AVFoundation.AVMidiChannelEvent {
	// constructors
	public AVMidiControlChangeEvent ();
	protected AVMidiControlChangeEvent (Foundation.NSObjectFlag t);
	protected AVMidiControlChangeEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiControlChangeEvent (uint channel, AVMidiControlChangeMessageType messageType, uint value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMidiControlChangeMessageType MessageType { get; }
	public virtual uint Value { get; }
}
```

#### New Type: AVFoundation.AVMidiControlChangeMessageType

```csharp
[Serializable]
public enum AVMidiControlChangeMessageType {
	AllNotesOff = 123,
	AllSoundOff = 120,
	AttackTime = 73,
	Balance = 8,
	BankSelect = 0,
	Breath = 2,
	Brightness = 74,
	ChorusLevel = 93,
	DataEntry = 6,
	DecayTime = 75,
	Expression = 11,
	FilterResonance = 71,
	Foot = 4,
	Hold2Pedal = 69,
	LegatoPedal = 68,
	ModWheel = 1,
	MonoModeOff = 127,
	MonoModeOn = 126,
	OmniModeOff = 124,
	OmniModeOn = 125,
	Pan = 10,
	Portamento = 65,
	PortamentoTime = 5,
	ReleaseTime = 72,
	ResetAllControllers = 121,
	ReverbLevel = 91,
	RpnLsb = 100,
	RpnMsb = 101,
	Soft = 67,
	Sostenuto = 66,
	Sustain = 64,
	VibratoDelay = 78,
	VibratoDepth = 77,
	VibratoRate = 76,
	Volume = 7,
}
```

#### New Type: AVFoundation.AVMidiMetaEvent

```csharp
public class AVMidiMetaEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVMidiMetaEvent ();
	protected AVMidiMetaEvent (Foundation.NSObjectFlag t);
	protected AVMidiMetaEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiMetaEvent (AVMidiMetaEventType type, Foundation.NSData data);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVMidiMetaEventType Type { get; }
}
```

#### New Type: AVFoundation.AVMidiMetaEventType

```csharp
[Serializable]
public enum AVMidiMetaEventType {
	Copyright = 2,
	CuePoint = 7,
	EndOfTrack = 47,
	Instrument = 4,
	KeySignature = 89,
	Lyric = 5,
	Marker = 6,
	MidiChannel = 32,
	MidiPort = 33,
	ProprietaryEvent = 127,
	SequenceNumber = 0,
	SmpteOffset = 84,
	Tempo = 81,
	Text = 1,
	TimeSignature = 88,
	TrackName = 3,
}
```

#### New Type: AVFoundation.AVMidiNoteEvent

```csharp
public class AVMidiNoteEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVMidiNoteEvent ();
	protected AVMidiNoteEvent (Foundation.NSObjectFlag t);
	protected AVMidiNoteEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiNoteEvent (uint channel, uint keyNum, uint velocity, double duration);
	// properties
	public virtual uint Channel { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual double Duration { get; set; }
	public virtual uint Key { get; set; }
	public virtual uint Velocity { get; set; }
}
```

#### New Type: AVFoundation.AVMidiPitchBendEvent

```csharp
public class AVMidiPitchBendEvent : AVFoundation.AVMidiChannelEvent {
	// constructors
	public AVMidiPitchBendEvent ();
	protected AVMidiPitchBendEvent (Foundation.NSObjectFlag t);
	protected AVMidiPitchBendEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiPitchBendEvent (uint channel, uint value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint Value { get; set; }
}
```

#### New Type: AVFoundation.AVMidiPolyPressureEvent

```csharp
public class AVMidiPolyPressureEvent : AVFoundation.AVMidiChannelEvent {
	// constructors
	public AVMidiPolyPressureEvent ();
	protected AVMidiPolyPressureEvent (Foundation.NSObjectFlag t);
	protected AVMidiPolyPressureEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiPolyPressureEvent (uint channel, uint key, uint pressure);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint Key { get; set; }
	public virtual uint Pressure { get; set; }
}
```

#### New Type: AVFoundation.AVMidiProgramChangeEvent

```csharp
public class AVMidiProgramChangeEvent : AVFoundation.AVMidiChannelEvent {
	// constructors
	public AVMidiProgramChangeEvent ();
	protected AVMidiProgramChangeEvent (Foundation.NSObjectFlag t);
	protected AVMidiProgramChangeEvent (ObjCRuntime.NativeHandle handle);
	public AVMidiProgramChangeEvent (uint channel, uint programNumber);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint ProgramNumber { get; set; }
}
```

#### New Type: AVFoundation.AVMidiSysexEvent

```csharp
public class AVMidiSysexEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVMidiSysexEvent ();
	public AVMidiSysexEvent (Foundation.NSData data);
	protected AVMidiSysexEvent (Foundation.NSObjectFlag t);
	protected AVMidiSysexEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint SizeInBytes { get; }
}
```

#### New Type: AVFoundation.AVMusicEvent

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

#### New Type: AVFoundation.AVMusicEventEnumerationBlock

```csharp
public sealed delegate AVMusicEventEnumerationBlock : System.MulticastDelegate {
	// constructors
	public AVMusicEventEnumerationBlock (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (AVMusicEvent event, out double timeStamp, out bool removeEvent, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (out double timeStamp, out bool removeEvent, System.IAsyncResult result);
	public virtual void Invoke (AVMusicEvent event, out double timeStamp, out bool removeEvent);
}
```

#### New Type: AVFoundation.AVMusicUserEvent

```csharp
public class AVMusicUserEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVMusicUserEvent ();
	public AVMusicUserEvent (Foundation.NSData data);
	protected AVMusicUserEvent (Foundation.NSObjectFlag t);
	protected AVMusicUserEvent (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint SizeInBytes { get; }
}
```

#### New Type: AVFoundation.AVMutableCompositionInsertHandler

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

#### New Type: AVFoundation.AVMutableVideoCompositionCreateApplier

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

#### New Type: AVFoundation.AVMutableVideoCompositionCreateCallback

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

#### New Type: AVFoundation.AVParameterEvent

```csharp
public class AVParameterEvent : AVFoundation.AVMusicEvent {
	// constructors
	public AVParameterEvent ();
	protected AVParameterEvent (Foundation.NSObjectFlag t);
	protected AVParameterEvent (ObjCRuntime.NativeHandle handle);
	public AVParameterEvent (uint parameterId, uint scope, uint element, float value);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual uint Element { get; set; }
	public virtual uint ParameterId { get; set; }
	public virtual uint Scope { get; set; }
	public virtual float Value { get; set; }
}
```

#### New Type: AVFoundation.AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason

```csharp
[Serializable]
public enum AVPlayerIntegratedTimelineSnapshotsOutOfSyncReason {
	CurrentSegmentChanged = 1,
	LoadedTimeRangesChanged = 2,
	SegmentsChanged = 0,
}
```

#### New Type: AVFoundation.AVPlayerIntegratedTimelineSnapshotsOutOfSyncReasonExtensions

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

#### New Type: AVFoundation.AVPlayerInterstitialEventAssetListResponseStatus

```csharp
[Serializable]
public enum AVPlayerInterstitialEventAssetListResponseStatus {
	Available = 0,
	Cleared = 1,
	Unavailable = 2,
}
```

#### New Type: AVFoundation.AVPlayerInterstitialEventCue

```csharp
[Serializable]
public enum AVPlayerInterstitialEventCue {
	JoinCue = 1,
	LeaveCue = 2,
	NoCue = 0,
}
```

#### New Type: AVFoundation.AVPlayerInterstitialEventCueExtensions

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

#### New Type: AVFoundation.AVPlayerInterstitialEventTimelineOccupancy

```csharp
[Serializable]
public enum AVPlayerInterstitialEventTimelineOccupancy {
	Fill = 1,
	SinglePoint = 0,
}
```

#### New Type: AVFoundation.AVPlayerItemIntegratedTimeline

```csharp
public class AVPlayerItemIntegratedTimeline : Foundation.NSObject {
	// constructors
	protected AVPlayerItemIntegratedTimeline (Foundation.NSObjectFlag t);
	protected AVPlayerItemIntegratedTimeline (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDate CurrentDate { get; }
	public virtual AVPlayerItemIntegratedTimelineSnapshot CurrentSnapshot { get; }
	public virtual CoreMedia.CMTime CurrentTime { get; }
	// methods
	public virtual IAVPlayerItemIntegratedTimelineObserver AddBoundaryTimeObserver (AVPlayerItemSegment segment, CoreMedia.CMTime[] offsetsIntoSegment, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback callback);
	public virtual IAVPlayerItemIntegratedTimelineObserver AddPeriodicTimeObserver (CoreMedia.CMTime interval, CoreFoundation.DispatchQueue queue, AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback callback);
	public virtual void RemoveTimeObserver (IAVPlayerItemIntegratedTimelineObserver observer);
	public virtual void SeekToDate (Foundation.NSDate date, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
	public virtual System.Threading.Tasks.Task<bool> SeekToDateAsync (Foundation.NSDate date);
	public virtual void SeekToTime (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter, AVPlayerItemIntegratedTimelineSeekCallback completionHandler);
	public virtual System.Threading.Tasks.Task<bool> SeekToTimeAsync (CoreMedia.CMTime time, CoreMedia.CMTime toleranceBefore, CoreMedia.CMTime toleranceAfter);
}
```

#### New Type: AVFoundation.AVPlayerItemIntegratedTimelineAddBoundaryTimeObserverCallback

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

#### New Type: AVFoundation.AVPlayerItemIntegratedTimelineAddPeriodicTimeObserverCallback

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

#### New Type: AVFoundation.AVPlayerItemIntegratedTimelineSeekCallback

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

#### New Type: AVFoundation.AVPlayerItemIntegratedTimelineSnapshot

```csharp
public class AVPlayerItemIntegratedTimelineSnapshot : Foundation.NSObject {
	// constructors
	protected AVPlayerItemIntegratedTimelineSnapshot (Foundation.NSObjectFlag t);
	protected AVPlayerItemIntegratedTimelineSnapshot (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDate CurrentDate { get; }
	public virtual AVPlayerItemSegment CurrentSegment { get; }
	public virtual CoreMedia.CMTime CurrentTime { get; }
	public virtual CoreMedia.CMTime Duration { get; }
	public virtual AVPlayerItemSegment[] Segments { get; }
	public static Foundation.NSString SnapshotsOutOfSyncNotification { get; }
	public static Foundation.NSString SnapshotsOutOfSyncReasonKey { get; }
	// methods
	public virtual void Map (CoreMedia.CMTime time, out AVPlayerItemSegment timeSegment, out CoreMedia.CMTime segmentOffset);

	// inner types
	public static class Notifications {
		// methods
		public static Foundation.NSObject ObserveSnapshotsOutOfSync (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveSnapshotsOutOfSync (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
	}
}
```

#### New Type: AVFoundation.AVPlayerItemSegment

```csharp
public class AVPlayerItemSegment : Foundation.NSObject {
	// constructors
	protected AVPlayerItemSegment (Foundation.NSObjectFlag t);
	protected AVPlayerItemSegment (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVPlayerInterstitialEvent InterstitialEvent { get; }
	public virtual CoreMedia.CMTimeRange[] LoadedTimeRanges { get; }
	public virtual AVPlayerItemSegmentType SegmentType { get; }
	public virtual Foundation.NSDate StartDate { get; }
	public virtual CoreMedia.CMTimeMapping TimeMapping { get; }
}
```

#### New Type: AVFoundation.AVPlayerItemSegmentType

```csharp
[Serializable]
public enum AVPlayerItemSegmentType {
	Interstitial = 1,
	Primary = 0,
}
```

#### New Type: AVFoundation.AVPlayerLooperItemOrdering

```csharp
[Serializable]
public enum AVPlayerLooperItemOrdering {
	FollowExistingItems = 1,
	PrecedeExistingItems = 0,
}
```

#### New Type: AVFoundation.AVPlayerVideoOutput

```csharp
public class AVPlayerVideoOutput : Foundation.NSObject {
	// constructors
	public AVPlayerVideoOutput (AVVideoOutputSpecification specification);
	protected AVPlayerVideoOutput (Foundation.NSObjectFlag t);
	protected AVPlayerVideoOutput (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual CoreMedia.CMTaggedBufferGroup CopyTaggedBufferGroup (CoreMedia.CMTime hostTime, out CoreMedia.CMTime presentationTimeStamp, out AVPlayerVideoOutputConfiguration activeConfiguration);
}
```

#### New Type: AVFoundation.AVPlayerVideoOutputConfiguration

```csharp
public class AVPlayerVideoOutputConfiguration : Foundation.NSObject {
	// constructors
	protected AVPlayerVideoOutputConfiguration (Foundation.NSObjectFlag t);
	protected AVPlayerVideoOutputConfiguration (ObjCRuntime.NativeHandle handle);
	// properties
	public virtual CoreMedia.CMTime ActivationTime { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSObject[] DataChannelDescriptions { get; }
	public virtual CoreGraphics.CGAffineTransform PreferredTransform { get; }
	public virtual AVPlayerItem SourcePlayerItem { get; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: AVFoundation.AVRequestAccessStatus

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

#### New Type: AVFoundation.AVSampleBufferGenerator

```csharp
public class AVSampleBufferGenerator : Foundation.NSObject {
	// constructors
	protected AVSampleBufferGenerator (Foundation.NSObjectFlag t);
	protected AVSampleBufferGenerator (ObjCRuntime.NativeHandle handle);
	public AVSampleBufferGenerator (AVAsset asset, CoreMedia.CMTimebase timebase);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, out Foundation.NSError outError);
	public virtual CoreMedia.CMSampleBuffer CreateSampleBuffer (AVSampleBufferRequest request, AVSampleBufferGeneratorBatch batch, out Foundation.NSError outError);
	public virtual AVSampleBufferGeneratorBatch MakeBatch ();
	public static void NotifyOfDataReady (CoreMedia.CMSampleBuffer sbuf, System.Action<System.Boolean,Foundation.NSError> completionHandler);
	public static System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> NotifyOfDataReadyAsync (CoreMedia.CMSampleBuffer sbuf);
}
```

#### New Type: AVFoundation.AVSampleBufferGeneratorBatch

```csharp
public class AVSampleBufferGeneratorBatch : Foundation.NSObject {
	// constructors
	protected AVSampleBufferGeneratorBatch (Foundation.NSObjectFlag t);
	protected AVSampleBufferGeneratorBatch (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	// methods
	public virtual void Cancel ();
	public virtual void MakeDataReady (AVSampleBufferGeneratorBatchMakeReadyCallback completionHandler);
	public virtual System.Threading.Tasks.Task MakeDataReadyAsync ();
}
```

#### New Type: AVFoundation.AVSampleBufferGeneratorBatchMakeReadyCallback

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

#### New Type: AVFoundation.AVSampleBufferRequest

```csharp
public class AVSampleBufferRequest : Foundation.NSObject {
	// constructors
	public AVSampleBufferRequest (AVSampleCursor startCursor);
	protected AVSampleBufferRequest (Foundation.NSObjectFlag t);
	protected AVSampleBufferRequest (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVSampleBufferRequestDirection Direction { get; set; }
	public virtual AVSampleCursor LimitCursor { get; set; }
	public virtual IntPtr MaxSampleCount { get; set; }
	public virtual AVSampleBufferRequestMode Mode { get; set; }
	public virtual CoreMedia.CMTime OverrideTime { get; set; }
	public virtual IntPtr PreferredMinSampleCount { get; set; }
	public virtual AVSampleCursor StartCursor { get; }
}
```

#### New Type: AVFoundation.AVSampleBufferVideoRenderer

```csharp
public class AVSampleBufferVideoRenderer : Foundation.NSObject, IAVQueuedSampleBufferRendering, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVSampleBufferVideoRenderer ();
	protected AVSampleBufferVideoRenderer (Foundation.NSObjectFlag t);
	protected AVSampleBufferVideoRenderer (ObjCRuntime.NativeHandle handle);
	// properties
	public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotification { get; }
	public static Foundation.NSString AVSampleBufferVideoRendererDidFailToDecodeNotificationErrorKey { get; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSError Error { get; }
	public virtual bool HasSufficientMediaDataForReliablePlaybackStart { get; }
	public virtual bool ReadyForMoreMediaData { get; }
	public virtual bool RequiresFlushToResumeDecoding { get; }
	public static Foundation.NSString RequiresFlushToResumeDecodingDidChangeNotification { get; }
	public virtual AVQueuedSampleBufferRenderingStatus Status { get; }
	public virtual CoreMedia.CMTimebase Timebase { get; }
	// methods
	public virtual CoreVideo.CVPixelBuffer CopyDisplayedPixelBuffer ();
	public virtual void Enqueue (CoreMedia.CMSampleBuffer sampleBuffer);
	public virtual void ExpectMinimumUpcomingSampleBufferPresentationTime (CoreMedia.CMTime minimumUpcomingPresentationTime);
	public virtual void ExpectMonotonicallyIncreasingUpcomingSampleBufferPresentationTimes ();
	public virtual void Flush ();
	public virtual void FlushWithRemovalOfDisplayedImage (bool removeDisplayedImage, System.Action handler);
	public virtual void LoadVideoPerformanceMetrics (AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback completionHandler);
	public virtual System.Threading.Tasks.Task<AVVideoPerformanceMetrics> LoadVideoPerformanceMetricsAsync ();
	public virtual void RequestMediaData (CoreFoundation.DispatchQueue queue, System.Action handler);
	public virtual void ResetUpcomingSampleBufferPresentationTimeExpectations ();
	public virtual void StopRequestingMediaData ();

	// inner types
	public static class Notifications {
		// methods
		public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveAVSampleBufferVideoRendererDidFailToDecode (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
		public static Foundation.NSObject ObserveRequiresFlushToResumeDecodingDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
	}
}
```

#### New Type: AVFoundation.AVSampleBufferVideoRendererLoadVideoPerformanceMetricsCallback

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

#### New Type: AVFoundation.AVSpatialCaptureDiscomfortReason

```csharp
[Serializable]
public enum AVSpatialCaptureDiscomfortReason {
	NotEnoughLight = 0,
	SubjectTooClose = 1,
}
```

#### New Type: AVFoundation.AVSpatialCaptureDiscomfortReasonExtensions

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

#### New Type: AVFoundation.AVSpeechSynthesisMarker

```csharp
public class AVSpeechSynthesisMarker : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVSpeechSynthesisMarker ();
	public AVSpeechSynthesisMarker (Foundation.NSCoder coder);
	protected AVSpeechSynthesisMarker (Foundation.NSObjectFlag t);
	protected AVSpeechSynthesisMarker (ObjCRuntime.NativeHandle handle);
	public AVSpeechSynthesisMarker (AVSpeechSynthesisMarkerMark type, Foundation.NSRange range, UIntPtr byteSampleOffset);
	public AVSpeechSynthesisMarker (Foundation.NSRange range, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerRangeOption option);
	public AVSpeechSynthesisMarker (string value, IntPtr byteSampleOffset, AVSpeechSynthesisMarkerStringOption option);
	// properties
	public virtual string BookmarkName { get; set; }
	public virtual UIntPtr ByteSampleOffset { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVSpeechSynthesisMarkerMark Mark { get; set; }
	public virtual string Phoneme { get; set; }
	public virtual Foundation.NSRange TextRange { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}
```

#### New Type: AVFoundation.AVSpeechSynthesisMarkerMark

```csharp
[Serializable]
public enum AVSpeechSynthesisMarkerMark {
	Bookmark = 4,
	Paragraph = 3,
	Phoneme = 0,
	Sentence = 2,
	Word = 1,
}
```

#### New Type: AVFoundation.AVSpeechSynthesisMarkerRangeOption

```csharp
[Serializable]
public enum AVSpeechSynthesisMarkerRangeOption {
	Paragraph = 2,
	Sentence = 1,
	Word = 0,
}
```

#### New Type: AVFoundation.AVSpeechSynthesisMarkerStringOption

```csharp
[Serializable]
public enum AVSpeechSynthesisMarkerStringOption {
	Bookmark = 1,
	Phoneme = 0,
}
```

#### New Type: AVFoundation.AVSpeechSynthesisPersonalVoiceAuthorizationStatus

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

#### New Type: AVFoundation.AVSpeechSynthesisProviderAudioUnit

```csharp
public class AVSpeechSynthesisProviderAudioUnit : AudioUnit.AUAudioUnit {
	// constructors
	protected AVSpeechSynthesisProviderAudioUnit (Foundation.NSObjectFlag t);
	protected AVSpeechSynthesisProviderAudioUnit (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVSpeechSynthesisProviderOutputBlock SpeechSynthesisOutputMetadataBlock { get; set; }
	public virtual AVSpeechSynthesisProviderVoice[] SpeechVoices { get; set; }
	// methods
	public virtual void CancelSpeechRequest ();
	public static AVSpeechSynthesisProviderAudioUnit Create (AudioUnit.AudioComponentDescription componentDescription, AudioUnit.AudioComponentInstantiationOptions options, out Foundation.NSError error);
	public virtual void SynthesizeSpeechRequest (AVSpeechSynthesisProviderRequest speechRequest);
}
```

#### New Type: AVFoundation.AVSpeechSynthesisProviderOutputBlock

```csharp
public sealed delegate AVSpeechSynthesisProviderOutputBlock : System.MulticastDelegate {
	// constructors
	public AVSpeechSynthesisProviderOutputBlock (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (AVSpeechSynthesisMarker[] markers, AVSpeechSynthesisProviderRequest request);
}
```

#### New Type: AVFoundation.AVSpeechSynthesisProviderRequest

```csharp
public class AVSpeechSynthesisProviderRequest : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVSpeechSynthesisProviderRequest (Foundation.NSCoder coder);
	protected AVSpeechSynthesisProviderRequest (Foundation.NSObjectFlag t);
	protected AVSpeechSynthesisProviderRequest (ObjCRuntime.NativeHandle handle);
	public AVSpeechSynthesisProviderRequest (string ssmlRepresentation, AVSpeechSynthesisProviderVoice voice);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual string SsmlRepresentation { get; }
	public virtual AVSpeechSynthesisProviderVoice Voice { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}
```

#### New Type: AVFoundation.AVSpeechSynthesisProviderVoice

```csharp
public class AVSpeechSynthesisProviderVoice : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVSpeechSynthesisProviderVoice (Foundation.NSCoder coder);
	protected AVSpeechSynthesisProviderVoice (Foundation.NSObjectFlag t);
	protected AVSpeechSynthesisProviderVoice (ObjCRuntime.NativeHandle handle);
	public AVSpeechSynthesisProviderVoice (string name, string identifier, string[] primaryLanguages, string[] supportedLanguages);
	// properties
	public virtual IntPtr Age { get; set; }
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual AVSpeechSynthesisVoiceGender Gender { get; set; }
	public virtual string Identifier { get; }
	public virtual string Name { get; }
	public virtual string[] PrimaryLanguages { get; }
	public virtual string[] SupportedLanguages { get; }
	public virtual string Version { get; set; }
	public virtual long VoiceSize { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
	public static void UpdateSpeechVoices ();
}
```

#### New Type: AVFoundation.AVSpeechSynthesisVoiceTraits

```csharp
[Serializable]
public enum AVSpeechSynthesisVoiceTraits {
	IsNoveltyVoice = 1,
	IsPersonalVoice = 2,
	None = 0,
}
```

#### New Type: AVFoundation.AVSpeechSynthesizerBufferCallback

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

#### New Type: AVFoundation.AVSpeechSynthesizerMarkerCallback

```csharp
public sealed delegate AVSpeechSynthesizerMarkerCallback : System.MulticastDelegate {
	// constructors
	public AVSpeechSynthesizerMarkerCallback (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (AVSpeechSynthesisMarker[] markers, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (AVSpeechSynthesisMarker[] markers);
}
```

#### New Type: AVFoundation.AVSpeechSynthesizerRequestPersonalVoiceAuthorizationCallback

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

#### New Type: AVFoundation.AVSpeechSynthesizerWillSpeakMarkerEventArgs

```csharp
public class AVSpeechSynthesizerWillSpeakMarkerEventArgs : System.EventArgs {
	// constructors
	public AVSpeechSynthesizerWillSpeakMarkerEventArgs (AVSpeechSynthesisMarker marker, AVSpeechUtterance utterance);
	// properties
	public AVSpeechSynthesisMarker Marker { get; set; }
	public AVSpeechUtterance Utterance { get; set; }
}
```

#### New Type: AVFoundation.AVSpeechUtteranceInitializationOption

```csharp
[Serializable]
public enum AVSpeechUtteranceInitializationOption {
	PlainText = 0,
	SsmlRepresentation = 1,
}
```

#### New Type: AVFoundation.AVVideoCompositionCreateApplier

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

#### New Type: AVFoundation.AVVideoCompositionCreateCallback

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

#### New Type: AVFoundation.AVVideoCompositionDetermineValidityCallback

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

#### New Type: AVFoundation.AVVideoOutputSpecification

```csharp
public class AVVideoOutputSpecification : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected AVVideoOutputSpecification (Foundation.NSObjectFlag t);
	public AVVideoOutputSpecification (Foundation.NSObject[] tagCollections);
	protected AVVideoOutputSpecification (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultOutputSettings { get; set; }
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> DefaultPixelBufferAttributes { get; set; }
	public virtual Foundation.NSObject[] PreferredTagCollections { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void SetOutputSettings (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> outputSettings, CoreMedia.CMTagCollection tagCollection);
}
```

#### New Type: AVFoundation.AVVideoPerformanceMetrics

```csharp
public class AVVideoPerformanceMetrics : Foundation.NSObject {
	// constructors
	protected AVVideoPerformanceMetrics (Foundation.NSObjectFlag t);
	protected AVVideoPerformanceMetrics (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual IntPtr NumberOfCorruptedFrames { get; }
	public virtual IntPtr NumberOfDroppedFrames { get; }
	public virtual IntPtr NumberOfFramesDisplayedUsingOptimizedCompositing { get; }
	public virtual double TotalAccumulatedFrameDelay { get; }
	public virtual IntPtr TotalNumberOfFrames { get; }
}
```

#### New Type: AVFoundation.AVZoomRange

```csharp
public class AVZoomRange : Foundation.NSObject {
	// constructors
	protected AVZoomRange (Foundation.NSObjectFlag t);
	protected AVZoomRange (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public virtual System.Runtime.InteropServices.NFloat MaxZoomFactor { get; }
	public virtual System.Runtime.InteropServices.NFloat MinZoomFactor { get; }
	// methods
	public virtual bool ContainsZoomFactor (System.Runtime.InteropServices.NFloat zoomFactor);
}
```

#### New Type: AVFoundation.CMTagCollectionVideoOutputPreset

```csharp
[Serializable]
public enum CMTagCollectionVideoOutputPreset {
	Monoscopic = 0,
	Stereoscopic = 1,
}
```

#### New Type: AVFoundation.CMTagCollectionVideoOutputPreset_Extensions

```csharp
public static class CMTagCollectionVideoOutputPreset_Extensions {
	// methods
	public static CoreMedia.CMTagCollection Create (this CMTagCollectionVideoOutputPreset value, out CoreMedia.CMTagCollectionError status);
}
```

#### New Type: AVFoundation.IAVAudioRecorderDelegate

```csharp
public interface IAVAudioRecorderDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void EncoderError (AVAudioRecorder recorder, Foundation.NSError error);
	public virtual void FinishedRecording (AVAudioRecorder recorder, bool flag);
}
```

#### New Type: AVFoundation.IAVCaptureAudioDataOutputSampleBufferDelegate

```csharp
public interface IAVCaptureAudioDataOutputSampleBufferDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.IAVCaptureDataOutputSynchronizerDelegate

```csharp
public interface IAVCaptureDataOutputSynchronizerDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidOutputSynchronizedDataCollection (AVCaptureDataOutputSynchronizer synchronizer, AVCaptureSynchronizedDataCollection synchronizedDataCollection);
}
```

#### New Type: AVFoundation.IAVCaptureDepthDataOutputDelegate

```csharp
public interface IAVCaptureDepthDataOutputDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidDropDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection, AVCaptureOutputDataDroppedReason reason);
	public virtual void DidOutputDepthData (AVCaptureDepthDataOutput output, AVDepthData depthData, CoreMedia.CMTime timestamp, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.IAVCaptureMetadataOutputObjectsDelegate

```csharp
public interface IAVCaptureMetadataOutputObjectsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.IAVCapturePhotoCaptureDelegate

```csharp
public interface IAVCapturePhotoCaptureDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void DidFinishCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public virtual void DidFinishProcessingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, CoreMedia.CMTime duration, CoreMedia.CMTime photoDisplayTime, AVCaptureResolvedPhotoSettings resolvedSettings, Foundation.NSError error);
	public virtual void DidFinishProcessingPhoto (AVCapturePhotoOutput output, AVCapturePhoto photo, Foundation.NSError error);
	public virtual void DidFinishRecordingLivePhotoMovie (AVCapturePhotoOutput captureOutput, Foundation.NSUrl outputFileUrl, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void WillBeginCapture (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
	public virtual void WillCapturePhoto (AVCapturePhotoOutput captureOutput, AVCaptureResolvedPhotoSettings resolvedSettings);
}
```

#### New Type: AVFoundation.IAVCapturePhotoFileDataRepresentationCustomizer

```csharp
public interface IAVCapturePhotoFileDataRepresentationCustomizer : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementAppleProRawCompressionSettings (AVCapturePhoto photo, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> defaultSettings, IntPtr maximumBitDepth);
	public virtual AVDepthData GetReplacementDepthData (AVCapturePhoto photo);
	public virtual CoreVideo.CVPixelBuffer GetReplacementEmbeddedThumbnail (out Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> replacementEmbeddedThumbnailPhotoFormatOut, AVCapturePhoto photo);
	public virtual Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> GetReplacementMetadata (AVCapturePhoto photo);
	public virtual AVPortraitEffectsMatte GetReplacementPortraitEffectsMatte (AVCapturePhoto photo);
	public virtual AVSemanticSegmentationMatte GetReplacementSemanticSegmentationMatte (Foundation.NSString semanticSegmentationMatteType, AVCapturePhoto photo);
}
```

#### New Type: AVFoundation.IAVCapturePhotoOutputReadinessCoordinatorDelegate

```csharp
public interface IAVCapturePhotoOutputReadinessCoordinatorDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void CaptureReadinessDidChange (AVCapturePhotoOutputReadinessCoordinator coordinator, AVCapturePhotoOutputCaptureReadiness captureReadiness);
}
```

#### New Type: AVFoundation.IAVCaptureSessionControlsDelegate

```csharp
public interface IAVCaptureSessionControlsDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidBecomeActive (AVCaptureSession session);
	public virtual void DidBecomeInactive (AVCaptureSession session);
	public virtual void WillEnterFullscreenAppearance (AVCaptureSession session);
	public virtual void WillExitFullscreenAppearance (AVCaptureSession session);
}
```

#### New Type: AVFoundation.IAVCaptureVideoDataOutputSampleBufferDelegate

```csharp
public interface IAVCaptureVideoDataOutputSampleBufferDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidDropSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}
```

#### New Type: AVFoundation.IAVMetricEventStreamPublisher

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

#### New Type: AVFoundation.IAVMetricEventStreamSubscriber

```csharp
public interface IAVMetricEventStreamSubscriber : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidReceiveEvent (IAVMetricEventStreamPublisher publisher, AVMetricEvent event);
}
```

#### New Type: AVFoundation.IAVPlayerItemIntegratedTimelineObserver

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


### Namespace AVKit

#### New Type: AVKit.AVContinuityDevicePickerViewController

```csharp
public class AVContinuityDevicePickerViewController : UIKit.UIViewController {
	// constructors
	public AVContinuityDevicePickerViewController ();
	public AVContinuityDevicePickerViewController (Foundation.NSCoder coder);
	protected AVContinuityDevicePickerViewController (Foundation.NSObjectFlag t);
	protected AVContinuityDevicePickerViewController (ObjCRuntime.NativeHandle handle);
	// properties
	public override ObjCRuntime.NativeHandle ClassHandle { get; }
	public IAVContinuityDevicePickerViewControllerDelegate Delegate { get; set; }
	public static bool Supported { get; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}
```

#### New Type: AVKit.AVContinuityDevicePickerViewControllerDelegate

```csharp
public class AVContinuityDevicePickerViewControllerDelegate : Foundation.NSObject, IAVContinuityDevicePickerViewControllerDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public AVContinuityDevicePickerViewControllerDelegate ();
	protected AVContinuityDevicePickerViewControllerDelegate (Foundation.NSObjectFlag t);
	protected AVContinuityDevicePickerViewControllerDelegate (ObjCRuntime.NativeHandle handle);
	// methods
	public virtual void DidCancel (AVContinuityDevicePickerViewController pickerViewController);
	public virtual void DidConnectDevice (AVContinuityDevicePickerViewController pickerViewController, AVFoundation.AVContinuityDevice device);
	public virtual void DidEndPresenting (AVContinuityDevicePickerViewController pickerViewController);
	public virtual void WillBeginPresenting (AVContinuityDevicePickerViewController pickerViewController);
}
```

#### New Type: AVKit.IAVContinuityDevicePickerViewControllerDelegate

```csharp
public interface IAVContinuityDevicePickerViewControllerDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidCancel (AVContinuityDevicePickerViewController pickerViewController);
	public virtual void DidConnectDevice (AVContinuityDevicePickerViewController pickerViewController, AVFoundation.AVContinuityDevice device);
	public virtual void DidEndPresenting (AVContinuityDevicePickerViewController pickerViewController);
	public virtual void WillBeginPresenting (AVContinuityDevicePickerViewController pickerViewController);
}
```


### Namespace CoreFoundation

#### New Type: CoreFoundation.CFComparisonResult

```csharp
[Serializable]
public enum CFComparisonResult {
	EqualTo = 0,
	GreaterThan = 1,
	LessThan = -1,
}
```


### Namespace CoreHaptics

#### Type Changed: CoreHaptics.CHHapticEngine

Added constructor:

```csharp
public CHHapticEngine (AVFoundation.AVAudioSession audioSession, out Foundation.NSError error);
```



### Namespace CoreMedia

#### Type Changed: CoreMedia.CMFormatDescription

Added property:

```csharp
public CMTaggedBufferGroupFormatType TaggedBufferGroupFormatType { get; }
```


#### Type Changed: CoreMedia.CMMediaType

Added value:

```csharp
TaggedBufferGroup = 1952606066,
```


#### Type Changed: CoreMedia.CMSampleBuffer

Added property:

```csharp
public CMTaggedBufferGroup TaggedBufferGroup { get; }
```

Added methods:

```csharp
public static CMSampleBuffer CreateWithNewTiming (CMSampleBuffer original, CMSampleTimingInfo[] timing, out int status);
public CMSampleTimingInfo[] GetSampleTimingInfo (out int status);
```


#### New Type: CoreMedia.CMPackingType

```csharp
[Serializable]
public enum CMPackingType {
	None = 1852796517,
	OverUnder = 1870030194,
	SideBySide = 1936286821,
}
```

#### New Type: CoreMedia.CMProjectionType

```csharp
[Serializable]
public enum CMProjectionType {
	Equirectangular = 1701934441,
	Fisheye = 1718186856,
	HalfEquirectangular = 1751478645,
	Rectangular = 1919247220,
}
```

#### New Type: CoreMedia.CMStereoViewComponents

```csharp
[Serializable]
[Flags]
public enum CMStereoViewComponents {
	LeftEye = 1,
	None = 0,
	RightEye = 2,
}
```

#### New Type: CoreMedia.CMStereoViewInterpretationOptions

```csharp
[Serializable]
[Flags]
public enum CMStereoViewInterpretationOptions {
	AdditionalViews = 2,
	Default = 0,
	StereoOrderReversed = 1,
}
```

#### New Type: CoreMedia.CMTag

```csharp
public struct CMTag {
	// properties
	public CMTagCategory Category { get; }
	public CMTagDataType DataType { get; }
	public ulong FlagsValue { get; }
	public double Float64Value { get; }
	public bool HasFlagsValue { get; }
	public bool HasFloat64Value { get; }
	public bool HasInt64Value { get; }
	public bool HasOSTypeValue { get; }
	public long Int64Value { get; }
	public static CMTag Invalid { get; }
	public bool IsValid { get; }
	public static CMTag MediaSubTypeMebx { get; }
	public static CMTag MediaTypeAudio { get; }
	public static CMTag MediaTypeMetadata { get; }
	public static CMTag MediaTypeVideo { get; }
	public uint OSTypeValue { get; }
	public static CMTag PackingTypeNone { get; }
	public static CMTag PackingTypeOverUnder { get; }
	public static CMTag PackingTypeSideBySide { get; }
	public static CMTag ProjectionTypeEquirectangular { get; }
	public static CMTag ProjectionTypeFisheye { get; }
	public static CMTag ProjectionTypeHalfEquirectangular { get; }
	public static CMTag ProjectionTypeRectangular { get; }
	public static CMTag StereoInterpretationOrderReversed { get; }
	public static CMTag StereoLeftAndRightEye { get; }
	public static CMTag StereoLeftEye { get; }
	public static CMTag StereoNone { get; }
	public static CMTag StereoRightEye { get; }
	public ulong Value { get; }
	// methods
	public static CoreFoundation.CFComparisonResult Compare (CMTag tag1, CMTag tag2);
	public static CMTag? Create (Foundation.NSDictionary dictionary);
	public static CMTag CreateWithFlagsValue (CMTagCategory category, ulong flags);
	public static CMTag CreateWithFloat64Value (CMTagCategory category, double value);
	public static CMTag CreateWithOSTypeValue (CMTagCategory category, uint osTypeValue);
	public static CMTag CreateWithSInt64Value (CMTagCategory category, long value);
	public override bool Equals (object obj);
	public static bool Equals (CMTag tag1, CMTag tag2);
	public override int GetHashCode ();
	public Foundation.NSDictionary ToDictionary ();
	public override string ToString ();
}
```

#### New Type: CoreMedia.CMTagCategory

```csharp
[Serializable]
public enum CMTagCategory {
	ChannelId = 1986226286,
	MediaSubType = 1836283234,
	MediaType = 1835297121,
	PackingType = 1885430635,
	PixelFormat = 1885960294,
	ProjectionType = 1886547818,
	StereoView = 1702454643,
	StereoViewInterpretation = 1702455664,
	TrackId = 1953653099,
	Undefined = 0,
	VideoLayerId = 1986814329,
}
```

#### New Type: CoreMedia.CMTagCollection

```csharp
public class CMTagCollection : CoreFoundation.NativeObject {
	// properties
	public IntPtr Count { get; }
	public bool IsEmpty { get; }
	public CMTag[] Tags { get; }
	// methods
	public CMTagCollectionError Add (CMTag tag);
	public CMTagCollectionError Add (CMTagCollection collection);
	public CMTagCollectionError Add (CMTag[] tags);
	public void Apply (CMTagCollectionApplyFunction callback);
	public CMTag ApplyUntil (CMTagCollectionTagFilterFunction callback);
	public bool ContainsCategory (CMTagCategory category);
	public bool ContainsTag (CMTag tag);
	public bool ContainsTagCollection (CMTagCollection tagCollection);
	public bool ContainsTags (CMTag[] tags);
	public CMTagCollection Copy (out CMTagCollectionError status);
	public static CMTagCollection Create (CMTag[] tags);
	public static CMTagCollection Create (Foundation.NSData data, out CMTagCollectionError status);
	public static CMTagCollection Create (Foundation.NSDictionary dictionary, out CMTagCollectionError status);
	public static CMTagCollection Create (out CMTagCollectionError status, CMTag[] tags);
	public static CMTagCollection CreateMutable ();
	public static CMTagCollection CreateMutable (out CMTagCollectionError status);
	public static CMTagCollection CreateMutable (IntPtr capacity, out CMTagCollectionError status);
	public CMTagCollection CreateMutableCopy (out CMTagCollectionError status);
	public CMTagCollection CreateWithCopyOfTags (out CMTagCollectionError status, CMTagCategory[] categories);
	public CMTagCollection ExclusiveOr (CMTagCollection collection, out CMTagCollectionError status);
	public static CMTagCollection ExclusiveOr (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
	public IntPtr GetCount (CMTagCategory category);
	public IntPtr GetCount (CMTagCollectionTagFilterFunction filter);
	public CMTag[] GetTags (CMTagCollectionTagFilterFunction filter);
	public CMTag[] GetTags (out CMTagCollectionError status);
	public CMTag[] GetTags (CMTagCategory category, out CMTagCollectionError status);
	public CMTagCollectionError GetTags (CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
	public CMTagCollectionError GetTags (CMTagCategory category, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
	public CMTagCollectionError GetTags (CMTagCollectionTagFilterFunction filter, CMTag[] tags, IntPtr tagCount, out IntPtr tagsCopied);
	public static IntPtr GetTypeId ();
	public CMTagCollection Intersect (CMTagCollection collection, out CMTagCollectionError status);
	public static CMTagCollection Intersect (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
	public CMTagCollectionError Remove (CMTag tag);
	public CMTagCollectionError RemoveAllTags ();
	public CMTagCollectionError RemoveAllTags (CMTagCategory category);
	public CMTagCollection Subtract (CMTagCollection collection, out CMTagCollectionError status);
	public static CMTagCollection Subtract (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
	public Foundation.NSData ToData ();
	public Foundation.NSDictionary ToDictionary ();
	public override string ToString ();
	public CMTagCollection Union (CMTagCollection collection, out CMTagCollectionError status);
	public static CMTagCollection Union (CMTagCollection collection1, CMTagCollection collection2, out CMTagCollectionError status);
}
```

#### New Type: CoreMedia.CMTagCollectionApplyFunction

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

#### New Type: CoreMedia.CMTagCollectionError

```csharp
[Serializable]
public enum CMTagCollectionError {
	AllocationFailed = -15741,
	ExhaustedBufferSize = -15748,
	InternalError = -15742,
	InvalidTag = -15743,
	InvalidTagCollectionData = -15745,
	InvalidTagCollectionDataVersion = -15747,
	InvalidTagCollectionDictionary = -15744,
	NotYetImplemented = -15749,
	ParamErr = -15740,
	Success = 0,
	TagNotFound = -15746,
}
```

#### New Type: CoreMedia.CMTagCollectionTagFilterFunction

```csharp
public sealed delegate CMTagCollectionTagFilterFunction : System.MulticastDelegate {
	// constructors
	public CMTagCollectionTagFilterFunction (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CMTag tag, System.AsyncCallback callback, object object);
	public virtual bool EndInvoke (System.IAsyncResult result);
	public virtual bool Invoke (CMTag tag);
}
```

#### New Type: CoreMedia.CMTagDataType

```csharp
[Serializable]
public enum CMTagDataType {
	Flags = 7,
	Float64 = 3,
	Invalid = 0,
	OSType = 5,
	SInt64 = 2,
}
```

#### New Type: CoreMedia.CMTagError

```csharp
[Serializable]
public enum CMTagError {
	AllocationFailed = -15731,
	ParamErr = -15730,
	Success = 0,
}
```

#### New Type: CoreMedia.CMTaggedBufferGroup

```csharp
public class CMTaggedBufferGroup : CoreFoundation.NativeObject {
	// properties
	public IntPtr Count { get; }
	// methods
	public static CMTaggedBufferGroup Combine (CMTaggedBufferGroup[] groups);
	public static CMTaggedBufferGroup Combine (out CMTaggedBufferGroupError status, CMTaggedBufferGroup[] groups);
	public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreFoundation.NativeObject[] buffers, out CMTaggedBufferGroupError status);
	public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CMSampleBuffer[] buffers, out CMTaggedBufferGroupError status);
	public static CMTaggedBufferGroup Create (CMTagCollection[] tagCollections, CoreVideo.CVPixelBuffer[] buffers, out CMTaggedBufferGroupError status);
	public CMFormatDescription CreateFormatDescription (out CMTaggedBufferGroupError status);
	public CMSampleBuffer CreateSampleBuffer (CMTime sampleBufferPts, CMTime sampleBufferDuration, CMFormatDescription formatDescription, out CMTaggedBufferGroupError status);
	public IntPtr GetNumberOfMatches (CMTagCollection tagCollection);
	public CoreVideo.CVPixelBuffer GetPixelBuffer (IntPtr index);
	public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTag tag, out IntPtr index);
	public CoreVideo.CVPixelBuffer GetPixelBuffer (CMTagCollection tagCollection, out IntPtr index);
	public CMSampleBuffer GetSampleBuffer (IntPtr index);
	public CMSampleBuffer GetSampleBuffer (CMTag tag, out IntPtr index);
	public CMSampleBuffer GetSampleBuffer (CMTagCollection tagCollection, out IntPtr index);
	public CMTagCollection GetTagCollection (IntPtr index);
	public static CMTaggedBufferGroup GetTaggedBufferGroup (CMSampleBuffer sampleBuffer);
	public static IntPtr GetTypeId ();
	public bool Matches (CMFormatDescription formatDescription);
}
```

#### New Type: CoreMedia.CMTaggedBufferGroupError

```csharp
[Serializable]
public enum CMTaggedBufferGroupError {
	AllocationFailed = -15781,
	InternalError = -15782,
	ParamErr = -15780,
	Success = 0,
}
```

#### New Type: CoreMedia.CMTaggedBufferGroupFormatType

```csharp
[Serializable]
public enum CMTaggedBufferGroupFormatType {
	TaggedBufferGroup = 1952606066,
}
```


### Namespace Foundation

#### Type Changed: Foundation.NSAttributedString

Obsoleted constructors:

```diff
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSData data, ref NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSUrl url, ref NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSData data, NSAttributedStringDocumentAttributes documentAttributes, ref NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSUrl url, NSAttributedStringDocumentAttributes documentAttributes, ref NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
 [Obsolete ("Use the 'Create' method instead, because there's no way to return an error from a constructor.")]
 public NSAttributedString (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
```

Added methods:

```csharp
public static NSAttributedString Create (NSData data, out NSError error);
public static NSAttributedString Create (NSUrl url, out NSError error);
public static NSAttributedString Create (NSData data, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSUrl url, NSAttributedStringDocumentAttributes options, out NSError error);
public static NSAttributedString Create (NSData markdown, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (NSUrl markdownFile, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
public static NSAttributedString Create (string markdownString, NSAttributedStringMarkdownParsingOptions options, NSUrl baseUrl, out NSError error);
```


#### Type Changed: Foundation.RegisterAttribute

Added property:

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



### Namespace OSLog

#### Type Changed: OSLog.OSLogStoreScope

Obsoleted fields:

```diff
 [Obsolete ("Not available on the current platform.")]
 System = 0,
```



### Namespace ObjCBindings

#### Type Changed: ObjCBindings.Constructor

Added values:

```csharp
IsThreadSafe = 8,
PlainString = 16,
```


#### Type Changed: ObjCBindings.EnumValue

Removed value:

```csharp
None = 0,
```

Added value:

```csharp
Default = 0,
```


#### Type Changed: ObjCBindings.ExportAttribute`1

Added properties:

```csharp
public System.Reflection.MethodAttributes DefaultCtorVisibility { get; set; }
public System.Reflection.MethodAttributes IntPtrCtorVisibility { get; set; }
public string Library { get; set; }
public string NativePrefix { get; set; }
public string NativeSuffix { get; set; }
public System.Reflection.MethodAttributes StringCtorVisibility { get; set; }
```


#### Type Changed: ObjCBindings.Method

Added values:

```csharp
AutoRelease = 256,
CustomMarshalDirective = 32,
IsThreadSafe = 64,
PlainString = 128,
```


#### Type Changed: ObjCBindings.Property

Added values:

```csharp
AutoRelease = 2048,
CoreImageFilterProperty = 1024,
CustomMarshalDirective = 32,
DisableZeroCopy = 64,
IsThreadSafe = 128,
MarshalNativeExceptions = 16,
PlainString = 512,
Transient = 256,
```


#### Removed Type ObjCBindings.Field
#### New Type: ObjCBindings.BindFromAttribute

```csharp
public class BindFromAttribute : System.Attribute {
	// constructors
	public BindFromAttribute (System.Type type);
	// properties
	public System.Type OriginalType { get; set; }
	public System.Type Type { get; set; }
}
```

#### New Type: ObjCBindings.BindingTypeAttribute`1

```csharp
public class BindingTypeAttribute`1 : System.Attribute {
	// constructors
	public BindingTypeAttribute`1 ();
	public BindingTypeAttribute`1 (string name);
	public BindingTypeAttribute`1 (T flags);
	public BindingTypeAttribute`1 (string name, T flags);
	// properties
	public System.Reflection.MethodAttributes DefaultCtorVisibility { get; set; }
	public T Flags { get; set; }
	public System.Reflection.MethodAttributes IntPtrCtorVisibility { get; set; }
	public string Name { get; set; }
	public System.Reflection.MethodAttributes StringCtorVisibility { get; set; }
}
```

#### New Type: ObjCBindings.Category

```csharp
[Serializable]
[Flags]
public enum Category {
	Default = 0,
	IsThreadSafe = 4,
}
```

#### New Type: ObjCBindings.Class

```csharp
[Serializable]
[Flags]
public enum Class {
	Default = 0,
	DisableDefaultCtor = 4,
	IsThreadSafe = 8,
}
```

#### New Type: ObjCBindings.CoreImageFilter

```csharp
[Serializable]
[Flags]
public enum CoreImageFilter {
	Default = 0,
}
```

#### New Type: ObjCBindings.Protocol

```csharp
[Serializable]
[Flags]
public enum Protocol {
	Default = 0,
	IsThreadSafe = 4,
}
```

#### New Type: ObjCBindings.StrongDictionary

```csharp
[Serializable]
[Flags]
public enum StrongDictionary {
	Default = 0,
}
```


### Namespace ObjCRuntime

#### Type Changed: ObjCRuntime.Constants

Modified fields:

```diff
-public const string Version = "18.2.9170";
+public const string Version = "18.2.9402";
```


#### Type Changed: ObjCRuntime.Dlfcn

Added method:

```csharp
public static T GetStruct<T> (IntPtr handle, string symbol);
```


#### Type Changed: ObjCRuntime.MarshalManagedExceptionEventArgs

Added constructor:

```csharp
public MarshalManagedExceptionEventArgs (System.Exception exception, MarshalManagedExceptionMode mode);
```


#### Type Changed: ObjCRuntime.MarshalObjectiveCExceptionEventArgs

Added constructor:

```csharp
public MarshalObjectiveCExceptionEventArgs (Foundation.NSException exception, MarshalObjectiveCExceptionMode mode);
```



### Namespace ReplayKit

#### Type Changed: ReplayKit.RPBroadcastHandler

Added method:

```csharp
public virtual void UpdateBroadcastUrl (Foundation.NSUrl broadcastUrl);
```



### Namespace UIKit

#### Type Changed: UIKit.UIApplication

Added properties:

```csharp
public virtual CoreGraphics.CGPoint AccessibilityActivationPoint { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedHint { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedLabel { get; set; }
public virtual Foundation.NSAttributedString[] AccessibilityAttributedUserInputLabels { get; set; }
public virtual Foundation.NSAttributedString AccessibilityAttributedValue { get; set; }
public virtual UIAccessibilityDirectTouchOptions AccessibilityDirectTouchOptions { get; set; }
public virtual bool AccessibilityElementsHidden { get; set; }
public virtual UIAccessibilityExpandedStatus AccessibilityExpandedStatus { get; set; }
public virtual CoreGraphics.CGRect AccessibilityFrame { get; set; }
public virtual Foundation.NSObject[] AccessibilityHeaderElements { get; set; }
public virtual string AccessibilityHint { get; set; }
public virtual string AccessibilityLabel { get; set; }
public virtual string AccessibilityLanguage { get; set; }
public virtual UIAccessibilityNavigationStyle AccessibilityNavigationStyle { get; set; }
public virtual UIBezierPath AccessibilityPath { get; set; }
public virtual bool AccessibilityRespondsToUserInteraction { get; set; }
public virtual string AccessibilityTextualContext { get; set; }
public virtual UIAccessibilityTrait AccessibilityTraits { get; set; }
public virtual string[] AccessibilityUserInputLabels { get; set; }
public virtual string AccessibilityValue { get; set; }
public virtual bool AccessibilityViewIsModal { get; set; }
public static Foundation.NSString AnnouncementDidFinishNotification { get; }
public static int AnnouncementNotification { get; }
public static Foundation.NSString AssistiveTechnologyKey { get; }
public static Foundation.NSString AssistiveTouchStatusDidChangeNotification { get; }
public static Foundation.NSString BoldTextStatusDidChangeNotification { get; }
public static Foundation.NSString ButtonShapesEnabledStatusDidChangeNotification { get; }
public static Foundation.NSString ClosedCaptioningStatusDidChangeNotification { get; }
public static Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
public static Foundation.NSString ElementFocusedNotification { get; }
public static Foundation.NSString FocusedElementKey { get; }
public static Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
public static Foundation.NSString GuidedAccessStatusDidChangeNotification { get; }
public static Foundation.NSString InvertColorsStatusDidChangeNotification { get; }
public virtual bool IsAccessibilityElement { get; set; }
public static int LayoutChangedNotification { get; }
public static Foundation.NSString MonoAudioStatusDidChangeNotification { get; }
public static Foundation.NSString NotificationSwitchControlIdentifier { get; }
public static Foundation.NSString NotificationVoiceOverIdentifier { get; }
public static Foundation.NSString OnOffSwitchLabelsDidChangeNotification { get; }
public static int PageScrolledNotification { get; }
public static int PauseAssistiveTechnologyNotification { get; }
public static Foundation.NSString PrefersCrossFadeTransitionsStatusDidChangeNotification { get; }
public static Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
public static Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
public static int ResumeAssistiveTechnologyNotification { get; }
public static int ScreenChangedNotification { get; }
public static Foundation.NSString ShakeToUndoDidChangeNotification { get; }
public static Foundation.NSString ShouldDifferentiateWithoutColorDidChangeNotification { get; }
public virtual bool ShouldGroupAccessibilityChildren { get; set; }
public static Foundation.NSString SpeakScreenStatusDidChangeNotification { get; }
public static Foundation.NSString SpeakSelectionStatusDidChangeNotification { get; }
public static Foundation.NSString SpeechAttributeAnnouncementPriority { get; }
public static Foundation.NSString SpeechAttributeIpaNotation { get; }
public static Foundation.NSString SpeechAttributeLanguage { get; }
public static Foundation.NSString SpeechAttributePitch { get; }
public static Foundation.NSString SpeechAttributePunctuation { get; }
public static Foundation.NSString SpeechAttributeQueueAnnouncement { get; }
public static Foundation.NSString SpeechAttributeSpellOut { get; }
public static Foundation.NSString SwitchControlStatusDidChangeNotification { get; }
public static Foundation.NSString TextAttributeContext { get; }
public static Foundation.NSString TextAttributeCustom { get; }
public static Foundation.NSString TextAttributeHeadingLevel { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitAdjustable { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitAllowsDirectInteraction { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitButton { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitCausesPageTurn { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitHeader { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitImage { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitKeyboardKey { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitLink { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitNone { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitNotEnabled { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitPlaysSound { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSearchField { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSelected { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitStartsMediaSession { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitStaticText { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitSummaryElement { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitTabBar { get; }

[Obsolete ("Use 'UIAccessibilityTraits' enum instead.")]
public static long TraitUpdatesFrequently { get; }
public static Foundation.NSString UnfocusedElementKey { get; }
public static Foundation.NSString VideoAutoplayStatusDidChangeNotification { get; }
public static Foundation.NSString VoiceOverStatusChanged { get; }
public static Foundation.NSString VoiceOverStatusDidChangeNotification { get; }
```

Added method:

```csharp
public virtual bool AccessibilityActivate ();
```

#### Type Changed: UIKit.UIApplication.Notifications

Added methods:

```csharp
public static Foundation.NSObject ObserveAnnouncementDidFinish (System.EventHandler<UIAccessibilityAnnouncementFinishedEventArgs> handler);
public static Foundation.NSObject ObserveAnnouncementDidFinish (Foundation.NSObject objectToObserve, System.EventHandler<UIAccessibilityAnnouncementFinishedEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTechnologyKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTechnologyKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTouchStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveAssistiveTouchStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveBoldTextStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveBoldTextStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveButtonShapesEnabledStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveButtonShapesEnabledStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveClosedCaptioningStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveClosedCaptioningStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveElementFocused (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveElementFocused (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveFocusedElementKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveFocusedElementKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGrayscaleStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGrayscaleStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGuidedAccessStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveGuidedAccessStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveInvertColorsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveInvertColorsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveMonoAudioStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveMonoAudioStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveOnOffSwitchLabelsDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveOnOffSwitchLabelsDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObservePrefersCrossFadeTransitionsStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObservePrefersCrossFadeTransitionsStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceMotionStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceMotionStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceTransparencyStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveReduceTransparencyStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShakeToUndoDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShakeToUndoDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShouldDifferentiateWithoutColorDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveShouldDifferentiateWithoutColorDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakScreenStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakScreenStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakSelectionStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSpeakSelectionStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSwitchControlStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveSwitchControlStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveUnfocusedElementKey (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveUnfocusedElementKey (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVideoAutoplayStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVideoAutoplayStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVoiceOverStatusDidChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveVoiceOverStatusDidChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
```