public virtual void GenerateCGImageAsynchronously (CoreMedia.CMTime requestedTime, AVAssetImageGenerateAsynchronouslyForTimeCompletionHandler handler);

public virtual bool ListenerHeadTrackingEnabled { get; set; }

public virtual bool IsOpen { get; }

public virtual void Close ();

public static Foundation.NSString RenderingCapabilitiesChangeNotification { get; }
public virtual AVAudioSessionRenderingMode RenderingMode { get; }
public static Foundation.NSString RenderingModeChangeNotification { get; }
public virtual AVAudioChannelLayout[] SupportedOutputChannelLayouts { get; }

public Foundation.NSError SetActive (bool active, AVAudioSessionSetActiveOptions options);
public bool SetCategory (AVAudioSessionCategory category, AVAudioSessionCategoryOptions options, out Foundation.NSError outError);
public Foundation.NSError SetCategory (AVAudioSessionCategory category, AVAudioSessionMode mode, AVAudioSessionCategoryOptions options);
public Foundation.NSError SetCategory (AVAudioSessionCategory category, string mode, AVAudioSessionCategoryOptions options);
public bool SetCategory (AVAudioSessionCategory category, AVAudioSessionMode mode, AVAudioSessionCategoryOptions options, out Foundation.NSError outError);
public bool SetCategory (AVAudioSessionCategory category, string mode, AVAudioSessionCategoryOptions options, out Foundation.NSError outError);
public bool SetCategory (AVAudioSessionCategory category, AVAudioSessionMode mode, AVAudioSessionRouteSharingPolicy policy, AVAudioSessionCategoryOptions options, out Foundation.NSError outError);
public bool SetCategory (AVAudioSessionCategory category, string mode, AVAudioSessionRouteSharingPolicy policy, AVAudioSessionCategoryOptions options, out Foundation.NSError outError);
public bool SetMode (AVAudioSessionMode mode, out Foundation.NSError error);

public static Foundation.NSObject ObserveRenderingCapabilitiesChange (System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRenderingCapabilitiesChange (Foundation.NSObject objectToObserve, System.EventHandler<Foundation.NSNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRenderingModeChange (System.EventHandler<RenderingModeChangeNotificationEventArgs> handler);
public static Foundation.NSObject ObserveRenderingModeChange (Foundation.NSObject objectToObserve, System.EventHandler<RenderingModeChangeNotificationEventArgs> handler);

public AVAudioSinkNode (AVAudioSinkNodeReceiverHandler2 receiverHandler);
public AVAudioSinkNode (AVAudioSinkNodeReceiverHandlerRaw receiverHandler);

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

public static Foundation.NSString[] ToArray (this AVMetadataObjectType value);
public static AVMetadataObjectType ToFlags (System.Collections.Generic.IEnumerable<Foundation.NSString> constants);

public virtual Cinematic.CNCompositionInfo AddTracks (Cinematic.CNAssetInfo assetInfo, int preferredStartingTrackID);

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

public sealed delegate AVAssetImageGenerateAsynchronouslyForTimeCompletionHandler : System.MulticastDelegate {
	// constructors
	public AVAssetImageGenerateAsynchronouslyForTimeCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CoreGraphics.CGImage imageRef, CoreMedia.CMTime actualTime, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CoreGraphics.CGImage imageRef, CoreMedia.CMTime actualTime, Foundation.NSError error);
}

public static class AVAudioSessionCategoryExtensions {
	// methods
	public static Foundation.NSString GetConstant (this AVAudioSessionCategory self);
	public static AVAudioSessionCategory GetValue (Foundation.NSString constant);
}

[Serializable]
public enum AVAudioSessionInterruptionReason {
	AppWasSuspended = 1,
	BuiltInMicMuted = 2,
	Default = 0,
	RouteDisconnected = 4,
}

[Serializable]
public enum AVAudioSessionMode {
	Default = 0,
	GameChat = 4,
	Measurement = 3,
	MoviePlayback = 5,
	SpokenAudio = 7,
	VideoChat = 6,
	VideoRecording = 2,
	VoiceChat = 1,
	VoicePrompt = 8,
}

public static class AVAudioSessionModeExtensions {
	// methods
	public static Foundation.NSString GetConstant (this AVAudioSessionMode self);
	public static AVAudioSessionMode GetValue (Foundation.NSString constant);
}

[Serializable]
public enum AVAudioSessionRenderingMode {
	DolbyAtmos = 5,
	DolbyAudio = 4,
	MonoStereo = 1,
	NotApplicable = 0,
	SpatialAudio = 3,
	Surround = 2,
}

public sealed delegate AVAudioSinkNodeReceiverHandler2 : System.MulticastDelegate {
	// constructors
	public AVAudioSinkNodeReceiverHandler2 (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (AudioToolbox.AudioTimeStamp timestamp, uint frameCount, AudioToolbox.AudioBuffers inputData, System.AsyncCallback callback, object object);
	public virtual int EndInvoke (System.IAsyncResult result);
	public virtual int Invoke (AudioToolbox.AudioTimeStamp timestamp, uint frameCount, AudioToolbox.AudioBuffers inputData);
}

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

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

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

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

public struct AVSampleCursorAudioDependencyInfo {
	// fields
	public nint PacketRefreshCount;
	// properties
	public bool IsIndependentlyDecodable { get; set; }
}

public class RenderingModeChangeNotificationEventArgs : Foundation.NSNotificationEventArgs {
	// constructors
	public RenderingModeChangeNotificationEventArgs (Foundation.NSNotification notification);
	// properties
	public AVAudioSessionRenderingMode NewRenderingMode { get; }
}

RecordingFailed = -1200,

public static class AXAnimatedImagesUtilities {
	// properties
	public static Foundation.NSString AnimatedImagesEnabledDidChangeNotification { get; }
	public static bool Enabled { get; }

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

public static class AXCustomContentProvider_Extensions {
	// methods
	public static System.Func<AXCustomContent[]> GetAccessibilityCustomContentHandler (this IAXCustomContentProvider This);
	public static void SetAccessibilityCustomContentHandler (this IAXCustomContentProvider This, System.Func<AXCustomContent[]> value);
}

public static class AXPrefers {
	// properties
	public static Foundation.NSString HorizontalTextLayoutDidChangeNotification { get; }
	// methods
	public static bool HorizontalTextEnabled ();

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

Ogg_3_0 = 9830403,
Ogg_4_0 = 12124164,
Ogg_5_0 = 13893637,
Ogg_5_1 = 13959174,
Ogg_6_1 = 14024711,
Ogg_7_1 = 14090248,

public static AudioConverter Create (AudioStreamBasicDescription sourceFormat, AudioStreamBasicDescription destinationFormat, AudioConverterOptions options);
public static AudioConverter Create (AudioStreamBasicDescription sourceFormat, AudioStreamBasicDescription destinationFormat, AudioConverterOptions options, out AudioConverterError error);

public int CountUserData (AudioFileChunkType chunkType);
public AudioFileError GetUserData (AudioFileChunkType chunkType, int index, ref int size, IntPtr userData);
public AudioFileError GetUserData (AudioFileChunkType chunkType, int index, long offset, byte[] data, out int size);
public AudioFileError GetUserData (AudioFileChunkType chunkType, int index, long offset, ref int size, IntPtr userData);
public AudioFileError GetUserData (uint userDataId, int index, long offset, byte[] data, out int size);
public AudioFileError GetUserData (uint userDataId, int index, long offset, ref int size, IntPtr userData);
public int GetUserDataSize (AudioFileChunkType chunkType, int index);
public AudioFileError GetUserDataSize (AudioFileChunkType chunkType, int index, out ulong size);
public AudioFileError GetUserDataSize (uint userDataId, int index, out ulong size);

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

[Serializable]
public enum AUVoiceIOOtherAudioDuckingLevel {
	Default = 0,
	Max = 30,
	Mid = 20,
	Min = 10,
}

[Serializable]
[Flags]
public enum AudioConverterOptions {
	None = 0,
	Unbuffered = 65536,
}

public virtual Foundation.NSData[] MigrateFromPlugin { get; }

public virtual ASUserAgeRange UserAgeRange { get; }

public ASWebAuthenticationSession (Foundation.NSUrl url, ASWebAuthenticationSessionCallback callback, ASWebAuthenticationSessionCompletionHandler completionHandler);

public virtual Foundation.NSDictionary AdditionalHeaderFields { get; set; }

protected override void Dispose (bool disposing);

[Serializable]
public enum ASAuthorizationPublicKeyCredentialAttachment {
	CrossPlatform = 1,
	Platform = 0,
}

[Serializable]
public enum ASAuthorizationWebBrowserPublicKeyCredentialManagerAuthorizationState {
	Authorized = 0,
	Denied = 1,
	NotDetermined = 2,
}

[Serializable]
public enum ASPublicKeyCredentialClientDataCrossOriginValue {
	CrossOrigin = 1,
	NotSet = 0,
	SameOriginWithAncestors = 2,
}

[Serializable]
public enum ASUserAgeRange {
	Child = 1,
	NotChild = 2,
	Unknown = 0,
}

public class ASWebAuthenticationSessionCallback : Foundation.NSObject {
	// constructors
	protected ASWebAuthenticationSessionCallback (Foundation.NSObjectFlag t);
	protected ASWebAuthenticationSessionCallback (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static ASWebAuthenticationSessionCallback Create (string customScheme);
	public static ASWebAuthenticationSessionCallback Create (string httpsHost, string path);
	public virtual bool MatchesUrl (Foundation.NSUrl url);
}

public class BGHealthResearchTask : BackgroundTasks.BGProcessingTask {
	// constructors
	public BGHealthResearchTask ();
	protected BGHealthResearchTask (Foundation.NSObjectFlag t);
	protected BGHealthResearchTask (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

public class BGHealthResearchTaskRequest : BackgroundTasks.BGProcessingTaskRequest {
	// constructors
	public BGHealthResearchTaskRequest ();
	protected BGHealthResearchTaskRequest (Foundation.NSObjectFlag t);
	protected BGHealthResearchTaskRequest (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string ProtectionTypeOfRequiredData { get; set; }
}

public static nint MaximumResults { get; }

public static Foundation.NSString CreationDateKey { get; }
public static Foundation.NSString CreatorUserRecordIdKey { get; }
public static Foundation.NSString LastModifiedUserRecordIdKey { get; }
public static Foundation.NSString ModificationDateKey { get; }
public static Foundation.NSString RecordIdKey { get; }

public virtual string ParticipantId { get; }

public class CKSyncEngine : Foundation.NSObject {
	// constructors
	public CKSyncEngine (CKSyncEngineConfiguration configuration);
	protected CKSyncEngine (Foundation.NSObjectFlag t);
	protected CKSyncEngine (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKDatabase Database { get; }
	public virtual CKSyncEngineState State { get; }
	// methods
	public virtual void CancelOperations (System.Action completionHandler);
	public virtual System.Threading.Tasks.Task CancelOperationsAsync ();
	public virtual void FetchChanges (System.Action<Foundation.NSError> completionHandler);
	public virtual void FetchChanges (CKSyncEngineFetchChangesOptions options, System.Action<Foundation.NSError> completionHandler);
	public virtual System.Threading.Tasks.Task FetchChangesAsync ();
	public virtual System.Threading.Tasks.Task FetchChangesAsync (CKSyncEngineFetchChangesOptions options);
	public virtual void SendChanges (System.Action<Foundation.NSError> completionHandler);
	public virtual void SendChanges (CKSyncEngineSendChangesOptions options, System.Action<Foundation.NSError> completionHandler);
	public virtual System.Threading.Tasks.Task SendChangesAsync ();
	public virtual System.Threading.Tasks.Task SendChangesAsync (CKSyncEngineSendChangesOptions options);
}

public class CKSyncEngineAccountChangeEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineAccountChangeEvent ();
	protected CKSyncEngineAccountChangeEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineAccountChangeEvent (IntPtr handle);
	// properties
	public virtual CKSyncEngineAccountChangeType ChangeType { get; }
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordID CurrentUser { get; }
	public virtual CKRecordID PreviousUser { get; }
}

[Serializable]
public enum CKSyncEngineAccountChangeType {
	SignIn = 0,
	SignOut = 1,
	SwitchAccounts = 2,
}

public class CKSyncEngineConfiguration : Foundation.NSObject {
	// constructors
	protected CKSyncEngineConfiguration (Foundation.NSObjectFlag t);
	protected CKSyncEngineConfiguration (IntPtr handle);
	public CKSyncEngineConfiguration (CKDatabase database, CKSyncEngineStateSerialization stateSerialization, ICKSyncEngineDelegate delegate);
	// properties
	public virtual bool AutomaticallySync { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual CKDatabase Database { get; set; }
	public ICKSyncEngineDelegate Delegate { get; set; }
	public virtual CKSyncEngineStateSerialization StateSerialization { get; set; }
	public virtual string SubscriptionId { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
}

public abstract class CKSyncEngineDelegate : Foundation.NSObject, ICKSyncEngineDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected CKSyncEngineDelegate ();
	protected CKSyncEngineDelegate (Foundation.NSObjectFlag t);
	protected CKSyncEngineDelegate (IntPtr handle);
	// methods
	public abstract void SyncEngine (CKSyncEngine syncEngine, CKSyncEngineEvent event);
	public virtual CKSyncEngineFetchChangesOptions SyncEngine (CKSyncEngine syncEngine, CKSyncEngineFetchChangesContext context);
	public abstract CKSyncEngineRecordZoneChangeBatch SyncEngine (CKSyncEngine syncEngine, CKSyncEngineSendChangesContext context);
}

public static class CKSyncEngineDelegate_Extensions {
	// methods
	public static CKSyncEngineFetchChangesOptions SyncEngine (this ICKSyncEngineDelegate This, CKSyncEngine syncEngine, CKSyncEngineFetchChangesContext context);
}

public class CKSyncEngineDidFetchChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineDidFetchChangesEvent ();
	protected CKSyncEngineDidFetchChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineDidFetchChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineFetchChangesContext Context { get; }
}

public class CKSyncEngineDidFetchRecordZoneChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineDidFetchRecordZoneChangesEvent ();
	protected CKSyncEngineDidFetchRecordZoneChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineDidFetchRecordZoneChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSError Error { get; }
	public virtual CKRecordZoneID ZoneId { get; }
}

public class CKSyncEngineDidSendChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineDidSendChangesEvent ();
	protected CKSyncEngineDidSendChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineDidSendChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineSendChangesContext Context { get; }
}

public class CKSyncEngineEvent : Foundation.NSObject {
	// constructors
	protected CKSyncEngineEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineEvent (IntPtr handle);
	// properties
	public virtual CKSyncEngineAccountChangeEvent AccountChangeEvent { get; }
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineDidFetchChangesEvent DidFetchChangesEvent { get; }
	public virtual CKSyncEngineDidFetchRecordZoneChangesEvent DidFetchRecordZoneChangesEvent { get; }
	public virtual CKSyncEngineDidSendChangesEvent DidSendChangesEvent { get; }
	public virtual CKSyncEngineFetchedDatabaseChangesEvent FetchedDatabaseChangesEvent { get; }
	public virtual CKSyncEngineFetchedRecordZoneChangesEvent FetchedRecordZoneChangesEvent { get; }
	public virtual CKSyncEngineSentDatabaseChangesEvent SentDatabaseChangesEvent { get; }
	public virtual CKSyncEngineSentRecordZoneChangesEvent SentRecordZoneChangesEvent { get; }
	public virtual CKSyncEngineStateUpdateEvent StateUpdateEvent { get; }
	public virtual CKSyncEngineEventType Type { get; }
	public virtual CKSyncEngineWillFetchChangesEvent WillFetchChangesEvent { get; }
	public virtual CKSyncEngineWillFetchRecordZoneChangesEvent WillFetchRecordZoneChangesEvent { get; }
	public virtual CKSyncEngineWillSendChangesEvent WillSendChangesEvent { get; }
}

[Serializable]
public enum CKSyncEngineEventType {
	AccountChange = 1,
	DidFetchChanges = 9,
	DidFetchRecordZoneChanges = 8,
	DidSendChanges = 11,
	FetchedDatabaseChanges = 2,
	FetchedRecordZoneChanges = 3,
	SentDatabaseChanges = 4,
	SentRecordZoneChanges = 5,
	StateUpdate = 0,
	WillFetchChanges = 6,
	WillFetchRecordZoneChanges = 7,
	WillSendChanges = 10,
}

public class CKSyncEngineFailedRecordSave : Foundation.NSObject {
	// constructors
	protected CKSyncEngineFailedRecordSave (Foundation.NSObjectFlag t);
	protected CKSyncEngineFailedRecordSave (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSError Error { get; }
	public virtual CKRecord Record { get; }
}

public class CKSyncEngineFailedZoneSave : Foundation.NSObject {
	// constructors
	protected CKSyncEngineFailedZoneSave (Foundation.NSObjectFlag t);
	protected CKSyncEngineFailedZoneSave (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSError Error { get; }
	public virtual CKRecordZone RecordZone { get; }
}

public class CKSyncEngineFetchChangesContext : Foundation.NSObject {
	// constructors
	protected CKSyncEngineFetchChangesContext (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchChangesContext (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineFetchChangesOptions Options { get; }
	public virtual CKSyncEngineSyncReason Reason { get; }
}

public class CKSyncEngineFetchChangesOptions : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CKSyncEngineFetchChangesOptions ();
	public CKSyncEngineFetchChangesOptions (CKSyncEngineFetchChangesScope scope);
	protected CKSyncEngineFetchChangesOptions (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchChangesOptions (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKOperationGroup OperationGroup { get; set; }
	public virtual CKRecordZoneID[] PrioritizedZoneIds { get; set; }
	public virtual CKSyncEngineFetchChangesScope Scope { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

public class CKSyncEngineFetchChangesScope : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CKSyncEngineFetchChangesScope ();
	protected CKSyncEngineFetchChangesScope (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchChangesScope (IntPtr handle);
	public CKSyncEngineFetchChangesScope (Foundation.NSSet<CKRecordZoneID> zoneIds, bool excluded);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSSet<CKRecordZoneID> ExcludedZoneIds { get; }
	public virtual Foundation.NSSet<CKRecordZoneID> ZoneIds { get; }
	// methods
	public virtual bool Contains (CKRecordZoneID zoneId);
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

public class CKSyncEngineFetchedDatabaseChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineFetchedDatabaseChangesEvent ();
	protected CKSyncEngineFetchedDatabaseChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchedDatabaseChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineFetchedZoneDeletion[] Deletions { get; }
	public virtual CKRecordZone[] Modifications { get; }
}

public class CKSyncEngineFetchedRecordDeletion : Foundation.NSObject {
	// constructors
	protected CKSyncEngineFetchedRecordDeletion (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchedRecordDeletion (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordID RecordId { get; }
	public virtual string RecordType { get; }
}

public class CKSyncEngineFetchedRecordZoneChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineFetchedRecordZoneChangesEvent ();
	protected CKSyncEngineFetchedRecordZoneChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchedRecordZoneChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineFetchedRecordDeletion[] Deletions { get; }
	public virtual CKRecord[] Modifications { get; }
}

public class CKSyncEngineFetchedZoneDeletion : Foundation.NSObject {
	// constructors
	protected CKSyncEngineFetchedZoneDeletion (Foundation.NSObjectFlag t);
	protected CKSyncEngineFetchedZoneDeletion (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineZoneDeletionReason Reason { get; }
	public virtual CKRecordZoneID ZoneId { get; }
}

public class CKSyncEnginePendingDatabaseChange : Foundation.NSObject {
	// constructors
	protected CKSyncEnginePendingDatabaseChange (Foundation.NSObjectFlag t);
	protected CKSyncEnginePendingDatabaseChange (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEnginePendingDatabaseChangeType Type { get; }
	public virtual CKRecordZoneID ZoneId { get; }
}

[Serializable]
public enum CKSyncEnginePendingDatabaseChangeType {
	DeleteZone = 1,
	SaveZone = 0,
}

public class CKSyncEnginePendingRecordZoneChange : Foundation.NSObject {
	// constructors
	protected CKSyncEnginePendingRecordZoneChange (Foundation.NSObjectFlag t);
	protected CKSyncEnginePendingRecordZoneChange (IntPtr handle);
	public CKSyncEnginePendingRecordZoneChange (CKRecordID recordId, CKSyncEnginePendingRecordZoneChangeType type);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordID RecordId { get; }
	public virtual CKSyncEnginePendingRecordZoneChangeType Type { get; }
}

[Serializable]
public enum CKSyncEnginePendingRecordZoneChangeType {
	DeleteRecord = 1,
	SaveRecord = 0,
}

public class CKSyncEnginePendingZoneDelete : CloudKit.CKSyncEnginePendingDatabaseChange {
	// constructors
	public CKSyncEnginePendingZoneDelete ();
	public CKSyncEnginePendingZoneDelete (CKRecordZoneID zoneId);
	protected CKSyncEnginePendingZoneDelete (Foundation.NSObjectFlag t);
	protected CKSyncEnginePendingZoneDelete (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
}

public class CKSyncEnginePendingZoneSave : CloudKit.CKSyncEnginePendingDatabaseChange {
	// constructors
	public CKSyncEnginePendingZoneSave ();
	public CKSyncEnginePendingZoneSave (CKRecordZone zone);
	protected CKSyncEnginePendingZoneSave (Foundation.NSObjectFlag t);
	protected CKSyncEnginePendingZoneSave (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordZone Zone { get; }
}

public class CKSyncEngineRecordZoneChangeBatch : Foundation.NSObject {
	// constructors
	protected CKSyncEngineRecordZoneChangeBatch (Foundation.NSObjectFlag t);
	protected CKSyncEngineRecordZoneChangeBatch (IntPtr handle);
	public CKSyncEngineRecordZoneChangeBatch (CKSyncEnginePendingRecordZoneChange[] pendingChanges, System.Func<CKRecordID,CloudKit.CKRecord> recordProvider);
	public CKSyncEngineRecordZoneChangeBatch (CKRecord[] recordsToSave, CKRecordID[] recordIdsToDelete, bool atomicByZone);
	// properties
	public virtual bool AtomicByZone { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordID[] RecordIdsToDelete { get; }
	public virtual CKRecord[] RecordsToSave { get; }
}

public class CKSyncEngineSendChangesContext : Foundation.NSObject {
	// constructors
	protected CKSyncEngineSendChangesContext (Foundation.NSObjectFlag t);
	protected CKSyncEngineSendChangesContext (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineSendChangesOptions Options { get; }
	public virtual CKSyncEngineSyncReason Reason { get; }
}

public class CKSyncEngineSendChangesOptions : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CKSyncEngineSendChangesOptions ();
	public CKSyncEngineSendChangesOptions (CKSyncEngineSendChangesScope scope);
	protected CKSyncEngineSendChangesOptions (Foundation.NSObjectFlag t);
	protected CKSyncEngineSendChangesOptions (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKOperationGroup OperationGroup { get; set; }
	public virtual CKSyncEngineSendChangesScope Scope { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

public class CKSyncEngineSendChangesScope : Foundation.NSObject, Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CKSyncEngineSendChangesScope ();
	protected CKSyncEngineSendChangesScope (Foundation.NSObjectFlag t);
	public CKSyncEngineSendChangesScope (Foundation.NSSet<CKRecordID> recordIds);
	protected CKSyncEngineSendChangesScope (IntPtr handle);
	public CKSyncEngineSendChangesScope (Foundation.NSSet<CKRecordZoneID> zoneIds, bool excluded);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSSet<CKRecordZoneID> ExcludedZoneIds { get; }
	public virtual Foundation.NSSet<CKRecordID> RecordIds { get; }
	public virtual Foundation.NSSet<CKRecordZoneID> ZoneIds { get; }
	// methods
	public virtual bool ContainsPendingRecordZoneChange (CKSyncEnginePendingRecordZoneChange pendingRecordZoneChange);
	public virtual bool ContainsRecordId (CKRecordID recordId);
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

public class CKSyncEngineSentDatabaseChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineSentDatabaseChangesEvent ();
	protected CKSyncEngineSentDatabaseChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineSentDatabaseChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordZoneID[] DeletedZoneIds { get; }
	public virtual Foundation.NSDictionary<CKRecordZoneID,Foundation.NSError> FailedZoneDeletes { get; }
	public virtual CKSyncEngineFailedZoneSave[] FailedZoneSaves { get; }
	public virtual CKRecordZone[] SavedZones { get; }
}

public class CKSyncEngineSentRecordZoneChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineSentRecordZoneChangesEvent ();
	protected CKSyncEngineSentRecordZoneChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineSentRecordZoneChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordID[] DeletedRecordIds { get; }
	public virtual Foundation.NSDictionary<CKRecordID,Foundation.NSError> FailedRecordDeletes { get; }
	public virtual CKSyncEngineFailedRecordSave[] FailedRecordSaves { get; }
	public virtual CKRecord[] SavedRecords { get; }
}

public class CKSyncEngineState : Foundation.NSObject {
	// constructors
	protected CKSyncEngineState (Foundation.NSObjectFlag t);
	protected CKSyncEngineState (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual bool HasPendingUntrackedChanges { get; set; }
	public virtual CKSyncEnginePendingDatabaseChange[] PendingDatabaseChanges { get; }
	public virtual CKSyncEnginePendingRecordZoneChange[] PendingRecordZoneChanges { get; }
	public virtual CKRecordZoneID[] ZoneIdsWithUnfetchedServerChanges { get; }
	// methods
	public virtual void AddPendingDatabaseChanges (CKSyncEnginePendingDatabaseChange[] changes);
	public virtual void AddPendingRecordZoneChanges (CKSyncEnginePendingRecordZoneChange[] changes);
	public virtual void RemovePendingDatabaseChanges (CKSyncEnginePendingDatabaseChange[] changes);
	public virtual void RemovePendingRecordZoneChanges (CKSyncEnginePendingRecordZoneChange[] changes);
}

public class CKSyncEngineStateSerialization : Foundation.NSObject, Foundation.INSCoding, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CKSyncEngineStateSerialization (Foundation.NSCoder coder);
	protected CKSyncEngineStateSerialization (Foundation.NSObjectFlag t);
	protected CKSyncEngineStateSerialization (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

public class CKSyncEngineStateUpdateEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineStateUpdateEvent ();
	protected CKSyncEngineStateUpdateEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineStateUpdateEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineStateSerialization StateSerialization { get; }
}

[Serializable]
public enum CKSyncEngineSyncReason {
	Manual = 1,
	Scheduled = 0,
}

public class CKSyncEngineWillFetchChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineWillFetchChangesEvent ();
	protected CKSyncEngineWillFetchChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineWillFetchChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineFetchChangesContext Context { get; }
}

public class CKSyncEngineWillFetchRecordZoneChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineWillFetchRecordZoneChangesEvent ();
	protected CKSyncEngineWillFetchRecordZoneChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineWillFetchRecordZoneChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKRecordZoneID ZoneId { get; }
}

public class CKSyncEngineWillSendChangesEvent : CloudKit.CKSyncEngineEvent {
	// constructors
	public CKSyncEngineWillSendChangesEvent ();
	protected CKSyncEngineWillSendChangesEvent (Foundation.NSObjectFlag t);
	protected CKSyncEngineWillSendChangesEvent (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CKSyncEngineSendChangesContext Context { get; }
}

[Serializable]
public enum CKSyncEngineZoneDeletionReason {
	Deleted = 0,
	EncryptedDataReset = 2,
	Purged = 1,
}

public interface ICKSyncEngineDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public abstract void SyncEngine (CKSyncEngine syncEngine, CKSyncEngineEvent event);
	public abstract CKSyncEngineRecordZoneChangeBatch SyncEngine (CKSyncEngine syncEngine, CKSyncEngineSendChangesContext context);
}

Brotli = 2818,
LZBitmap = 1794,

public virtual CAToneMapMode ToneMapMode { get; set; }

public CASpringAnimation (double perceptualDuration, nfloat bounce);

public virtual bool AllowsOverdamping { get; set; }
public virtual nfloat Bounce { get; }
public virtual double PerceptualDuration { get; }

public class CAMetalDisplayLink : Foundation.NSObject {
	// constructors
	public CAMetalDisplayLink (CAMetalLayer layer);
	protected CAMetalDisplayLink (Foundation.NSObjectFlag t);
	protected CAMetalDisplayLink (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public ICAMetalDisplayLinkDelegate Delegate { get; set; }
	public virtual bool Paused { get; set; }
	public virtual float PreferredFrameLatency { get; set; }
	public virtual CAFrameRateRange PreferredFrameRateRange { get; set; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	public virtual void AddToRunLoop (Foundation.NSRunLoop runloop, Foundation.NSRunLoopMode mode);
	protected override void Dispose (bool disposing);
	public virtual void Invalidate ();
	public virtual void RemoveFromRunLoop (Foundation.NSRunLoop runloop, Foundation.NSRunLoopMode mode);
}

public abstract class CAMetalDisplayLinkDelegate : Foundation.NSObject, ICAMetalDisplayLinkDelegate, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	protected CAMetalDisplayLinkDelegate ();
	protected CAMetalDisplayLinkDelegate (Foundation.NSObjectFlag t);
	protected CAMetalDisplayLinkDelegate (IntPtr handle);
	// methods
	public abstract void NeedsUpdate (CAMetalDisplayLink link, CAMetalDisplayLinkUpdate update);
}

public class CAMetalDisplayLinkUpdate : Foundation.NSObject {
	// constructors
	protected CAMetalDisplayLinkUpdate (Foundation.NSObjectFlag t);
	protected CAMetalDisplayLinkUpdate (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual ICAMetalDrawable Drawable { get; }
	public virtual double TargetPresentationTimestamp { get; }
	public virtual double TargetTimestamp { get; }
}

public class CARenderer : Foundation.NSObject {
	// constructors
	public CARenderer ();
	protected CARenderer (Foundation.NSObjectFlag t);
	protected CARenderer (IntPtr handle);
	// properties
	public virtual CoreGraphics.CGRect Bounds { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual CALayer Layer { get; set; }
	// methods
	public virtual void AddUpdate (CoreGraphics.CGRect r);
	public void BeginFrame (double timeInSeconds);
	public virtual void BeginFrame (double timeInSeconds, ref Foundation.NSObject ts);
	public static CARenderer Create (Metal.IMTLTexture tex, CARendererOptions options);
	public static CARenderer Create (Metal.IMTLTexture tex, Foundation.NSDictionary dict);
	public virtual void EndFrame ();
	public virtual double GetNextFrameTime ();
	public virtual void Render ();
	public virtual void SetDestination (Metal.IMTLTexture tex);
	public virtual CoreGraphics.CGRect UpdateBounds ();
}

public class CARendererOptions : Foundation.DictionaryContainer {
	// constructors
	public CARendererOptions ();
	public CARendererOptions (Foundation.NSDictionary dictionary);
	// properties
	public CoreGraphics.CGColorSpace ColorSpace { get; set; }
	public Metal.IMTLCommandQueue MetalCommandQueue { get; set; }
}

[Serializable]
public enum CAToneMapMode {
	Automatic = 0,
	IfSupported = 2,
	Never = 1,
}

public static class CAToneMapModeExtensions {
	// methods
	public static Foundation.NSString GetConstant (this CAToneMapMode self);
	public static CAToneMapMode GetValue (Foundation.NSString constant);
}

public interface ICAMetalDisplayLinkDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public abstract void NeedsUpdate (CAMetalDisplayLink link, CAMetalDisplayLinkUpdate update);
}

public event System.EventHandler<CBPeripheralDiconnectionEventEventArgs> DidDisconnectPeripheral;

public virtual void DidDisconnectPeripheral (CBCentralManager central, CBPeripheral peripheral, double timestamp, bool isReconnecting, Foundation.NSError error);

public static void DidDisconnectPeripheral (this ICBCentralManagerDelegate This, CBCentralManager central, CBPeripheral peripheral, double timestamp, bool isReconnecting, Foundation.NSError error);

public bool? EnableAutoReconnect { get; }

public static Foundation.NSString CharacteristicObservationScheduleString { get; }

public class CBPeripheralDiconnectionEventEventArgs : System.EventArgs {
	// constructors
	public CBPeripheralDiconnectionEventEventArgs (CBPeripheral peripheral, double timestamp, bool isReconnecting, Foundation.NSError error);
	// properties
	public Foundation.NSError Error { get; set; }
	public bool IsReconnecting { get; set; }
	public CBPeripheral Peripheral { get; set; }
	public double Timestamp { get; set; }
}

CompositeAttributeType = 2100,

public virtual string VersionChecksum { get; }

public static Foundation.NSDictionary<Foundation.NSString,Foundation.NSString> ChecksumsForVersionedModel (Foundation.NSUrl modelUrl, out Foundation.NSError error);

public virtual bool FinishDeferredLightweightMigration (out Foundation.NSError error);
public virtual bool FinishDeferredLightweightMigrationTask (out Foundation.NSError error);

public static Foundation.NSString DeferredLightweightMigrationOptionKey { get; }
public static Foundation.NSString StagedMigrationManagerOptionKey { get; }

public class NSCompositeAttributeDescription : CoreData.NSAttributeDescription {
	// constructors
	public NSCompositeAttributeDescription ();
	public NSCompositeAttributeDescription (Foundation.NSCoder coder);
	protected NSCompositeAttributeDescription (Foundation.NSObjectFlag t);
	protected NSCompositeAttributeDescription (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NSAttributeDescription[] Elements { get; set; }
}

public class NSCustomMigrationStage : CoreData.NSMigrationStage {
	// constructors
	protected NSCustomMigrationStage (Foundation.NSObjectFlag t);
	protected NSCustomMigrationStage (IntPtr handle);
	public NSCustomMigrationStage (NSManagedObjectModelReference currentModel, NSManagedObjectModelReference nextModel);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NSManagedObjectModelReference CurrentModel { get; }
	public virtual System.Func<NSStagedMigrationManager,CoreData.NSCustomMigrationStage,Foundation.NSError,System.Boolean> DidMigrateHandler { get; set; }
	public virtual NSManagedObjectModelReference NextModel { get; }
	public virtual System.Func<NSStagedMigrationManager,CoreData.NSCustomMigrationStage,Foundation.NSError,System.Boolean> WillMigrateHandler { get; set; }
}

public class NSLightweightMigrationStage : CoreData.NSMigrationStage {
	// constructors
	protected NSLightweightMigrationStage (Foundation.NSObjectFlag t);
	protected NSLightweightMigrationStage (IntPtr handle);
	public NSLightweightMigrationStage (string[] versionChecksums);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string[] VersionChecksums { get; }
}

public class NSManagedObjectModelReference : Foundation.NSObject {
	// constructors
	protected NSManagedObjectModelReference (Foundation.NSObjectFlag t);
	protected NSManagedObjectModelReference (IntPtr handle);
	public NSManagedObjectModelReference (NSManagedObjectModel model, string versionChecksum);
	public NSManagedObjectModelReference (Foundation.NSUrl fileUrl, string versionChecksum);
	public NSManagedObjectModelReference (Foundation.NSDictionary versionHash, Foundation.NSBundle bundle, string versionChecksum);
	public NSManagedObjectModelReference (string modelName, Foundation.NSBundle bundle, string versionChecksum);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NSManagedObjectModel ResolvedModel { get; }
	public virtual string VersionChecksum { get; }
}

public class NSMigrationStage : Foundation.NSObject {
	// constructors
	public NSMigrationStage ();
	protected NSMigrationStage (Foundation.NSObjectFlag t);
	protected NSMigrationStage (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Label { get; set; }
}

public class NSStagedMigrationManager : Foundation.NSObject {
	// constructors
	public NSStagedMigrationManager (NSMigrationStage[] stages);
	protected NSStagedMigrationManager (Foundation.NSObjectFlag t);
	protected NSStagedMigrationManager (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NSPersistentContainer Container { get; }
	public virtual NSMigrationStage[] Stages { get; }
}

public string[] AllModes { get; }
public string CurrentMode { get; }

public CFRunLoopExitReason RunInMode (string mode, double seconds, bool returnAfterSourceHandled);

public void DrawConicGradient (CGGradient gradient, CGPoint point, nfloat angle);

public static Foundation.NSString MemoryLimit { get; }

public virtual Foundation.NSData GetOpenEXRRepresentation (CIImage image, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> options, out Foundation.NSError errorPtr);
public virtual bool WriteOpenExrRepresentation (CIImage image, Foundation.NSUrl url, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> options, out Foundation.NSError errorPtr);

public static CIBlurredRectangleGenerator BlurredRectangleGeneratorFilter { get; }
public static CICannyEdgeDetector CannyEdgeDetectorFilter { get; }
public static CIRoundedRectangleStrokeGenerator RoundedRectangleStrokeGeneratorFilter { get; }
public static CISobelGradients SobelGradientsFilter { get; }

public virtual float ContentHeadroom { get; }
public static int FormatRgb10 { get; }
public static int FormatRgbX16 { get; }
public static int FormatRgbXf { get; }
public static int FormatRgbXh { get; }
public virtual Metal.IMTLTexture MetalTexture { get; }
public virtual bool Opaque { get; }

public virtual CIImage CreateByApplyingGainMap (CIImage gainMap);
public virtual CIImage CreateByApplyingGainMap (CIImage gainMap, float headroom);

public static nuint GetRoiTileCount (this ICIImageProcessorInput This);
public static nuint GetRoiTileIndex (this ICIImageProcessorInput This);

public static CIVector[] GetRoiTileArray (int input, Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> arguments, CoreGraphics.CGRect outputRect);

public bool Extrapolate { get; set; }

public virtual double KernelCompileTime { get; }

public bool Extrapolate { get; set; }

public class CIAreaBoundsRed : CoreImage.CIFilter, ICIAreaBoundsRedProtocol, ICIAreaReductionFilterProtocol, ICIFilterProtocol, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CIAreaBoundsRed ();
	public CIAreaBoundsRed (Foundation.NSCoder coder);
	protected CIAreaBoundsRed (Foundation.NSObjectFlag t);
	protected CIAreaBoundsRed (IntPtr handle);
	// properties
	public virtual CoreGraphics.CGRect InputExtent { get; set; }
	public virtual CIImage InputImage { get; set; }
	public virtual CIImage OutputImage { get; }
}

public class CIBlurredRectangleGenerator : CoreImage.CIFilter, ICIBlurredRectangleGeneratorProtocol, ICIFilterProtocol, ObjCRuntime.INativeObject, System.IDisposable {
	// constructors
	public CIBlurredRectangleGenerator ();
	public CIBlurredRectangleGenerator (Foundation.NSCoder coder);
	protected CIBlurredRectangleGenerator (Foundation.NSObjectFlag t);
	protected CIBlurredRectangleGenerator (IntPtr handle);
	// properties
	public virtual CIColor Color { get; set; }
	public virtual CoreGraphics.CGRect InputExtent { get; set; }
	public virtual CIImage OutputImage { get; }
	public virtual float Sigma { get; set; }
}