watchOS API diff from stable

watchos-14-16-0-14-99-0.md

title	description	author	ms.author	ms.date	ms.topic	ms.assetid	ms.prod
Xamarin.WatchOS SDK API diff: 14.16.0 vs 14.99.0	List of API changes between Xamarin.WatchOS versions 14.16.0 and 14.99.0.	spouliot	sepoulio	8/17/2021	article	d1b23050-3648-88f7-4a4c-0a140002c6cd	xamarin

Xamarin.WatchOS SDK API diff: 14.16.0 vs 14.99.0

Xamarin.WatchOS.dll

Namespace AVFoundation

Type Changed: AVFoundation.AVPlayerInterstitialEvent

Obsoleted properties:

 [Obsolete ("Use 'TemplateItems' instead.")]
 public virtual AVPlayerItem[] InterstitialTemplateItems { get; }

Removed methods:

public static AVPlayerInterstitialEvent GetInterstitialEvent (AVPlayerItem primaryItem, CoreMedia.CMTime time, AVPlayerItem[] templateItems, AVPlayerInterstitialEventRestrictions restrictions, CoreMedia.CMTime resumptionOffset);
public static AVPlayerInterstitialEvent GetInterstitialEvent (AVPlayerItem primaryItem, Foundation.NSDate date, AVPlayerItem[] templateItems, AVPlayerInterstitialEventRestrictions restrictions, CoreMedia.CMTime resumptionOffset);
public static AVPlayerInterstitialEvent GetPlayerInterstitialEvent (AVPlayerItem primaryItem, CoreMedia.CMTime time, AVPlayerItem[] interstitialTemplateItems, AVPlayerInterstitialEventRestrictions restrictions, CoreMedia.CMTime resumptionOffset);
public static AVPlayerInterstitialEvent GetPlayerInterstitialEvent (AVPlayerItem primaryItem, Foundation.NSDate date, AVPlayerItem[] interstitialTemplateItems, AVPlayerInterstitialEventRestrictions restrictions, CoreMedia.CMTime resumptionOffset);

Type Changed: AVFoundation.AVPlayerInterstitialEventController

Modified base type:

-AVFoundation.AVPlayerInterstitialEventObserver
+AVFoundation.AVPlayerInterstitialEventMonitor

Obsoleted properties:

 [Obsolete ("Use 'Events' instead.")]
 public virtual AVPlayerInterstitialEvent[] InterstitialEvents { get; set; }

Obsoleted methods:

 [Obsolete ("Use 'GetInterstitialEventController' instead.")]
 public static AVPlayerInterstitialEventController GetPlayerInterstitialEventController (AVPlayer primaryPlayer);

Type Changed: AVFoundation.AVPlayerInterstitialEventObserver

Removed methods:

protected override void Dispose (bool disposing);
public static AVPlayerInterstitialEventObserver GetInterstitialEventObserver (AVPlayer primaryPlayer);
public static AVPlayerInterstitialEventObserver GetPlayerInterstitialEventObserver (AVPlayer primaryPlayer);

New Type: AVFoundation.AVPlayerInterstitialEventMonitor

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

Namespace Accessibility

New Type: Accessibility.AXCategoricalDataAxisDescriptor

public class AXCategoricalDataAxisDescriptor : Foundation.NSObject, IAXDataAxisDescriptor, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXCategoricalDataAxisDescriptor (Foundation.NSObjectFlag t);
	protected AXCategoricalDataAxisDescriptor (IntPtr handle);
	public AXCategoricalDataAxisDescriptor (Foundation.NSAttributedString attributedTitle, string[] categoryOrder);
	public AXCategoricalDataAxisDescriptor (string title, string[] categoryOrder);
	// properties
	public virtual Foundation.NSAttributedString AttributedTitle { get; set; }
	public virtual string[] CategoryOrder { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual string Title { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

New Type: Accessibility.AXChartDescriptor

public class AXChartDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXChartDescriptor (Foundation.NSObjectFlag t);
	protected AXChartDescriptor (IntPtr handle);
	public AXChartDescriptor (Foundation.NSAttributedString attributedTitle, string summary, IAXDataAxisDescriptor xAxis, AXNumericDataAxisDescriptor yAxis, AXDataSeriesDescriptor[] series);
	public AXChartDescriptor (string title, string summary, IAXDataAxisDescriptor xAxis, AXNumericDataAxisDescriptor yAxis, AXDataSeriesDescriptor[] series);
	public AXChartDescriptor (Foundation.NSAttributedString attributedTitle, string summary, IAXDataAxisDescriptor xAxis, AXNumericDataAxisDescriptor yAxis, IAXDataAxisDescriptor[] additionalAxes, AXDataSeriesDescriptor[] series);
	public AXChartDescriptor (string title, string summary, IAXDataAxisDescriptor xAxis, AXNumericDataAxisDescriptor yAxis, IAXDataAxisDescriptor[] additionalAxes, AXDataSeriesDescriptor[] series);
	// properties
	public virtual IAXDataAxisDescriptor[] AdditionalAxes { get; set; }
	public virtual Foundation.NSAttributedString AttributedTitle { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual AXChartDescriptorContentDirection ContentDirection { get; set; }
	public virtual CoreGraphics.CGRect ContentFrame { get; set; }
	public virtual AXDataSeriesDescriptor[] Series { get; set; }
	public virtual string Summary { get; set; }
	public virtual string Title { get; set; }
	public virtual IAXDataAxisDescriptor XAxis { get; set; }
	public virtual AXNumericDataAxisDescriptor YAxis { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

New Type: Accessibility.AXChartDescriptorContentDirection

[Serializable]
public enum AXChartDescriptorContentDirection {
	BottomToTop = 3,
	LeftToRight = 0,
	RadialClockwise = 4,
	RadialCounterClockwise = 5,
	RightToLeft = 1,
	TopToBottom = 2,
}

New Type: Accessibility.AXDataPoint

public class AXDataPoint : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXDataPoint (Foundation.NSObjectFlag t);
	protected AXDataPoint (IntPtr handle);
	public AXDataPoint (AXDataPointValue xValue, AXDataPointValue yValue);
	public AXDataPoint (AXDataPointValue xValue, AXDataPointValue yValue, AXDataPointValue[] additionalValues);
	public AXDataPoint (AXDataPointValue xValue, AXDataPointValue yValue, AXDataPointValue[] additionalValues, string label);
	// properties
	public virtual AXDataPointValue[] AdditionalValues { get; set; }
	public virtual Foundation.NSAttributedString AttributedLabel { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual string Label { get; set; }
	public virtual AXDataPointValue XValue { get; set; }
	public virtual AXDataPointValue YValue { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

New Type: Accessibility.AXDataPointValue

public class AXDataPointValue : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXDataPointValue (Foundation.NSObjectFlag t);
	protected AXDataPointValue (IntPtr handle);
	// properties
	public virtual string Category { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual double Number { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static AXDataPointValue CreateValueWithCategory (string category);
	public static AXDataPointValue CreateValueWithNumber (double number);
}

New Type: Accessibility.AXDataSeriesDescriptor

public class AXDataSeriesDescriptor : Foundation.NSObject, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXDataSeriesDescriptor (Foundation.NSObjectFlag t);
	protected AXDataSeriesDescriptor (IntPtr handle);
	public AXDataSeriesDescriptor (Foundation.NSAttributedString attributedName, bool isContinuous, AXDataPoint[] dataPoints);
	public AXDataSeriesDescriptor (string name, bool isContinuous, AXDataPoint[] dataPoints);
	// properties
	public virtual Foundation.NSAttributedString AttributedName { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual AXDataPoint[] DataPoints { get; set; }
	public virtual bool IsContinuous { get; set; }
	public virtual string Name { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

New Type: Accessibility.AXHearingDeviceEar

[Serializable]
[Flags]
public enum AXHearingDeviceEar {
	Both = 6,
	Left = 2,
	None = 0,
	Right = 4,
}

New Type: Accessibility.AXHearingUtilities

public static class AXHearingUtilities {
	// properties
	public static Foundation.NSString PairedUUIDsDidChangeNotification { get; }
	public static Foundation.NSString StreamingEarDidChangeNotification { get; }
	// methods
	public static Foundation.NSUuid[] GetMFiHearingDevicePairedUuids ();
	public static AXHearingDeviceEar GetMFiHearingDeviceStreamingEar ();
	public static bool SupportsBidirectionalStreaming ();

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

New Type: Accessibility.AXLiveAudioGraph

public class AXLiveAudioGraph : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXLiveAudioGraph (Foundation.NSObjectFlag t);
	protected AXLiveAudioGraph (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static void Start ();
	public static void Stop ();
	public static void Update (double value);
}

New Type: Accessibility.AXNumericDataAxisDescriptor

public class AXNumericDataAxisDescriptor : Foundation.NSObject, IAXDataAxisDescriptor, Foundation.INSCopying, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected AXNumericDataAxisDescriptor (Foundation.NSObjectFlag t);
	protected AXNumericDataAxisDescriptor (IntPtr handle);
	public AXNumericDataAxisDescriptor (Foundation.NSAttributedString attributedTitle, double lowerBound, double upperBound, Foundation.NSNumber[] gridlinePositions, System.Func<System.Double,Foundation.NSString> valueDescriptionProvider);
	public AXNumericDataAxisDescriptor (string title, double lowerBound, double upperBound, Foundation.NSNumber[] gridlinePositions, System.Func<System.Double,Foundation.NSString> valueDescriptionProvider);
	// properties
	public virtual Foundation.NSAttributedString AttributedTitle { get; set; }
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSNumber[] GridlinePositions { get; set; }
	public virtual double LowerBound { get; set; }
	public virtual AXNumericDataAxisDescriptorScale ScaleType { get; set; }
	public virtual string Title { get; set; }
	public virtual double UpperBound { get; set; }
	public virtual ValueDescriptionProviderHandler ValueDescriptionProvider { get; set; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
}

New Type: Accessibility.AXNumericDataAxisDescriptorScale

[Serializable]
public enum AXNumericDataAxisDescriptorScale {
	Linear = 0,
	Ln = 2,
	Log10 = 1,
}

New Type: Accessibility.IAXChart

public interface IAXChart : ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual AXChartDescriptor AccessibilityChartDescriptor { get; set; }
}

New Type: Accessibility.IAXDataAxisDescriptor

public interface IAXDataAxisDescriptor : Foundation.INSCopying, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual Foundation.NSAttributedString AttributedTitle { get; set; }
	public virtual string Title { get; set; }
}

New Type: Accessibility.ValueDescriptionProviderHandler

public sealed delegate ValueDescriptionProviderHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public ValueDescriptionProviderHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (double dataValue, System.AsyncCallback callback, object object);
	public virtual Foundation.NSString EndInvoke (System.IAsyncResult result);
	public virtual Foundation.NSString Invoke (double dataValue);
}

Namespace AudioToolbox

Type Changed: AudioToolbox.AudioChannelLabel

Added values:

HoaN3d = 196608,
HoaSn3d = 131072,

Type Changed: AudioToolbox.AudioChannelLayoutTag

Added values:

Atmos_5_1_4 = 12779530,
Atmos_7_1_2 = 12845066,
Logic_4_0_A = 7536644,
Logic_4_0_B = 7602180,
Logic_4_0_C = 12910596,
Logic_5_0_A = 7667717,
Logic_5_0_B = 7733253,
Logic_5_0_C = 7798789,
Logic_5_0_D = 7864325,
Logic_5_1_A = 7929862,
Logic_5_1_B = 7995398,
Logic_5_1_C = 8060934,
Logic_5_1_D = 8126470,
Logic_6_0_A = 9240582,
Logic_6_0_B = 12976134,
Logic_6_0_C = 9109510,
Logic_6_1_A = 9306119,
Logic_6_1_B = 13041671,
Logic_6_1_C = 8192007,
Logic_6_1_D = 13107207,
Logic_7_1_A = 8388616,
Logic_7_1_B = 13172744,
Logic_7_1_C = 8388616,
Logic_7_1_SDDS_A = 8257544,
Logic_7_1_SDDS_B = 8323080,
Logic_7_1_SDDS_C = 8454152,
Logic_Atmos_5_1_2 = 12713992,
Logic_Atmos_5_1_4 = 12779530,
Logic_Atmos_7_1_2 = 12845066,
Logic_Atmos_7_1_4_A = 12582924,
Logic_Atmos_7_1_4_B = 13238284,
Logic_Atmos_7_1_6 = 13303822,
Logic_Mono = 6553601,
Logic_Quadraphonic = 7077892,
Logic_Stereo = 6619138,

Namespace AuthenticationServices

Type Changed: AuthenticationServices.ASAuthorizationError

Added value:

NotInteractive = 1005,

Namespace CloudKit

Type Changed: CloudKit.CKAccountStatus

Added value:

TemporarilyUnavailable = 4,

Type Changed: CloudKit.CKErrorCode

Added value:

TemporarilyUnavailable = 36,

Type Changed: CloudKit.CKErrorFields

Added property:

public static Foundation.NSString UserDidResetEncryptedDataKey { get; }

Type Changed: CloudKit.CKFetchDatabaseChangesOperation

Added property:

public virtual System.Action<CKRecordZoneID> RecordZoneWithIdWasDeletedDueToUserEncryptedDataReset { get; set; }

Type Changed: CloudKit.CKFetchRecordZoneChangesOperation

Added property:

public virtual CKFetchRecordZoneChangesRecordWasChangedHandler RecordWasChangedHandler { get; set; }

Type Changed: CloudKit.CKFetchRecordZonesOperation

Added property:

public virtual CKRecordZonePerRecordZoneCompletionHandler PerRecordZoneCompletionHandler { get; set; }

Type Changed: CloudKit.CKFetchShareParticipantsOperation

Added property:

public virtual CKFetchShareParticipantsOperationPerShareParticipantCompletionHandler PerShareParticipantCompletionBlock { get; set; }

Type Changed: CloudKit.CKFetchSubscriptionsOperation

Added property:

public virtual CKFetchSubscriptionsPerSubscriptionCompletionHandler PerSubscriptionCompletionHandler { get; set; }

Type Changed: CloudKit.CKModifyRecordZonesOperation

Added properties:

public virtual CKModifyRecordZonesPerRecordZoneDeleteHandler PerRecordZoneDeleteHandler { get; set; }
public virtual CKModifyRecordZonesPerRecordZoneSaveHandler PerRecordZoneSaveHandler { get; set; }

Type Changed: CloudKit.CKModifyRecordsOperation

Added properties:

public virtual CKModifyRecordsOperationPerRecordDeleteHandler PerRecordDeleteHandler { get; set; }
public virtual CKModifyRecordsOperationPerRecordSaveHandler PerRecordSaveHandler { get; set; }

Type Changed: CloudKit.CKModifySubscriptionsOperation

Added properties:

public virtual CKModifySubscriptionsPerSubscriptionDeleteHandler PerSubscriptionDeleteHandler { get; set; }
public virtual CKModifySubscriptionsPerSubscriptionSaveHandler PerSubscriptionSaveHandler { get; set; }

Type Changed: CloudKit.CKQueryOperation

Added property:

public virtual CKQueryOperationRecordMatchedHandler RecordMatchedHandler { get; set; }

Type Changed: CloudKit.CKRecord

Added property:

public static Foundation.NSString NameZoneWideShare { get; }

Type Changed: CloudKit.CKRecordZone

Added property:

public virtual CKReference Share { get; }

Type Changed: CloudKit.CKRecordZoneCapabilities

Added value:

ZoneWideSharing = 8,

Type Changed: CloudKit.CKShare

Added constructor:

public CKShare (CKRecordZoneID recordZoneId);

Type Changed: CloudKit.CKShareMetadata

Added property:

public virtual CKRecordID HierarchicalRootRecordId { get; }

New Type: CloudKit.CKFetchRecordZoneChangesRecordWasChangedHandler

public sealed delegate CKFetchRecordZoneChangesRecordWasChangedHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKFetchRecordZoneChangesRecordWasChangedHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordID recordId, CKRecord record, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordID recordId, CKRecord record, Foundation.NSError error);
}

New Type: CloudKit.CKFetchShareParticipantsOperationPerShareParticipantCompletionHandler

public sealed delegate CKFetchShareParticipantsOperationPerShareParticipantCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKFetchShareParticipantsOperationPerShareParticipantCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKUserIdentityLookupInfo identityLookupInfo, CKShareParticipant participant, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKUserIdentityLookupInfo identityLookupInfo, CKShareParticipant participant, Foundation.NSError error);
}

New Type: CloudKit.CKFetchSubscriptionsPerSubscriptionCompletionHandler

public sealed delegate CKFetchSubscriptionsPerSubscriptionCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKFetchSubscriptionsPerSubscriptionCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSString subscriptionId, CKSubscription subscription, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSString subscriptionId, CKSubscription subscription, Foundation.NSError error);
}

New Type: CloudKit.CKModifyRecordZonesPerRecordZoneDeleteHandler

public sealed delegate CKModifyRecordZonesPerRecordZoneDeleteHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifyRecordZonesPerRecordZoneDeleteHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordZoneID zoneId, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordZoneID zoneId, Foundation.NSError error);
}

New Type: CloudKit.CKModifyRecordZonesPerRecordZoneSaveHandler

public sealed delegate CKModifyRecordZonesPerRecordZoneSaveHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifyRecordZonesPerRecordZoneSaveHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordZoneID zoneId, CKRecordZone zone, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordZoneID zoneId, CKRecordZone zone, Foundation.NSError error);
}

New Type: CloudKit.CKModifyRecordsOperationPerRecordDeleteHandler

public sealed delegate CKModifyRecordsOperationPerRecordDeleteHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifyRecordsOperationPerRecordDeleteHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordID recordId, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordID recordId, Foundation.NSError error);
}

New Type: CloudKit.CKModifyRecordsOperationPerRecordSaveHandler

public sealed delegate CKModifyRecordsOperationPerRecordSaveHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifyRecordsOperationPerRecordSaveHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordID recordId, CKRecord record, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordID recordId, CKRecord record, Foundation.NSError error);
}

New Type: CloudKit.CKModifySubscriptionsPerSubscriptionDeleteHandler

public sealed delegate CKModifySubscriptionsPerSubscriptionDeleteHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifySubscriptionsPerSubscriptionDeleteHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSString subscriptionId, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSString subscriptionId, Foundation.NSError error);
}

New Type: CloudKit.CKModifySubscriptionsPerSubscriptionSaveHandler

public sealed delegate CKModifySubscriptionsPerSubscriptionSaveHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKModifySubscriptionsPerSubscriptionSaveHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSString subscriptionId, CKSubscription subscription, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSString subscriptionId, CKSubscription subscription, Foundation.NSError error);
}

New Type: CloudKit.CKQueryOperationRecordMatchedHandler

public sealed delegate CKQueryOperationRecordMatchedHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKQueryOperationRecordMatchedHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordID recordId, CKRecord record, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordID recordId, CKRecord record, Foundation.NSError error);
}

New Type: CloudKit.CKRecordZonePerRecordZoneCompletionHandler

public sealed delegate CKRecordZonePerRecordZoneCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public CKRecordZonePerRecordZoneCompletionHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CKRecordZoneID recordZoneId, CKRecordZone recordZone, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CKRecordZoneID recordZoneId, CKRecordZone recordZone, Foundation.NSError error);
}

Namespace Contacts

Type Changed: Contacts.CNErrorCode

Added value:

ChangeHistoryInvalidFetchRequest = 605,

Namespace CoreData

Type Changed: CoreData.NSAttributeDescription

Added property:

public virtual bool AllowsCloudEncryption { get; set; }

Type Changed: CoreData.NSPersistentCloudKitContainer

Added methods:

public virtual void AcceptShareInvitations (CloudKit.CKShareMetadata[] metadata, NSPersistentStore persistentStore, NSPersistentCloudKitContainerAcceptShareInvitationsHandler handler);
public virtual System.Threading.Tasks.Task<Foundation.NSArray<CloudKit.CKShareMetadata>> AcceptShareInvitationsAsync (CloudKit.CKShareMetadata[] metadata, NSPersistentStore persistentStore);
public virtual void FetchParticipantsMatchingLookupInfos (CloudKit.CKUserIdentityLookupInfo[] lookupInfos, NSPersistentStore persistentStore, NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosHandler handler);
public virtual System.Threading.Tasks.Task<Foundation.NSArray<CloudKit.CKShareParticipant>> FetchParticipantsMatchingLookupInfosAsync (CloudKit.CKUserIdentityLookupInfo[] lookupInfos, NSPersistentStore persistentStore);
public virtual CloudKit.CKShare[] FetchSharesInPersistentStore (NSPersistentStore persistentStore, out Foundation.NSError error);
public virtual Foundation.NSDictionary<NSManagedObjectID,CloudKit.CKShare> FetchSharesMatchingObjectIds (NSManagedObjectID[] objectIDs, out Foundation.NSError error);
public virtual void PersistUpdatedShare (CloudKit.CKShare share, NSPersistentStore persistentStore, NSPersistentCloudKitContainerPersistUpdatedShareHandler handler);
public virtual System.Threading.Tasks.Task<CloudKit.CKShare> PersistUpdatedShareAsync (CloudKit.CKShare share, NSPersistentStore persistentStore);
public virtual void PurgeObjectsAndRecordsInZone (CloudKit.CKRecordZoneID zoneId, NSPersistentStore persistentStore, NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZoneHandler handler);
public virtual System.Threading.Tasks.Task<CloudKit.CKRecordZoneID> PurgeObjectsAndRecordsInZoneAsync (CloudKit.CKRecordZoneID zoneId, NSPersistentStore persistentStore);
public virtual void ShareManagedObjects (NSManagedObject[] managedObjects, CloudKit.CKShare share, NSPersistentCloudKitContainerShareManagedObjectsHandler handler);
public virtual System.Threading.Tasks.Task<NSPersistentCloudKitContainerShareManagedObjectsResult> ShareManagedObjectsAsync (NSManagedObject[] managedObjects, CloudKit.CKShare share);

New Type: CoreData.NSPersistentCloudKitContainerAcceptShareInvitationsHandler

public sealed delegate NSPersistentCloudKitContainerAcceptShareInvitationsHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public NSPersistentCloudKitContainerAcceptShareInvitationsHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSArray<CloudKit.CKShareMetadata> acceptedShareMetadatas, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSArray<CloudKit.CKShareMetadata> acceptedShareMetadatas, Foundation.NSError error);
}

New Type: CoreData.NSPersistentCloudKitContainerAcceptShareInvitationsResult

public class NSPersistentCloudKitContainerAcceptShareInvitationsResult {
	// constructors
	public NSPersistentCloudKitContainerAcceptShareInvitationsResult (Foundation.NSArray<CloudKit.CKShareMetadata> acceptedShareMetadatas);
	// properties
	public Foundation.NSArray<CloudKit.CKShareMetadata> AcceptedShareMetadatas { get; set; }
}

New Type: CoreData.NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosHandler

public sealed delegate NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSArray<CloudKit.CKShareParticipant> fetchedParticipants, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSArray<CloudKit.CKShareParticipant> fetchedParticipants, Foundation.NSError error);
}

New Type: CoreData.NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosResult

public class NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosResult {
	// constructors
	public NSPersistentCloudKitContainerFetchParticipantsMatchingLookupInfosResult (Foundation.NSArray<CloudKit.CKShareParticipant> fetchedParticipants);
	// properties
	public Foundation.NSArray<CloudKit.CKShareParticipant> FetchedParticipants { get; set; }
}

New Type: CoreData.NSPersistentCloudKitContainerPersistUpdatedShareHandler

public sealed delegate NSPersistentCloudKitContainerPersistUpdatedShareHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public NSPersistentCloudKitContainerPersistUpdatedShareHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CloudKit.CKShare persistedShare, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CloudKit.CKShare persistedShare, Foundation.NSError error);
}

New Type: CoreData.NSPersistentCloudKitContainerPersistUpdatedShareResult

public class NSPersistentCloudKitContainerPersistUpdatedShareResult {
	// constructors
	public NSPersistentCloudKitContainerPersistUpdatedShareResult (CloudKit.CKShare persistedShare);
	// properties
	public CloudKit.CKShare PersistedShare { get; set; }
}

New Type: CoreData.NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZone

public class NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZone {
	// constructors
	public NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZone (CloudKit.CKRecordZoneID purgedZoneId);
	// properties
	public CloudKit.CKRecordZoneID PurgedZoneId { get; set; }
}

New Type: CoreData.NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZoneHandler

public sealed delegate NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZoneHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public NSPersistentCloudKitContainerPurgeObjectsAndRecordsInZoneHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (CloudKit.CKRecordZoneID purgedZoneId, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (CloudKit.CKRecordZoneID purgedZoneId, Foundation.NSError error);
}

New Type: CoreData.NSPersistentCloudKitContainerShareManagedObjectsHandler

public sealed delegate NSPersistentCloudKitContainerShareManagedObjectsHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public NSPersistentCloudKitContainerShareManagedObjectsHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSSet<NSManagedObjectID> sharedObjectIds, CloudKit.CKShare share, CloudKit.CKContainer container, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSSet<NSManagedObjectID> sharedObjectIds, CloudKit.CKShare share, CloudKit.CKContainer container, Foundation.NSError error);
}

New Type: CoreData.NSPersistentCloudKitContainerShareManagedObjectsResult

public class NSPersistentCloudKitContainerShareManagedObjectsResult {
	// constructors
	public NSPersistentCloudKitContainerShareManagedObjectsResult (Foundation.NSSet<NSManagedObjectID> sharedObjectIds, CloudKit.CKShare share, CloudKit.CKContainer container);
	// properties
	public CloudKit.CKContainer Container { get; set; }
	public CloudKit.CKShare Share { get; set; }
	public Foundation.NSSet<NSManagedObjectID> SharedObjectIds { get; set; }
}

Namespace CoreFoundation

Type Changed: CoreFoundation.CFBundle

Type Changed: CoreFoundation.CFBundle.Architecture

Modified fields:

-ARM = 18
+ARM = 12
-ARM64 = 16777234
+ARM64 = 16777228
-PPC = 24
+PPC = 18
-PPC64 = 16777240
+PPC64 = 16777234

Type Changed: CoreFoundation.CFString

Added methods:

public static IntPtr CreateNative (string value);
public static string FromHandle (IntPtr handle);
public static string FromHandle (IntPtr handle, bool releaseHandle);
public static void ReleaseNative (IntPtr handle);

New Type: CoreFoundation.CFArray

public class CFArray : CoreFoundation.NativeObject, ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public nint Count { get; }
	// methods
	public static T[] ArrayFromHandle<T> (IntPtr handle);
	public IntPtr GetValue (nint index);
	public static string[] StringArrayFromHandle (IntPtr handle);
}

Namespace CoreLocation

Type Changed: CoreLocation.CLLocation

Added constructor:

public CLLocation (CLLocationCoordinate2D coordinate, double altitude, double horizontalAccuracy, double verticalAccuracy, double course, double courseAccuracy, double speed, double speedAccuracy, Foundation.NSDate timestamp, CLLocationSourceInformation sourceInfo);

Added properties:

public virtual double EllipsoidalAltitude { get; }
public virtual CLLocationSourceInformation SourceInformation { get; }

New Type: CoreLocation.CLLocationPushServiceError

[Serializable]
public enum CLLocationPushServiceError {
	MissingEntitlement = 3,
	MissingPushExtension = 1,
	MissingPushServerEnvironment = 2,
	Unknown = 0,
}

New Type: CoreLocation.CLLocationPushServiceErrorExtensions

public static class CLLocationPushServiceErrorExtensions {
	// methods
	public static Foundation.NSString GetDomain (this CLLocationPushServiceError self);
}

New Type: CoreLocation.CLLocationPushServiceExtension_Extensions

public static class CLLocationPushServiceExtension_Extensions {
	// methods
	public static void ServiceExtensionWillTerminate (this ICLLocationPushServiceExtension This);
}

New Type: CoreLocation.CLLocationSourceInformation

public class CLLocationSourceInformation : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public CLLocationSourceInformation ();
	public CLLocationSourceInformation (Foundation.NSCoder coder);
	protected CLLocationSourceInformation (Foundation.NSObjectFlag t);
	protected CLLocationSourceInformation (IntPtr handle);
	public CLLocationSourceInformation (bool isSoftware, bool isAccessory);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual bool IsProducedByAccessory { get; }
	public virtual bool IsSimulatedBySoftware { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: CoreLocation.ICLLocationPushServiceExtension

public interface ICLLocationPushServiceExtension : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DidReceiveLocationPushPayload (Foundation.NSDictionary<Foundation.NSString,Foundation.NSObject> payload, System.Action completion);
}

Namespace CoreMotion

Type Changed: CoreMotion.CMAltimeter

Added property:

public static bool IsAbsoluteAltitudeAvailable { get; }

Added methods:

public virtual void StartAbsoluteAltitudeUpdates (Foundation.NSOperationQueue queue, System.Action<CMAbsoluteAltitudeData,Foundation.NSError> handler);
public virtual void StopAbsoluteAltitudeUpdates ();

New Type: CoreMotion.CMAbsoluteAltitudeData

public class CMAbsoluteAltitudeData : CoreMotion.CMLogItem, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public CMAbsoluteAltitudeData (Foundation.NSCoder coder);
	protected CMAbsoluteAltitudeData (Foundation.NSObjectFlag t);
	protected CMAbsoluteAltitudeData (IntPtr handle);
	// properties
	public virtual double Accuracy { get; }
	public virtual double Altitude { get; }
	public override IntPtr ClassHandle { get; }
	public virtual double Precision { get; }
}

Namespace CoreText

Type Changed: CoreText.CTRunDelegate

Modified base type:

-System.Object
+CoreFoundation.NativeObject

Removed property:

public virtual IntPtr Handle { get; }

Removed methods:

public virtual void Dispose ();
protected virtual void Dispose (bool disposing);
protected override void ~CTRunDelegate ();

Type Changed: CoreText.CTRunDelegateOperations

Added property:

public IntPtr Handle { get; }

Namespace CoreVideo

Type Changed: CoreVideo.CVImageBuffer

Added properties:

public static Foundation.NSString AmbientViewingEnvironmentKey { get; }
public static Foundation.NSString RegionOfInterestKey { get; }

Type Changed: CoreVideo.CVPixelBuffer

Added method:

public CVPixelBufferAttributes GetPixelBufferCreationAttributes ();

New Type: CoreVideo.CVPixelFormatTypeExtensions

public static class CVPixelFormatTypeExtensions {
	// methods
	public static bool IsCompressedPixelFormatAvailable (this CVPixelFormatType type);
}

Namespace EventKit

Type Changed: EventKit.EKErrorCode

Added value:

ReminderAlarmContainsEmailOrUrl = 36,

New Type: EventKit.EKVirtualConferenceDescriptor

public class EKVirtualConferenceDescriptor : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected EKVirtualConferenceDescriptor (Foundation.NSObjectFlag t);
	protected EKVirtualConferenceDescriptor (IntPtr handle);
	public EKVirtualConferenceDescriptor (string title, EKVirtualConferenceUrlDescriptor[] urlDescriptors, string conferenceDetails);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string ConferenceDetails { get; }
	public virtual string Title { get; }
	public virtual EKVirtualConferenceUrlDescriptor[] UrlDescriptors { get; }
}

New Type: EventKit.EKVirtualConferenceProvider

public class EKVirtualConferenceProvider : Foundation.NSObject, Foundation.INSExtensionRequestHandling, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public EKVirtualConferenceProvider ();
	protected EKVirtualConferenceProvider (Foundation.NSObjectFlag t);
	protected EKVirtualConferenceProvider (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void BeginRequestWithExtensionContext (Foundation.NSExtensionContext context);
	public virtual void FetchAvailableRoomTypes (VirtualConferenceRoomTypeHandler handler);
	public virtual System.Threading.Tasks.Task<Foundation.NSArray<EKVirtualConferenceRoomTypeDescriptor>> FetchAvailableRoomTypesAsync ();
	public virtual void FetchVirtualConference (string identifier, VirtualConferenceHandler handler);
	public virtual System.Threading.Tasks.Task<EKVirtualConferenceDescriptor> FetchVirtualConferenceAsync (string identifier);
}

New Type: EventKit.EKVirtualConferenceRoomTypeDescriptor

public class EKVirtualConferenceRoomTypeDescriptor : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected EKVirtualConferenceRoomTypeDescriptor (Foundation.NSObjectFlag t);
	protected EKVirtualConferenceRoomTypeDescriptor (IntPtr handle);
	public EKVirtualConferenceRoomTypeDescriptor (string title, string identifier);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Identifier { get; }
	public virtual string Title { get; }
}

New Type: EventKit.EKVirtualConferenceUrlDescriptor

public class EKVirtualConferenceUrlDescriptor : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected EKVirtualConferenceUrlDescriptor (Foundation.NSObjectFlag t);
	protected EKVirtualConferenceUrlDescriptor (IntPtr handle);
	public EKVirtualConferenceUrlDescriptor (string title, Foundation.NSUrl url);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Title { get; }
	public virtual Foundation.NSUrl Url { get; }
}

New Type: EventKit.VirtualConferenceHandler

public sealed delegate VirtualConferenceHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public VirtualConferenceHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (EKVirtualConferenceDescriptor virtualConferenceDescriptor, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (EKVirtualConferenceDescriptor virtualConferenceDescriptor, Foundation.NSError error);
}

New Type: EventKit.VirtualConferenceRoomTypeHandler

public sealed delegate VirtualConferenceRoomTypeHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public VirtualConferenceRoomTypeHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSArray<EKVirtualConferenceRoomTypeDescriptor> virtualConferenceRoomTypeDescriptor, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSArray<EKVirtualConferenceRoomTypeDescriptor> virtualConferenceRoomTypeDescriptor, Foundation.NSError error);
}

Namespace Foundation

Type Changed: Foundation.NSArray

Obsoleted methods:

 [Obsolete ("Use of 'CFArray.StringArrayFromHandle' offers better performance.")]
 public static string[] StringArrayFromHandle (IntPtr handle);

Type Changed: Foundation.NSDocumentType

Added values:

DocFormat = 5,
MacSimpleText = 4,
OfficeOpenXml = 7,
OpenDocument = 9,
WebArchive = 8,
WordML = 6,

Type Changed: Foundation.NSString

Obsoleted methods:

 [Obsolete ("Use of 'CFString.CreateNative' offers better performance.")]
 public static IntPtr CreateNative (string str);
 [Obsolete ("Use of 'CFString.FromHandle' offers better performance.")]
 public static string FromHandle (IntPtr usrhandle);
 [Obsolete ("Use of 'CFString.FromHandle' offers better performance.")]
 public static string FromHandle (IntPtr handle, bool owns);

Type Changed: Foundation.NSValue

Modified properties:

-public virtual NSObject CMTimeMappingValue { get; }
+public virtual CoreMedia.CMTimeMapping CMTimeMappingValue { get; }
-public virtual NSObject CMTimeRangeValue { get; }
+public virtual CoreMedia.CMTimeRange CMTimeRangeValue { get; }
-public virtual NSObject CMTimeValue { get; }
+public virtual CoreMedia.CMTime CMTimeValue { get; }

Removed methods:

public static NSValue FromCMTime (NSObject time);
public static NSValue FromCMTimeMapping (NSObject timeMapping);
public static NSValue FromCMTimeRange (NSObject timeRange);

Added methods:

public static NSValue FromCMTime (CoreMedia.CMTime time);
public static NSValue FromCMTimeMapping (CoreMedia.CMTimeMapping timeMapping);
public static NSValue FromCMTimeRange (CoreMedia.CMTimeRange timeRange);

Namespace GameKit

Type Changed: GameKit.GKError

Added value:

FriendRequestNotAvailable = 103,

Namespace HealthKit

Type Changed: HealthKit.HKAnchoredObjectQuery

Added constructor:

public HKAnchoredObjectQuery (HKQueryDescriptor[] queryDescriptors, HKQueryAnchor anchor, nint limit, HKAnchoredObjectUpdateHandler resultsHandler);

Type Changed: HealthKit.HKCategoryTypeIdentifier

Added values:

AppleWalkingSteadinessEvent = 59,
PregnancyTestResult = 60,
ProgesteroneTestResult = 61,

Type Changed: HealthKit.HKHealthStore

Added methods:

public virtual void DisableAllBackgroundDelivery (System.Action<System.Boolean,Foundation.NSError> completion);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DisableAllBackgroundDeliveryAsync ();
public virtual void DisableBackgroundDelivery (HKObjectType type, System.Action<System.Boolean,Foundation.NSError> completion);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> DisableBackgroundDeliveryAsync (HKObjectType type);
public virtual void EnableBackgroundDelivery (HKObjectType type, HKUpdateFrequency frequency, System.Action<System.Boolean,Foundation.NSError> completion);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> EnableBackgroundDeliveryAsync (HKObjectType type, HKUpdateFrequency frequency);
public virtual void RecalibrateEstimates (HKSampleType sampleType, Foundation.NSDate date, System.Action<System.Boolean,Foundation.NSError> completion);
public virtual System.Threading.Tasks.Task<System.Tuple<System.Boolean,Foundation.NSError>> RecalibrateEstimatesAsync (HKSampleType sampleType, Foundation.NSDate date);

Type Changed: HealthKit.HKMetadataKey

Added properties:

public static Foundation.NSString AlgorithmVersion { get; }
public static Foundation.NSString DateOfEarliestDataUsedForEstimate { get; }

Type Changed: HealthKit.HKObserverQuery

Added constructor:

public HKObserverQuery (HKQueryDescriptor[] queryDescriptors, HKObserverQueryDescriptorUpdateHandler updateHandler);

Type Changed: HealthKit.HKQuantityTypeIdentifier

Added values:

AppleWalkingSteadiness = 91,
NumberOfAlcoholicBeverages = 92,

Type Changed: HealthKit.HKQuery

Added method:

public static Foundation.NSPredicate GetPredicateForVerifiableClinicalRecords (Foundation.NSDateInterval dateInterval);

Type Changed: HealthKit.HKSampleQuery

Added constructors:

public HKSampleQuery (HKQueryDescriptor[] queryDescriptors, nint limit, HKSampleQueryResultsHandler resultsHandler);
public HKSampleQuery (HKQueryDescriptor[] queryDescriptors, nint limit, Foundation.NSSortDescriptor[] sortDescriptors, HKSampleQueryResultsHandler resultsHandler);

Type Changed: HealthKit.HKSampleType

Added property:

public virtual bool AllowsRecalibrationForEstimates { get; }

New Type: HealthKit.HKAppleWalkingSteadiness

public static class HKAppleWalkingSteadiness {
	// methods
	public static HKQuantity GetMaximumQuantity (HKAppleWalkingSteadinessClassification classification);
	public static HKQuantity GetMinimumQuantity (HKAppleWalkingSteadinessClassification classification);
	public static bool TryGetClassification (HKQuantity value, out HKAppleWalkingSteadinessClassification? classification, out Foundation.NSError error);
}

New Type: HealthKit.HKAppleWalkingSteadinessClassification

[Serializable]
public enum HKAppleWalkingSteadinessClassification {
	Low = 2,
	Ok = 1,
	VeryLow = 3,
}

New Type: HealthKit.HKCategoryValueAppleWalkingSteadinessEvent

[Serializable]
public enum HKCategoryValueAppleWalkingSteadinessEvent {
	InitialLow = 1,
	InitialVeryLow = 2,
	RepeatLow = 3,
	RepeatVeryLow = 4,
}

New Type: HealthKit.HKCategoryValuePregnancyTestResult

[Serializable]
public enum HKCategoryValuePregnancyTestResult {
	Indeterminate = 3,
	Negative = 1,
	Positive = 2,
}

New Type: HealthKit.HKCategoryValueProgesteroneTestResult

[Serializable]
public enum HKCategoryValueProgesteroneTestResult {
	Indeterminate = 3,
	Negative = 1,
	Positive = 2,
}

New Type: HealthKit.HKObserverQueryDescriptorUpdateHandler

public sealed delegate HKObserverQueryDescriptorUpdateHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public HKObserverQueryDescriptorUpdateHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (HKObserverQuery query, Foundation.NSSet<HKSampleType> samples, System.Action completion, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (HKObserverQuery query, Foundation.NSSet<HKSampleType> samples, System.Action completion, Foundation.NSError error);
}

New Type: HealthKit.HKQueryDescriptor

public class HKQueryDescriptor : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public HKQueryDescriptor (Foundation.NSCoder coder);
	protected HKQueryDescriptor (Foundation.NSObjectFlag t);
	protected HKQueryDescriptor (IntPtr handle);
	public HKQueryDescriptor (HKSampleType sampleType, Foundation.NSPredicate predicate);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSPredicate Predicate { get; }
	public virtual HKSampleType SampleType { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

Namespace HomeKit

Type Changed: HomeKit.HMError

Added value:

AccessoryIsSuspended = 103,

New Type: HomeKit.FetchRoomHandler

public sealed delegate FetchRoomHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public FetchRoomHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSArray<HMChipServiceRoom> rooms, Foundation.NSError error, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSArray<HMChipServiceRoom> rooms, Foundation.NSError error);
}

New Type: HomeKit.HMChipServiceHome

public class HMChipServiceHome : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public HMChipServiceHome (Foundation.NSCoder coder);
	protected HMChipServiceHome (Foundation.NSObjectFlag t);
	protected HMChipServiceHome (IntPtr handle);
	public HMChipServiceHome (Foundation.NSUuid uuid, string name);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Name { get; }
	public virtual Foundation.NSUuid Uuid { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: HomeKit.HMChipServiceRequestHandler

public class HMChipServiceRequestHandler : Foundation.NSObject, Foundation.INSExtensionRequestHandling, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public HMChipServiceRequestHandler ();
	protected HMChipServiceRequestHandler (Foundation.NSObjectFlag t);
	protected HMChipServiceRequestHandler (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void BeginRequestWithExtensionContext (Foundation.NSExtensionContext context);
	public virtual void ConfigureAccessory (string accessoryName, HMChipServiceRoom accessoryRoom, System.Action<Foundation.NSError> completion);
	public virtual System.Threading.Tasks.Task ConfigureAccessoryAsync (string accessoryName, HMChipServiceRoom accessoryRoom);
	public virtual void FetchRooms (HMChipServiceHome home, FetchRoomHandler completion);
	public virtual System.Threading.Tasks.Task<Foundation.NSArray<HMChipServiceRoom>> FetchRoomsAsync (HMChipServiceHome home);
	public virtual void PairAccessory (HMChipServiceHome home, string onboardingPayload, System.Action<Foundation.NSError> completion);
	public virtual System.Threading.Tasks.Task PairAccessoryAsync (HMChipServiceHome home, string onboardingPayload);
}

New Type: HomeKit.HMChipServiceRoom

public class HMChipServiceRoom : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public HMChipServiceRoom (Foundation.NSCoder coder);
	protected HMChipServiceRoom (Foundation.NSObjectFlag t);
	protected HMChipServiceRoom (IntPtr handle);
	public HMChipServiceRoom (Foundation.NSUuid uuid, string name);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string Name { get; }
	public virtual Foundation.NSUuid Uuid { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: HomeKit.HMChipServiceTopology

public class HMChipServiceTopology : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public HMChipServiceTopology (Foundation.NSCoder coder);
	protected HMChipServiceTopology (Foundation.NSObjectFlag t);
	public HMChipServiceTopology (HMChipServiceHome[] homes);
	protected HMChipServiceTopology (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual HMChipServiceHome[] Homes { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

Namespace ImageIO

Type Changed: ImageIO.CGImageProperties

Added properties:

public static Foundation.NSString GroupImageIndexLeft { get; }
public static Foundation.NSString GroupImageIndexRight { get; }
public static Foundation.NSString GroupImageIsAlternateImage { get; }
public static Foundation.NSString GroupImageIsLeftImage { get; }
public static Foundation.NSString GroupImageIsRightImage { get; }
public static Foundation.NSString GroupImagesAlternate { get; }
public static Foundation.NSString GroupIndex { get; }
public static Foundation.NSString GroupType { get; }
public static Foundation.NSString GroupTypeAlternate { get; }
public static Foundation.NSString GroupTypeStereoPair { get; }
public static Foundation.NSString Groups { get; }
public static Foundation.NSString ImageIndex { get; }
public static Foundation.NSString PNGPixelsAspectRatio { get; }

Namespace MapKit

Type Changed: MapKit.MKMapItem

Modified methods:

 public bool OpenMaps (MKMapItem[] mapItems--- = NULL---, MKLaunchOptions launchOptions = NULL)

Namespace ObjCRuntime

Type Changed: ObjCRuntime.Constants

Modified fields:

-public const string SdkVersion = "7.4";
+public const string SdkVersion = "8.0";
-public const string Version = "14.16.0";
+public const string Version = "14.99.0";

Added fields:

public static const string ChipLibrary = "/System/Library/Frameworks/CHIP.framework/CHIP";
public static const string NearbyInteractionLibrary = "/System/Library/Frameworks/NearbyInteraction.framework/NearbyInteraction";
public static const string OSLogLibrary = "/System/Library/Frameworks/OSLog.framework/OSLog";

Type Changed: ObjCRuntime.PlatformName

Obsoleted fields:

 [Obsolete ("Use 'MacCatalyst' instead.")]
 UIKitForMac = 5,

Type Changed: ObjCRuntime.Runtime

Added method:

public static void ThrowException (IntPtr gchandle);

Namespace PassKit

Type Changed: PassKit.PKPassLibrary

Added methods:

public virtual void GetServiceProviderData (PKSecureElementPass secureElementPass, System.Action<Foundation.NSData,Foundation.NSError> completion);
public virtual System.Threading.Tasks.Task<Foundation.NSData> GetServiceProviderDataAsync (PKSecureElementPass secureElementPass);

Type Changed: PassKit.PKPaymentErrorCode

Added values:

CouponCodeExpired = 5,
CouponCodeInvalid = 4,

Type Changed: PassKit.PKPaymentMethodType

Added value:

EMoney = 5,

Type Changed: PassKit.PKPaymentRequest

Added property:

public virtual PKShippingContactEditingMode ShippingContactEditingMode { get; set; }

Type Changed: PassKit.PKPaymentRequestUpdate

Added property:

public virtual PKShippingMethod[] ShippingMethods { get; set; }

Type Changed: PassKit.PKShippingMethod

Added property:

public virtual PKDateComponentsRange DateComponentsRange { get; set; }

Type Changed: PassKit.PKTransitPassProperties

Modified base type:

-Foundation.NSObject
+PassKit.PKStoredValuePassProperties

New Type: PassKit.PKDateComponentsRange

public class PKDateComponentsRange : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public PKDateComponentsRange (Foundation.NSCoder coder);
	protected PKDateComponentsRange (Foundation.NSObjectFlag t);
	protected PKDateComponentsRange (IntPtr handle);
	public PKDateComponentsRange (Foundation.NSDateComponents startDateComponents, Foundation.NSDateComponents endDateComponents);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSDateComponents EndDateComponents { get; }
	public virtual Foundation.NSDateComponents StartDateComponents { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: PassKit.PKDeferredPaymentSummaryItem

public class PKDeferredPaymentSummaryItem : PassKit.PKPaymentSummaryItem, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected PKDeferredPaymentSummaryItem (Foundation.NSObjectFlag t);
	protected PKDeferredPaymentSummaryItem (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSDate DeferredDate { get; set; }
}

New Type: PassKit.PKRecurringPaymentSummaryItem

public class PKRecurringPaymentSummaryItem : PassKit.PKPaymentSummaryItem, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected PKRecurringPaymentSummaryItem (Foundation.NSObjectFlag t);
	protected PKRecurringPaymentSummaryItem (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSDate EndDate { get; set; }
	public virtual nint IntervalCount { get; set; }
	public virtual Foundation.NSCalendarUnit IntervalUnit { get; set; }
	public virtual Foundation.NSDate StartDate { get; set; }
}

New Type: PassKit.PKServiceProviderDataCompletionResult

public class PKServiceProviderDataCompletionResult {
	// constructors
	public PKServiceProviderDataCompletionResult (Foundation.NSData arg1);
	// properties
	public Foundation.NSData Arg1 { get; set; }
}

New Type: PassKit.PKShippingContactEditingMode

[Serializable]
public enum PKShippingContactEditingMode {
	Enabled = 1,
	StorePickup = 2,
}

New Type: PassKit.PKStoredValuePassBalance

public class PKStoredValuePassBalance : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected PKStoredValuePassBalance (Foundation.NSObjectFlag t);
	protected PKStoredValuePassBalance (IntPtr handle);
	// properties
	public virtual Foundation.NSDecimalNumber Amount { get; }
	public virtual string BalanceType { get; }
	public override IntPtr ClassHandle { get; }
	public virtual string CurrencyCode { get; }
	public virtual Foundation.NSDate ExpiryDate { get; }
	// methods
	public virtual bool IsEqual (PKStoredValuePassBalance balance);
}

New Type: PassKit.PKStoredValuePassBalanceType

[Serializable]
public enum PKStoredValuePassBalanceType {
	Cash = 0,
	LoyaltyPoints = 1,
}

New Type: PassKit.PKStoredValuePassBalanceTypeExtensions

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

New Type: PassKit.PKStoredValuePassProperties

public class PKStoredValuePassProperties : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected PKStoredValuePassProperties (Foundation.NSObjectFlag t);
	protected PKStoredValuePassProperties (IntPtr handle);
	// properties
	public virtual PKStoredValuePassBalance[] Balances { get; }
	public virtual bool Blocked { get; }
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSDate ExpirationDate { get; }
	// methods
	public static PKStoredValuePassProperties GetPassProperties (PKPass pass);
}

Namespace SceneKit

Type Changed: SceneKit.SCNAnimatable

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNAnimatable_Extensions

Added method:

public static void RemoveAllAnimationsWithBlendOutDuration (this ISCNAnimatable This, nfloat duration);

Type Changed: SceneKit.SCNAnimationPlayer

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNCamera

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNConstraint

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNGeometry

Added property:

public virtual Foundation.NSNumber MinimumLanguageVersion { get; set; }

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNLight

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNMaterial

Added property:

public virtual Foundation.NSNumber MinimumLanguageVersion { get; set; }

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNMaterialProperty

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNMorpher

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNNode

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNParticleSystem

Added property:

public virtual bool WritesToDepthBuffer { get; set; }

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Type Changed: SceneKit.SCNShadable

Added property:

public virtual Foundation.NSNumber MinimumLanguageVersion { get; set; }

Type Changed: SceneKit.SCNShadable_Extensions

Added methods:

public static Foundation.NSNumber GetMinimumLanguageVersion (this ISCNShadable This);
public static void SetMinimumLanguageVersion (this ISCNShadable This, Foundation.NSNumber value);

Type Changed: SceneKit.SCNTechnique

Added method:

public virtual void RemoveAllAnimationsWithBlendOutDuration (nfloat duration);

Namespace Security

Type Changed: Security.SecTrust

Added method:

public SecCertificate[] GetCertificateChain ();

Namespace SoundAnalysis

Type Changed: SoundAnalysis.SNClassificationResult

Modified properties:

-public virtual Foundation.NSObject TimeRange { get; }
+public virtual CoreMedia.CMTimeRange TimeRange { get; }

Added method:

public virtual SNClassification GetClassification (string identifier);

Type Changed: SoundAnalysis.SNClassifySoundRequest

Added constructor:

public SNClassifySoundRequest (string classifierIdentifier, out Foundation.NSError error);

Added properties:

public virtual string[] KnownClassifications { get; }
public virtual CoreMedia.CMTime WindowDuration { get; set; }
public virtual SNTimeDurationConstraint WindowDurationConstraint { get; }

New Type: SoundAnalysis.SNClassifierIdentifier

[Serializable]
public enum SNClassifierIdentifier {
	Version1 = 0,
}

New Type: SoundAnalysis.SNClassifierIdentifierExtensions

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

New Type: SoundAnalysis.SNTimeDurationConstraint

public class SNTimeDurationConstraint : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public SNTimeDurationConstraint (CoreMedia.CMTimeRange durationRange);
	public SNTimeDurationConstraint (CoreMedia.CMTime[] enumeratedDurations);
	protected SNTimeDurationConstraint (Foundation.NSObjectFlag t);
	protected SNTimeDurationConstraint (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual CoreMedia.CMTimeRange DurationRange { get; }
	public virtual Foundation.NSValue[] EnumeratedDurations { get; }
	public virtual SNTimeDurationConstraintType Type { get; }
}

New Type: SoundAnalysis.SNTimeDurationConstraintType

[Serializable]
public enum SNTimeDurationConstraintType {
	Enumerated = 1,
	Range = 2,
}

Namespace UniformTypeIdentifiers

Type Changed: UniformTypeIdentifiers.UTTypes

Added property:

public static UTType Makefile { get; }

Namespace UserNotifications

Type Changed: UserNotifications.UNAuthorizationOptions

Added value:

TimeSensitive = 256,

Type Changed: UserNotifications.UNErrorCode

Added values:

ContentProvidingInvalid = 1501,
ContentProvidingObjectNotAllowed = 1500,

Type Changed: UserNotifications.UNLocationNotificationTrigger

Added method:

public static UNLocationNotificationTrigger CreateTrigger (CoreLocation.CLRegion region, bool repeats);

Type Changed: UserNotifications.UNMutableNotificationContent

Added properties:

public virtual UNNotificationInterruptionLevel InterruptionLevel { get; set; }
public virtual double RelevanceScore { get; set; }

Type Changed: UserNotifications.UNNotificationAction

Added property:

public virtual UNNotificationActionIcon Icon { get; }

Added method:

public static UNNotificationAction FromIdentifier (string identifier, string title, UNNotificationActionOptions options, UNNotificationActionIcon icon);

Type Changed: UserNotifications.UNNotificationContent

Added properties:

public virtual UNNotificationInterruptionLevel InterruptionLevel { get; }
public virtual double RelevanceScore { get; }

Added method:

public virtual UNNotificationContent Update (IUNNotificationContentProviding fromProvider, out Foundation.NSError outError);

Type Changed: UserNotifications.UNNotificationSettings

Added properties:

public virtual UNNotificationSetting DirectMessagesSetting { get; }
public virtual UNNotificationSetting ScheduledDeliverySetting { get; }
public virtual UNNotificationSetting TimeSensitiveSetting { get; }

Type Changed: UserNotifications.UNTextInputNotificationAction

Added method:

public static UNTextInputNotificationAction FromIdentifier (string identifier, string title, UNNotificationActionOptions options, UNNotificationActionIcon icon, string textInputButtonTitle, string textInputPlaceholder);

New Type: UserNotifications.IUNNotificationContentProviding

public interface IUNNotificationContentProviding : ObjCRuntime.INativeObject, System.IDisposable {
}

New Type: UserNotifications.UNNotificationActionIcon

public class UNNotificationActionIcon : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public UNNotificationActionIcon (Foundation.NSCoder coder);
	protected UNNotificationActionIcon (Foundation.NSObjectFlag t);
	protected UNNotificationActionIcon (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public static UNNotificationActionIcon CreateFromSystem (string imageName);
	public static UNNotificationActionIcon CreateFromTemplate (string imageName);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: UserNotifications.UNNotificationInterruptionLevel

[Serializable]
public enum UNNotificationInterruptionLevel {
	Active = 0,
	Critical = 1,
	Passive = 2,
	TimeSensitive = 3,
}

Namespace WatchKit

Type Changed: WatchKit.WKRefreshBackgroundTask

Added property:

public virtual System.Action ExpirationHandler { get; set; }

New Namespace Chip

New Type: Chip.ChipAccountLogin

public class ChipAccountLogin : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipAccountLogin (Foundation.NSObjectFlag t);
	protected ChipAccountLogin (IntPtr handle);
	public ChipAccountLogin (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void GetSetupPin (string tempAccountIdentifier, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetSetupPinAsync (string tempAccountIdentifier);
	public virtual void Login (string tempAccountIdentifier, string setupPin, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> LoginAsync (string tempAccountIdentifier, string setupPin);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
}

New Type: Chip.ChipApplicationBasic

public class ChipApplicationBasic : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipApplicationBasic (Foundation.NSObjectFlag t);
	protected ChipApplicationBasic (IntPtr handle);
	public ChipApplicationBasic (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeApplication (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeApplicationAsync ();
	public virtual void ReadAttributeApplicationName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeApplicationNameAsync ();
	public virtual void ReadAttributeApplicationSatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeApplicationSatusAsync ();
	public virtual void ReadAttributeCatalogVendorId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCatalogVendorIdAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeProductId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductIdAsync ();
	public virtual void ReadAttributeVendorId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorIdAsync ();
	public virtual void ReadAttributeVendorName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorNameAsync ();
}

New Type: Chip.ChipApplicationLauncher

public class ChipApplicationLauncher : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipApplicationLauncher (Foundation.NSObjectFlag t);
	protected ChipApplicationLauncher (IntPtr handle);
	public ChipApplicationLauncher (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void LaunchApp (string data, ushort catalogVendorId, string applicationId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> LaunchAppAsync (string data, ushort catalogVendorId, string applicationId);
	public virtual void ReadAttributeApplicationLauncherList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeApplicationLauncherListAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
}

New Type: Chip.ChipAudioOutput

public class ChipAudioOutput : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipAudioOutput (Foundation.NSObjectFlag t);
	protected ChipAudioOutput (IntPtr handle);
	public ChipAudioOutput (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeAudioOutputList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeAudioOutputListAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void RenameOutput (byte index, string name, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RenameOutputAsync (byte index, string name);
	public virtual void SelectOutput (byte index, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SelectOutputAsync (byte index);
}

New Type: Chip.ChipBarrierControl

public class ChipBarrierControl : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipBarrierControl (Foundation.NSObjectFlag t);
	protected ChipBarrierControl (IntPtr handle);
	public ChipBarrierControl (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void GoToPercent (byte percentOpen, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GoToPercentAsync (byte percentOpen);
	public virtual void ReadAttributeBarrierCapabilities (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBarrierCapabilitiesAsync ();
	public virtual void ReadAttributeBarrierMovingState (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBarrierMovingStateAsync ();
	public virtual void ReadAttributeBarrierPosition (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBarrierPositionAsync ();
	public virtual void ReadAttributeBarrierSafetyStatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBarrierSafetyStatusAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void Stop (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopAsync ();
}

New Type: Chip.ChipBasic

public class ChipBasic : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipBasic (Foundation.NSObjectFlag t);
	protected ChipBasic (IntPtr handle);
	public ChipBasic (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void GetMfgSpecificPing (ChipResponseHandler responseHandler);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeHardwareVersion (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeHardwareVersionAsync ();
	public virtual void ReadAttributeHardwareVersionString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeHardwareVersionStringAsync ();
	public virtual void ReadAttributeInteractionModelVersion (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInteractionModelVersionAsync ();
	public virtual void ReadAttributeLocalConfigDisabled (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLocalConfigDisabledAsync ();
	public virtual void ReadAttributeLocation (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLocationAsync ();
	public virtual void ReadAttributeManufacturingDate (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeManufacturingDateAsync ();
	public virtual void ReadAttributePartNumber (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePartNumberAsync ();
	public virtual void ReadAttributeProductId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductIdAsync ();
	public virtual void ReadAttributeProductLabel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductLabelAsync ();
	public virtual void ReadAttributeProductName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductNameAsync ();
	public virtual void ReadAttributeProductUrl (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductUrlAsync ();
	public virtual void ReadAttributeSerialNumber (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSerialNumberAsync ();
	public virtual void ReadAttributeSoftwareVersion (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSoftwareVersionAsync ();
	public virtual void ReadAttributeSoftwareVersionString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSoftwareVersionStringAsync ();
	public virtual void ReadAttributeUserLabel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeUserLabelAsync ();
	public virtual void ReadAttributeVendorId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorIdAsync ();
	public virtual void ReadAttributeVendorName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorNameAsync ();
	public virtual void WriteAttributeLocalConfigDisabled (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeLocalConfigDisabledAsync (byte value);
	public virtual void WriteAttributeLocation (string value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeLocationAsync (string value);
	public virtual void WriteAttributeUserLabel (string value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeUserLabelAsync (string value);
}

New Type: Chip.ChipBinaryInputBasic

public class ChipBinaryInputBasic : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipBinaryInputBasic (Foundation.NSObjectFlag t);
	protected ChipBinaryInputBasic (IntPtr handle);
	public ChipBinaryInputBasic (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributePresentValue (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributePresentValueAsync (ushort minInterval, ushort maxInterval);
	public virtual void ConfigureAttributeStatusFlags (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeStatusFlagsAsync (ushort minInterval, ushort maxInterval);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeOutOfService (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOutOfServiceAsync ();
	public virtual void ReadAttributePresentValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePresentValueAsync ();
	public virtual void ReadAttributeStatusFlags (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeStatusFlagsAsync ();
	public virtual void ReportAttributePresentValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributePresentValueAsync ();
	public virtual void ReportAttributeStatusFlags (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeStatusFlagsAsync ();
	public virtual void WriteAttributeOutOfService (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeOutOfServiceAsync (byte value);
	public virtual void WriteAttributePresentValue (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributePresentValueAsync (byte value);
}

New Type: Chip.ChipBinding

public class ChipBinding : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipBinding (Foundation.NSObjectFlag t);
	protected ChipBinding (IntPtr handle);
	public ChipBinding (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void Bind (ulong nodeId, ushort groupId, byte endpointId, ushort clusterId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> BindAsync (ulong nodeId, ushort groupId, byte endpointId, ushort clusterId);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void Unbind (ulong nodeId, ushort groupId, byte endpointId, ushort clusterId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UnbindAsync (ulong nodeId, ushort groupId, byte endpointId, ushort clusterId);
}

New Type: Chip.ChipBridgedDeviceBasic

public class ChipBridgedDeviceBasic : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipBridgedDeviceBasic (Foundation.NSObjectFlag t);
	protected ChipBridgedDeviceBasic (IntPtr handle);
	public ChipBridgedDeviceBasic (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeHardwareVersion (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeHardwareVersionAsync ();
	public virtual void ReadAttributeHardwareVersionString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeHardwareVersionStringAsync ();
	public virtual void ReadAttributeManufacturingDate (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeManufacturingDateAsync ();
	public virtual void ReadAttributePartNumber (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePartNumberAsync ();
	public virtual void ReadAttributeProductLabel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductLabelAsync ();
	public virtual void ReadAttributeProductName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductNameAsync ();
	public virtual void ReadAttributeProductUrl (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeProductUrlAsync ();
	public virtual void ReadAttributeReachable (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeReachableAsync ();
	public virtual void ReadAttributeSerialNumber (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSerialNumberAsync ();
	public virtual void ReadAttributeSoftwareVersion (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSoftwareVersionAsync ();
	public virtual void ReadAttributeSoftwareVersionString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSoftwareVersionStringAsync ();
	public virtual void ReadAttributeUserLabel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeUserLabelAsync ();
	public virtual void ReadAttributeVendorId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorIdAsync ();
	public virtual void ReadAttributeVendorName (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeVendorNameAsync ();
	public virtual void WriteAttributeUserLabel (string value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeUserLabelAsync (string value);
}

New Type: Chip.ChipCluster

public class ChipCluster : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipCluster (Foundation.NSObjectFlag t);
	protected ChipCluster (IntPtr handle);
	public ChipCluster (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
}

New Type: Chip.ChipColorControl

public class ChipColorControl : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipColorControl (Foundation.NSObjectFlag t);
	protected ChipColorControl (IntPtr handle);
	public ChipColorControl (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeColorTemperature (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeColorTemperatureAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void ConfigureAttributeCurrentHue (ushort minInterval, ushort maxInterval, byte change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentHueAsync (ushort minInterval, ushort maxInterval, byte change);
	public virtual void ConfigureAttributeCurrentSaturation (ushort minInterval, ushort maxInterval, byte change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentSaturationAsync (ushort minInterval, ushort maxInterval, byte change);
	public virtual void ConfigureAttributeCurrentX (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentXAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void ConfigureAttributeCurrentY (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentYAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void MoveColor (short rateX, short rateY, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveColorAsync (short rateX, short rateY, byte optionsMask, byte optionsOverride);
	public virtual void MoveColorTemperature (byte moveMode, ushort rate, ushort colorTemperatureMinimum, ushort colorTemperatureMaximum, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveColorTemperatureAsync (byte moveMode, ushort rate, ushort colorTemperatureMinimum, ushort colorTemperatureMaximum, byte optionsMask, byte optionsOverride);
	public virtual void MoveHue (byte moveMode, byte rate, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveHueAsync (byte moveMode, byte rate, byte optionsMask, byte optionsOverride);
	public virtual void MoveSaturation (byte moveMode, byte rate, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveSaturationAsync (byte moveMode, byte rate, byte optionsMask, byte optionsOverride);
	public virtual void MoveToColor (ushort colorX, ushort colorY, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToColorAsync (ushort colorX, ushort colorY, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void MoveToColorTemperature (ushort colorTemperature, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToColorTemperatureAsync (ushort colorTemperature, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void MoveToHue (byte hue, byte direction, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual void MoveToHueAndSaturation (byte hue, byte saturation, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToHueAndSaturationAsync (byte hue, byte saturation, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToHueAsync (byte hue, byte direction, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void MoveToSaturation (byte saturation, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToSaturationAsync (byte saturation, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeColorCapabilities (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorCapabilitiesAsync ();
	public virtual void ReadAttributeColorControlOptions (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorControlOptionsAsync ();
	public virtual void ReadAttributeColorLoopActive (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorLoopActiveAsync ();
	public virtual void ReadAttributeColorLoopDirection (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorLoopDirectionAsync ();
	public virtual void ReadAttributeColorLoopTime (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorLoopTimeAsync ();
	public virtual void ReadAttributeColorMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorModeAsync ();
	public virtual void ReadAttributeColorPointBIntensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointBIntensityAsync ();
	public virtual void ReadAttributeColorPointBX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointBXAsync ();
	public virtual void ReadAttributeColorPointBY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointBYAsync ();
	public virtual void ReadAttributeColorPointGIntensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointGIntensityAsync ();
	public virtual void ReadAttributeColorPointGX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointGXAsync ();
	public virtual void ReadAttributeColorPointGY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointGYAsync ();
	public virtual void ReadAttributeColorPointRIntensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointRIntensityAsync ();
	public virtual void ReadAttributeColorPointRX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointRXAsync ();
	public virtual void ReadAttributeColorPointRY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorPointRYAsync ();
	public virtual void ReadAttributeColorTempPhysicalMax (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorTempPhysicalMaxAsync ();
	public virtual void ReadAttributeColorTempPhysicalMin (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorTempPhysicalMinAsync ();
	public virtual void ReadAttributeColorTemperature (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeColorTemperatureAsync ();
	public virtual void ReadAttributeCompensationText (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCompensationTextAsync ();
	public virtual void ReadAttributeCoupleColorTempToLevelMinMireds (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCoupleColorTempToLevelMinMiredsAsync ();
	public virtual void ReadAttributeCurrentHue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentHueAsync ();
	public virtual void ReadAttributeCurrentSaturation (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentSaturationAsync ();
	public virtual void ReadAttributeCurrentX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentXAsync ();
	public virtual void ReadAttributeCurrentY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentYAsync ();
	public virtual void ReadAttributeDriftCompensation (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeDriftCompensationAsync ();
	public virtual void ReadAttributeEnhancedColorMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEnhancedColorModeAsync ();
	public virtual void ReadAttributeEnhancedCurrentHue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEnhancedCurrentHueAsync ();
	public virtual void ReadAttributeNumberOfPrimaries (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeNumberOfPrimariesAsync ();
	public virtual void ReadAttributePrimary1Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary1IntensityAsync ();
	public virtual void ReadAttributePrimary1X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary1XAsync ();
	public virtual void ReadAttributePrimary1Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary1YAsync ();
	public virtual void ReadAttributePrimary2Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary2IntensityAsync ();
	public virtual void ReadAttributePrimary2X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary2XAsync ();
	public virtual void ReadAttributePrimary2Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary2YAsync ();
	public virtual void ReadAttributePrimary3Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary3IntensityAsync ();
	public virtual void ReadAttributePrimary3X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary3XAsync ();
	public virtual void ReadAttributePrimary3Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary3YAsync ();
	public virtual void ReadAttributePrimary4Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary4IntensityAsync ();
	public virtual void ReadAttributePrimary4X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary4XAsync ();
	public virtual void ReadAttributePrimary4Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary4YAsync ();
	public virtual void ReadAttributePrimary5Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary5IntensityAsync ();
	public virtual void ReadAttributePrimary5X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary5XAsync ();
	public virtual void ReadAttributePrimary5Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary5YAsync ();
	public virtual void ReadAttributePrimary6Intensity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary6IntensityAsync ();
	public virtual void ReadAttributePrimary6X (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary6XAsync ();
	public virtual void ReadAttributePrimary6Y (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePrimary6YAsync ();
	public virtual void ReadAttributeRemainingTime (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeRemainingTimeAsync ();
	public virtual void ReadAttributeStartUpColorTemperatureMireds (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeStartUpColorTemperatureMiredsAsync ();
	public virtual void ReadAttributeWhitePointX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeWhitePointXAsync ();
	public virtual void ReadAttributeWhitePointY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeWhitePointYAsync ();
	public virtual void ReportAttributeColorTemperature (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeColorTemperatureAsync ();
	public virtual void ReportAttributeCurrentHue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentHueAsync ();
	public virtual void ReportAttributeCurrentSaturation (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentSaturationAsync ();
	public virtual void ReportAttributeCurrentX (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentXAsync ();
	public virtual void ReportAttributeCurrentY (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentYAsync ();
	public virtual void StepColor (short stepX, short stepY, ushort transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepColorAsync (short stepX, short stepY, ushort transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void StepColorTemperature (byte stepMode, ushort stepSize, ushort transitionTime, ushort colorTemperatureMinimum, ushort colorTemperatureMaximum, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepColorTemperatureAsync (byte stepMode, ushort stepSize, ushort transitionTime, ushort colorTemperatureMinimum, ushort colorTemperatureMaximum, byte optionsMask, byte optionsOverride);
	public virtual void StepHue (byte stepMode, byte stepSize, byte transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepHueAsync (byte stepMode, byte stepSize, byte transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void StepSaturation (byte stepMode, byte stepSize, byte transitionTime, byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepSaturationAsync (byte stepMode, byte stepSize, byte transitionTime, byte optionsMask, byte optionsOverride);
	public virtual void StopMoveStep (byte optionsMask, byte optionsOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopMoveStepAsync (byte optionsMask, byte optionsOverride);
	public virtual void WriteAttributeColorControlOptions (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorControlOptionsAsync (byte value);
	public virtual void WriteAttributeColorPointBIntensity (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointBIntensityAsync (byte value);
	public virtual void WriteAttributeColorPointBX (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointBXAsync (ushort value);
	public virtual void WriteAttributeColorPointBY (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointBYAsync (ushort value);
	public virtual void WriteAttributeColorPointGIntensity (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointGIntensityAsync (byte value);
	public virtual void WriteAttributeColorPointGX (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointGXAsync (ushort value);
	public virtual void WriteAttributeColorPointGY (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointGYAsync (ushort value);
	public virtual void WriteAttributeColorPointRIntensity (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointRIntensityAsync (byte value);
	public virtual void WriteAttributeColorPointRX (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointRXAsync (ushort value);
	public virtual void WriteAttributeColorPointRY (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeColorPointRYAsync (ushort value);
	public virtual void WriteAttributeStartUpColorTemperatureMireds (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeStartUpColorTemperatureMiredsAsync (ushort value);
	public virtual void WriteAttributeWhitePointX (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeWhitePointXAsync (ushort value);
	public virtual void WriteAttributeWhitePointY (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeWhitePointYAsync (ushort value);
}

New Type: Chip.ChipCommissioningFlow

[Serializable]
public enum ChipCommissioningFlow {
	Custom = 2,
	Invalid = 3,
	Standard = 0,
	UserActionRequired = 1,
}

New Type: Chip.ChipContentLaunch

public class ChipContentLaunch : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipContentLaunch (Foundation.NSObjectFlag t);
	protected ChipContentLaunch (IntPtr handle);
	public ChipContentLaunch (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void LaunchContent (byte autoPlay, string data, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> LaunchContentAsync (byte autoPlay, string data);
	public virtual void LaunchUrl (string contentUrl, string displayString, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> LaunchUrlAsync (string contentUrl, string displayString);
	public virtual void ReadAttributeAcceptsHeaderList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeAcceptsHeaderListAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeSupportedStreamingTypes (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSupportedStreamingTypesAsync ();
}

New Type: Chip.ChipDescriptor

public class ChipDescriptor : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipDescriptor (Foundation.NSObjectFlag t);
	protected ChipDescriptor (IntPtr handle);
	public ChipDescriptor (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClientList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClientListAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeDeviceList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeDeviceListAsync ();
	public virtual void ReadAttributePartsList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePartsListAsync ();
	public virtual void ReadAttributeServerList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeServerListAsync ();
}

New Type: Chip.ChipDevice

public class ChipDevice : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipDevice (Foundation.NSObjectFlag t);
	protected ChipDevice (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual bool IsActive { get; }
	// methods
	public virtual bool OpenPairingWindow (nuint duration, out Foundation.NSError error);
	public virtual string OpenPairingWindow (nuint duration, nuint discriminator, nuint setupPin, out Foundation.NSError error);
}

New Type: Chip.ChipDeviceController

public class ChipDeviceController : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipDeviceController (Foundation.NSObjectFlag t);
	protected ChipDeviceController (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSNumber ControllerNodeId { get; }
	public virtual bool IsRunning { get; }
	public static ChipDeviceController SharedController { get; }
	// methods
	public virtual ChipDevice GetPairedDevice (ulong deviceId, out Foundation.NSError error);
	public virtual bool PairDevice (ulong deviceId, string onboardingPayload, ChipOnboardingPayloadType onboardingPayloadType, out Foundation.NSError error);
	public virtual bool PairDevice (ulong deviceId, ushort discriminator, uint setupPinCode, out Foundation.NSError error);
	public virtual bool PairDevice (ulong deviceId, string address, ushort port, ushort discriminator, uint setupPinCode, out Foundation.NSError error);
	public virtual bool PairDeviceWithoutSecurity (ulong deviceId, string address, ushort port, out Foundation.NSError error);
	public virtual void SetListenPort (ushort port);
	public virtual void SetPairingDelegate (IChipDevicePairingDelegate delegate, CoreFoundation.DispatchQueue queue);
	public virtual bool Shutdown ();
	public virtual bool Startup (IChipPersistentStorageDelegate storageDelegate);
	public virtual bool StopDevicePairing (ulong deviceId, out Foundation.NSError error);
	public virtual bool UnpairDevice (ulong deviceId, out Foundation.NSError error);
	public virtual void UpdateDevice (ulong deviceId, ulong fabricId);
}

New Type: Chip.ChipDevicePairingDelegate

public class ChipDevicePairingDelegate : Foundation.NSObject, IChipDevicePairingDelegate, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public ChipDevicePairingDelegate ();
	protected ChipDevicePairingDelegate (Foundation.NSObjectFlag t);
	protected ChipDevicePairingDelegate (IntPtr handle);
	// methods
	public virtual void OnAddressUpdated (Foundation.NSError error);
	public virtual void OnPairingComplete (Foundation.NSError error);
	public virtual void OnPairingDeleted (Foundation.NSError error);
	public virtual void OnStatusUpdate (ChipPairingStatus status);
}

New Type: Chip.ChipDevicePairingDelegate_Extensions

public static class ChipDevicePairingDelegate_Extensions {
	// methods
	public static void OnAddressUpdated (this IChipDevicePairingDelegate This, Foundation.NSError error);
	public static void OnPairingComplete (this IChipDevicePairingDelegate This, Foundation.NSError error);
	public static void OnPairingDeleted (this IChipDevicePairingDelegate This, Foundation.NSError error);
	public static void OnStatusUpdate (this IChipDevicePairingDelegate This, ChipPairingStatus status);
}

New Type: Chip.ChipDoorLock

public class ChipDoorLock : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipDoorLock (Foundation.NSObjectFlag t);
	protected ChipDoorLock (IntPtr handle);
	public ChipDoorLock (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ClearAllPins (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearAllPinsAsync ();
	public virtual void ClearAllRfids (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearAllRfidsAsync ();
	public virtual void ClearHolidaySchedule (byte scheduleId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearHolidayScheduleAsync (byte scheduleId);
	public virtual void ClearPin (ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearPinAsync (ushort userId);
	public virtual void ClearRfid (ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearRfidAsync (ushort userId);
	public virtual void ClearWeekdaySchedule (byte scheduleId, ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearWeekdayScheduleAsync (byte scheduleId, ushort userId);
	public virtual void ClearYeardaySchedule (byte scheduleId, ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearYeardayScheduleAsync (byte scheduleId, ushort userId);
	public virtual void ConfigureAttributeLockState (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeLockStateAsync (ushort minInterval, ushort maxInterval);
	public virtual void GetHolidaySchedule (byte scheduleId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetHolidayScheduleAsync (byte scheduleId);
	public virtual void GetLogRecord (ushort logIndex, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetLogRecordAsync (ushort logIndex);
	public virtual void GetPin (ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetPinAsync (ushort userId);
	public virtual void GetRfid (ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetRfidAsync (ushort userId);
	public virtual void GetUserType (ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetUserTypeAsync (ushort userId);
	public virtual void GetWeekdaySchedule (byte scheduleId, ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetWeekdayScheduleAsync (byte scheduleId, ushort userId);
	public virtual void GetYeardaySchedule (byte scheduleId, ushort userId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetYeardayScheduleAsync (byte scheduleId, ushort userId);
	public virtual void LockDoor (string pin, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> LockDoorAsync (string pin);
	public virtual void ReadAttributeActuatorEnabled (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeActuatorEnabledAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeLockState (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLockStateAsync ();
	public virtual void ReadAttributeLockType (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLockTypeAsync ();
	public virtual void ReportAttributeLockState (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeLockStateAsync ();
	public virtual void SetHolidaySchedule (byte scheduleId, uint localStartTime, uint localEndTime, byte operatingModeDuringHoliday, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetHolidayScheduleAsync (byte scheduleId, uint localStartTime, uint localEndTime, byte operatingModeDuringHoliday);
	public virtual void SetPin (ushort userId, byte userStatus, byte userType, string pin, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetPinAsync (ushort userId, byte userStatus, byte userType, string pin);
	public virtual void SetRfid (ushort userId, byte userStatus, byte userType, string id, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetRfidAsync (ushort userId, byte userStatus, byte userType, string id);
	public virtual void SetUserType (ushort userId, byte userType, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetUserTypeAsync (ushort userId, byte userType);
	public virtual void SetWeekdaySchedule (byte scheduleId, ushort userId, byte daysMask, byte startHour, byte startMinute, byte endHour, byte endMinute, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetWeekdayScheduleAsync (byte scheduleId, ushort userId, byte daysMask, byte startHour, byte startMinute, byte endHour, byte endMinute);
	public virtual void SetYeardaySchedule (byte scheduleId, ushort userId, uint localStartTime, uint localEndTime, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetYeardayScheduleAsync (byte scheduleId, ushort userId, uint localStartTime, uint localEndTime);
	public virtual void UnlockDoor (string pin, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UnlockDoorAsync (string pin);
	public virtual void UnlockWithTimeout (ushort timeoutInSeconds, string pin, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UnlockWithTimeoutAsync (ushort timeoutInSeconds, string pin);
}

New Type: Chip.ChipError

public class ChipError : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipError (Foundation.NSObjectFlag t);
	protected ChipError (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static int ConvertToChipErrorCode (Foundation.NSError errorCode);
	public static Foundation.NSError Create (int errorCode);
}

New Type: Chip.ChipErrorCode

[Serializable]
public enum ChipErrorCode {
	DuplicateExists = 9,
	IntegrityCheckFailed = 8,
	InvalidArgument = 4,
	InvalidIntegerValue = 3,
	InvalidMessageLength = 5,
	InvalidState = 6,
	InvalidStringLength = 2,
	Success = 0,
	UndefinedError = 1,
	WrongAddressType = 7,
}

New Type: Chip.ChipErrorCodeExtensions

public static class ChipErrorCodeExtensions {
	// methods
	public static Foundation.NSString GetDomain (this ChipErrorCode self);
}

New Type: Chip.ChipEthernetNetworkDiagnostics

public class ChipEthernetNetworkDiagnostics : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipEthernetNetworkDiagnostics (Foundation.NSObjectFlag t);
	protected ChipEthernetNetworkDiagnostics (IntPtr handle);
	public ChipEthernetNetworkDiagnostics (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCollisionCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCollisionCountAsync ();
	public virtual void ReadAttributeOverrunCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOverrunCountAsync ();
	public virtual void ReadAttributePacketRxCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePacketRxCountAsync ();
	public virtual void ReadAttributePacketTxCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributePacketTxCountAsync ();
	public virtual void ReadAttributeTxErrCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeTxErrCountAsync ();
	public virtual void ResetCounts (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ResetCountsAsync ();
}

New Type: Chip.ChipFixedLabel

public class ChipFixedLabel : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipFixedLabel (Foundation.NSObjectFlag t);
	protected ChipFixedLabel (IntPtr handle);
	public ChipFixedLabel (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeLabelList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLabelListAsync ();
}

New Type: Chip.ChipGeneralCommissioning

public class ChipGeneralCommissioning : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipGeneralCommissioning (Foundation.NSObjectFlag t);
	protected ChipGeneralCommissioning (IntPtr handle);
	public ChipGeneralCommissioning (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ArmFailSafe (ushort expiryLengthSeconds, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ArmFailSafeAsync (ushort expiryLengthSeconds, ulong breadcrumb, uint timeoutMs);
	public virtual void CommissioningComplete (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> CommissioningCompleteAsync ();
	public virtual void ReadAttributeBreadcrumb (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBreadcrumbAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeFabricId (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeFabricIdAsync ();
	public virtual void SetRegulatoryConfig (byte location, string countryCode, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetRegulatoryConfigAsync (byte location, string countryCode, ulong breadcrumb, uint timeoutMs);
	public virtual void WriteAttributeBreadcrumb (ulong value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBreadcrumbAsync (ulong value);
}

New Type: Chip.ChipGeneralDiagnostics

public class ChipGeneralDiagnostics : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipGeneralDiagnostics (Foundation.NSObjectFlag t);
	protected ChipGeneralDiagnostics (IntPtr handle);
	public ChipGeneralDiagnostics (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeNetworkInterfaces (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeNetworkInterfacesAsync ();
	public virtual void ReadAttributeRebootCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeRebootCountAsync ();
}

New Type: Chip.ChipGroupKeyManagement

public class ChipGroupKeyManagement : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipGroupKeyManagement (Foundation.NSObjectFlag t);
	protected ChipGroupKeyManagement (IntPtr handle);
	public ChipGroupKeyManagement (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeGroupKeys (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeGroupKeysAsync ();
	public virtual void ReadAttributeGroups (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeGroupsAsync ();
}

New Type: Chip.ChipGroups

public class ChipGroups : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipGroups (Foundation.NSObjectFlag t);
	protected ChipGroups (IntPtr handle);
	public ChipGroups (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void AddGroup (ushort groupId, string groupName, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddGroupAsync (ushort groupId, string groupName);
	public virtual void AddGroupIfIdentifying (ushort groupId, string groupName, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddGroupIfIdentifyingAsync (ushort groupId, string groupName);
	public virtual void GetGroupMembership (byte groupCount, ushort groupList, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetGroupMembershipAsync (byte groupCount, ushort groupList);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeNameSupport (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeNameSupportAsync ();
	public virtual void RemoveAllGroups (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveAllGroupsAsync ();
	public virtual void RemoveGroup (ushort groupId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveGroupAsync (ushort groupId);
	public virtual void ViewGroup (ushort groupId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ViewGroupAsync (ushort groupId);
}

New Type: Chip.ChipIdentify

public class ChipIdentify : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipIdentify (Foundation.NSObjectFlag t);
	protected ChipIdentify (IntPtr handle);
	public ChipIdentify (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void Identify (ushort identifyTime, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> IdentifyAsync (ushort identifyTime);
	public virtual void IdentifyQuery (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> IdentifyQueryAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeIdentifyTime (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeIdentifyTimeAsync ();
	public virtual void WriteAttributeIdentifyTime (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeIdentifyTimeAsync (ushort value);
}

New Type: Chip.ChipKeypadInput

public class ChipKeypadInput : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipKeypadInput (Foundation.NSObjectFlag t);
	protected ChipKeypadInput (IntPtr handle);
	public ChipKeypadInput (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void SendKey (byte keyCode, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SendKeyAsync (byte keyCode);
}

New Type: Chip.ChipLevelControl

public class ChipLevelControl : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipLevelControl (Foundation.NSObjectFlag t);
	protected ChipLevelControl (IntPtr handle);
	public ChipLevelControl (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeCurrentLevel (ushort minInterval, ushort maxInterval, byte change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentLevelAsync (ushort minInterval, ushort maxInterval, byte change);
	public virtual void Move (byte moveMode, byte rate, byte optionMask, byte optionOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveAsync (byte moveMode, byte rate, byte optionMask, byte optionOverride);
	public virtual void MoveToLevel (byte level, ushort transitionTime, byte optionMask, byte optionOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToLevelAsync (byte level, ushort transitionTime, byte optionMask, byte optionOverride);
	public virtual void MoveToLevelWithOnOff (byte level, ushort transitionTime, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveToLevelWithOnOffAsync (byte level, ushort transitionTime);
	public virtual void MoveWithOnOff (byte moveMode, byte rate, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> MoveWithOnOffAsync (byte moveMode, byte rate);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCurrentLevel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentLevelAsync ();
	public virtual void ReportAttributeCurrentLevel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentLevelAsync ();
	public virtual void Step (byte stepMode, byte stepSize, ushort transitionTime, byte optionMask, byte optionOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepAsync (byte stepMode, byte stepSize, ushort transitionTime, byte optionMask, byte optionOverride);
	public virtual void StepWithOnOff (byte stepMode, byte stepSize, ushort transitionTime, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StepWithOnOffAsync (byte stepMode, byte stepSize, ushort transitionTime);
	public virtual void Stop (byte optionMask, byte optionOverride, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopAsync (byte optionMask, byte optionOverride);
	public virtual void StopWithOnOff (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopWithOnOffAsync ();
}

New Type: Chip.ChipLowPower

public class ChipLowPower : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipLowPower (Foundation.NSObjectFlag t);
	protected ChipLowPower (IntPtr handle);
	public ChipLowPower (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void Sleep (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SleepAsync ();
}

New Type: Chip.ChipManualSetupPayloadParser

public class ChipManualSetupPayloadParser : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipManualSetupPayloadParser (Foundation.NSObjectFlag t);
	protected ChipManualSetupPayloadParser (IntPtr handle);
	public ChipManualSetupPayloadParser (string decimalStringRepresentation);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual ChipSetupPayload PopulatePayload (out Foundation.NSError error);
}

New Type: Chip.ChipMediaInput

public class ChipMediaInput : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipMediaInput (Foundation.NSObjectFlag t);
	protected ChipMediaInput (IntPtr handle);
	public ChipMediaInput (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void HideInputStatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> HideInputStatusAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeMediaInputList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMediaInputListAsync ();
	public virtual void RenameInput (byte index, string name, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RenameInputAsync (byte index, string name);
	public virtual void SelectInput (byte index, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SelectInputAsync (byte index);
	public virtual void ShowInputStatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ShowInputStatusAsync ();
}

New Type: Chip.ChipMediaPlayback

public class ChipMediaPlayback : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipMediaPlayback (Foundation.NSObjectFlag t);
	protected ChipMediaPlayback (IntPtr handle);
	public ChipMediaPlayback (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void FastForward (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> FastForwardAsync ();
	public virtual void Next (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> NextAsync ();
	public virtual void Pause (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> PauseAsync ();
	public virtual void Play (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> PlayAsync ();
	public virtual void Previous (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> PreviousAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void Rewind (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RewindAsync ();
	public virtual void SkipBackward (ulong deltaPositionMilliseconds, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SkipBackwardAsync (ulong deltaPositionMilliseconds);
	public virtual void SkipForward (ulong deltaPositionMilliseconds, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SkipForwardAsync (ulong deltaPositionMilliseconds);
	public virtual void SkipSeek (ulong position, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SkipSeekAsync (ulong position);
	public virtual void StartOver (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StartOverAsync ();
	public virtual void Stop (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopAsync ();
}

New Type: Chip.ChipNetworkCommissioning

public class ChipNetworkCommissioning : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipNetworkCommissioning (Foundation.NSObjectFlag t);
	protected ChipNetworkCommissioning (IntPtr handle);
	public ChipNetworkCommissioning (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void AddThreadNetwork (Foundation.NSData operationalDataset, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddThreadNetworkAsync (Foundation.NSData operationalDataset, ulong breadcrumb, uint timeoutMs);
	public virtual void AddWiFiNetwork (Foundation.NSData ssid, Foundation.NSData credentials, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddWiFiNetworkAsync (Foundation.NSData ssid, Foundation.NSData credentials, ulong breadcrumb, uint timeoutMs);
	public virtual void DisableNetwork (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> DisableNetworkAsync (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs);
	public virtual void EnableNetwork (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> EnableNetworkAsync (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs);
	public virtual void GetLastNetworkCommissioningResult (uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetLastNetworkCommissioningResultAsync (uint timeoutMs);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void RemoveNetwork (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveNetworkAsync (Foundation.NSData networkId, ulong breadcrumb, uint timeoutMs);
	public virtual void ScanNetworks (Foundation.NSData ssid, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ScanNetworksAsync (Foundation.NSData ssid, ulong breadcrumb, uint timeoutMs);
	public virtual void UpdateThreadNetwork (Foundation.NSData operationalDataset, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UpdateThreadNetworkAsync (Foundation.NSData operationalDataset, ulong breadcrumb, uint timeoutMs);
	public virtual void UpdateWiFiNetwork (Foundation.NSData ssid, Foundation.NSData credentials, ulong breadcrumb, uint timeoutMs, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UpdateWiFiNetworkAsync (Foundation.NSData ssid, Foundation.NSData credentials, ulong breadcrumb, uint timeoutMs);
}

New Type: Chip.ChipOnOff

public class ChipOnOff : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipOnOff (Foundation.NSObjectFlag t);
	protected ChipOnOff (IntPtr handle);
	public ChipOnOff (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeOnOff (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeOnOffAsync (ushort minInterval, ushort maxInterval);
	public virtual void Off (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> OffAsync ();
	public virtual void On (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> OnAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeOnOff (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOnOffAsync ();
	public virtual void ReportAttributeOnOff (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeOnOffAsync ();
	public virtual void Toggle (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ToggleAsync ();
}

New Type: Chip.ChipOnboardingPayloadParser

public class ChipOnboardingPayloadParser : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipOnboardingPayloadParser (Foundation.NSObjectFlag t);
	protected ChipOnboardingPayloadParser (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static ChipSetupPayload SetupPayload (string onboardingPayload, ChipOnboardingPayloadType type, out Foundation.NSError error);
}

New Type: Chip.ChipOnboardingPayloadType

[Serializable]
public enum ChipOnboardingPayloadType {
	Admin = 3,
	ManualCode = 1,
	Nfc = 2,
	QRCode = 0,
}

New Type: Chip.ChipOperationalCredentials

public class ChipOperationalCredentials : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipOperationalCredentials (Foundation.NSObjectFlag t);
	protected ChipOperationalCredentials (IntPtr handle);
	public ChipOperationalCredentials (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void AddOpCert (Foundation.NSData noc, Foundation.NSData iCACertificate, Foundation.NSData iPKValue, ulong caseAdminNode, ushort adminVendorId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddOpCertAsync (Foundation.NSData noc, Foundation.NSData iCACertificate, Foundation.NSData iPKValue, ulong caseAdminNode, ushort adminVendorId);
	public virtual void OpCsrRequest (Foundation.NSData csrNonce, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> OpCsrRequestAsync (Foundation.NSData csrNonce);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeFabricsList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeFabricsListAsync ();
	public virtual void RemoveAllFabrics (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveAllFabricsAsync ();
	public virtual void RemoveFabric (ulong fabricId, ulong nodeId, ushort vendorId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveFabricAsync (ulong fabricId, ulong nodeId, ushort vendorId);
	public virtual void SetFabric (ushort vendorId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetFabricAsync (ushort vendorId);
	public virtual void UpdateFabricLabel (string label, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UpdateFabricLabelAsync (string label);
}

New Type: Chip.ChipOptionalQRCodeInfo

public class ChipOptionalQRCodeInfo : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipOptionalQRCodeInfo (Foundation.NSObjectFlag t);
	protected ChipOptionalQRCodeInfo (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual Foundation.NSNumber InfoType { get; set; }
	public virtual Foundation.NSNumber IntegerValue { get; set; }
	public virtual string StringValue { get; set; }
	public virtual Foundation.NSNumber Tag { get; set; }
}

New Type: Chip.ChipOptionalQRCodeInfoType

[Serializable]
public enum ChipOptionalQRCodeInfoType {
	Int32 = 2,
	String = 1,
	Unknown = 0,
}

New Type: Chip.ChipPairingStatus

[Serializable]
public enum ChipPairingStatus {
	SecurePairingFailed = 1,
	SecurePairingSuccess = 0,
	UnknownStatus = 2,
}

New Type: Chip.ChipPersistentStorageDelegate

public abstract class ChipPersistentStorageDelegate : Foundation.NSObject, IChipPersistentStorageDelegate, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipPersistentStorageDelegate ();
	protected ChipPersistentStorageDelegate (Foundation.NSObjectFlag t);
	protected ChipPersistentStorageDelegate (IntPtr handle);
	// methods
	public virtual void DeleteValue (string key);
	public virtual string GetValue (string key);
	public virtual void SetValue (string key, string value);
}

New Type: Chip.ChipPumpConfigurationAndControl

public class ChipPumpConfigurationAndControl : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipPumpConfigurationAndControl (Foundation.NSObjectFlag t);
	protected ChipPumpConfigurationAndControl (IntPtr handle);
	public ChipPumpConfigurationAndControl (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeCapacity (ushort minInterval, ushort maxInterval, short change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCapacityAsync (ushort minInterval, ushort maxInterval, short change);
	public virtual void ReadAttributeCapacity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCapacityAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeEffectiveControlMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEffectiveControlModeAsync ();
	public virtual void ReadAttributeEffectiveOperationMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEffectiveOperationModeAsync ();
	public virtual void ReadAttributeMaxFlow (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMaxFlowAsync ();
	public virtual void ReadAttributeMaxPressure (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMaxPressureAsync ();
	public virtual void ReadAttributeMaxSpeed (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMaxSpeedAsync ();
	public virtual void ReadAttributeOperationMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOperationModeAsync ();
	public virtual void ReportAttributeCapacity (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCapacityAsync ();
	public virtual void WriteAttributeOperationMode (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeOperationModeAsync (byte value);
}

New Type: Chip.ChipQRCodeSetupPayloadParser

public class ChipQRCodeSetupPayloadParser : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipQRCodeSetupPayloadParser (Foundation.NSObjectFlag t);
	protected ChipQRCodeSetupPayloadParser (IntPtr handle);
	public ChipQRCodeSetupPayloadParser (string base38Representation);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual ChipSetupPayload PopulatePayload (out Foundation.NSError error);
}

New Type: Chip.ChipReadAttributeResult

public class ChipReadAttributeResult {
	// constructors
	public ChipReadAttributeResult (Foundation.NSError error, Foundation.NSDictionary data);
	// properties
	public Foundation.NSDictionary Data { get; set; }
	public Foundation.NSError Error { get; set; }
}

New Type: Chip.ChipRelativeHumidityMeasurement

public class ChipRelativeHumidityMeasurement : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipRelativeHumidityMeasurement (Foundation.NSObjectFlag t);
	protected ChipRelativeHumidityMeasurement (IntPtr handle);
	public ChipRelativeHumidityMeasurement (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeMeasuredValue (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeMeasuredValueAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeMaxMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMaxMeasuredValueAsync ();
	public virtual void ReadAttributeMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMeasuredValueAsync ();
	public virtual void ReadAttributeMinMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMinMeasuredValueAsync ();
	public virtual void ReportAttributeMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeMeasuredValueAsync ();
}

New Type: Chip.ChipRendezvousInformationFlags

[Serializable]
[Flags]
public enum ChipRendezvousInformationFlags {
	AllMask = 7,
	Ble = 2,
	None = 0,
	OnNetwork = 4,
	SoftAP = 1,
}

New Type: Chip.ChipResponseHandler

public sealed delegate ChipResponseHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
	// constructors
	public ChipResponseHandler (object object, IntPtr method);
	// methods
	public virtual System.IAsyncResult BeginInvoke (Foundation.NSError error, Foundation.NSDictionary data, System.AsyncCallback callback, object object);
	public virtual void EndInvoke (System.IAsyncResult result);
	public virtual void Invoke (Foundation.NSError error, Foundation.NSDictionary data);
}

New Type: Chip.ChipScenes

public class ChipScenes : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipScenes (Foundation.NSObjectFlag t);
	protected ChipScenes (IntPtr handle);
	public ChipScenes (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void AddScene (ushort groupId, byte sceneId, ushort transitionTime, string sceneName, ushort clusterId, byte length, byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddSceneAsync (ushort groupId, byte sceneId, ushort transitionTime, string sceneName, ushort clusterId, byte length, byte value);
	public virtual void GetSceneMembership (ushort groupId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetSceneMembershipAsync (ushort groupId);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCurrentGroup (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentGroupAsync ();
	public virtual void ReadAttributeCurrentScene (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentSceneAsync ();
	public virtual void ReadAttributeNameSupport (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeNameSupportAsync ();
	public virtual void ReadAttributeSceneCount (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSceneCountAsync ();
	public virtual void ReadAttributeSceneValid (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSceneValidAsync ();
	public virtual void RecallScene (ushort groupId, byte sceneId, ushort transitionTime, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RecallSceneAsync (ushort groupId, byte sceneId, ushort transitionTime);
	public virtual void RemoveAllScenes (ushort groupId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveAllScenesAsync (ushort groupId);
	public virtual void RemoveScene (ushort groupId, byte sceneId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveSceneAsync (ushort groupId, byte sceneId);
	public virtual void StoreScene (ushort groupId, byte sceneId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StoreSceneAsync (ushort groupId, byte sceneId);
	public virtual void ViewScene (ushort groupId, byte sceneId, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ViewSceneAsync (ushort groupId, byte sceneId);
}

New Type: Chip.ChipSetupPayload

public class ChipSetupPayload : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipSetupPayload (Foundation.NSObjectFlag t);
	protected ChipSetupPayload (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual ChipCommissioningFlow CommissioningFlow { get; set; }
	public virtual Foundation.NSNumber Discriminator { get; set; }
	public virtual Foundation.NSNumber ProductId { get; set; }
	public virtual ChipRendezvousInformationFlags RendezvousInformation { get; set; }
	public virtual string SerialNumber { get; set; }
	public virtual Foundation.NSNumber SetUpPinCode { get; set; }
	public virtual Foundation.NSNumber VendorId { get; set; }
	public virtual Foundation.NSNumber Version { get; set; }
	// methods
	public virtual ChipOptionalQRCodeInfo[] GetAllOptionalVendorData (out Foundation.NSError error);
}

New Type: Chip.ChipSoftwareDiagnostics

public class ChipSoftwareDiagnostics : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipSoftwareDiagnostics (Foundation.NSObjectFlag t);
	protected ChipSoftwareDiagnostics (IntPtr handle);
	public ChipSoftwareDiagnostics (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCurrentHeapHighWatermark (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentHeapHighWatermarkAsync ();
	public virtual void ResetWatermarks (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ResetWatermarksAsync ();
}

New Type: Chip.ChipSwitch

public class ChipSwitch : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipSwitch (Foundation.NSObjectFlag t);
	protected ChipSwitch (IntPtr handle);
	public ChipSwitch (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeCurrentPosition (ushort minInterval, ushort maxInterval, byte change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentPositionAsync (ushort minInterval, ushort maxInterval, byte change);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCurrentPosition (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentPositionAsync ();
	public virtual void ReadAttributeNumberOfPositions (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeNumberOfPositionsAsync ();
	public virtual void ReportAttributeCurrentPosition (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentPositionAsync ();
}

New Type: Chip.ChipTargetNavigator

public class ChipTargetNavigator : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipTargetNavigator (Foundation.NSObjectFlag t);
	protected ChipTargetNavigator (IntPtr handle);
	public ChipTargetNavigator (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void NavigateTarget (byte target, string data, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> NavigateTargetAsync (byte target, string data);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeTargetNavigatorList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeTargetNavigatorListAsync ();
}

New Type: Chip.ChipTemperatureMeasurement

public class ChipTemperatureMeasurement : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipTemperatureMeasurement (Foundation.NSObjectFlag t);
	protected ChipTemperatureMeasurement (IntPtr handle);
	public ChipTemperatureMeasurement (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeMeasuredValue (ushort minInterval, ushort maxInterval, short change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeMeasuredValueAsync (ushort minInterval, ushort maxInterval, short change);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeMaxMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMaxMeasuredValueAsync ();
	public virtual void ReadAttributeMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMeasuredValueAsync ();
	public virtual void ReadAttributeMinMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeMinMeasuredValueAsync ();
	public virtual void ReportAttributeMeasuredValue (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeMeasuredValueAsync ();
}

New Type: Chip.ChipTestCluster

public class ChipTestCluster : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipTestCluster (Foundation.NSObjectFlag t);
	protected ChipTestCluster (IntPtr handle);
	public ChipTestCluster (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeBitmap16 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBitmap16Async ();
	public virtual void ReadAttributeBitmap32 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBitmap32Async ();
	public virtual void ReadAttributeBitmap64 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBitmap64Async ();
	public virtual void ReadAttributeBitmap8 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBitmap8Async ();
	public virtual void ReadAttributeBoolean (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeBooleanAsync ();
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeEnum16 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEnum16Async ();
	public virtual void ReadAttributeEnum8 (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeEnum8Async ();
	public virtual void ReadAttributeInt16s (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt16sAsync ();
	public virtual void ReadAttributeInt16u (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt16uAsync ();
	public virtual void ReadAttributeInt32s (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt32sAsync ();
	public virtual void ReadAttributeInt32u (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt32uAsync ();
	public virtual void ReadAttributeInt64s (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt64sAsync ();
	public virtual void ReadAttributeInt64u (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt64uAsync ();
	public virtual void ReadAttributeInt8s (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt8sAsync ();
	public virtual void ReadAttributeInt8u (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInt8uAsync ();
	public virtual void ReadAttributeListInt8u (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeListInt8uAsync ();
	public virtual void ReadAttributeListOctetString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeListOctetStringAsync ();
	public virtual void ReadAttributeListStructOctetString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeListStructOctetStringAsync ();
	public virtual void ReadAttributeOctetString (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOctetStringAsync ();
	public virtual void Test (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> TestAsync ();
	public virtual void TestNotHandled (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> TestNotHandledAsync ();
	public virtual void TestSpecific (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> TestSpecificAsync ();
	public virtual void TestUnknownCommand (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> TestUnknownCommandAsync ();
	public virtual void WriteAttributeBitmap16 (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBitmap16Async (ushort value);
	public virtual void WriteAttributeBitmap32 (uint value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBitmap32Async (uint value);
	public virtual void WriteAttributeBitmap64 (ulong value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBitmap64Async (ulong value);
	public virtual void WriteAttributeBitmap8 (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBitmap8Async (byte value);
	public virtual void WriteAttributeBoolean (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeBooleanAsync (byte value);
	public virtual void WriteAttributeEnum16 (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeEnum16Async (ushort value);
	public virtual void WriteAttributeEnum8 (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeEnum8Async (byte value);
	public virtual void WriteAttributeInt16s (short value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt16sAsync (short value);
	public virtual void WriteAttributeInt16u (ushort value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt16uAsync (ushort value);
	public virtual void WriteAttributeInt32s (int value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt32sAsync (int value);
	public virtual void WriteAttributeInt32u (uint value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt32uAsync (uint value);
	public virtual void WriteAttributeInt64s (long value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt64sAsync (long value);
	public virtual void WriteAttributeInt64u (ulong value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt64uAsync (ulong value);
	public virtual void WriteAttributeInt8s (sbyte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt8sAsync (sbyte value);
	public virtual void WriteAttributeInt8u (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeInt8uAsync (byte value);
	public virtual void WriteAttributeOctetString (Foundation.NSData value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeOctetStringAsync (Foundation.NSData value);
}

New Type: Chip.ChipThermostat

public class ChipThermostat : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipThermostat (Foundation.NSObjectFlag t);
	protected ChipThermostat (IntPtr handle);
	public ChipThermostat (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ClearWeeklySchedule (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ClearWeeklyScheduleAsync ();
	public virtual void ConfigureAttributeLocalTemperature (ushort minInterval, ushort maxInterval, short change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeLocalTemperatureAsync (ushort minInterval, ushort maxInterval, short change);
	public virtual void GetRelayStatusLog (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetRelayStatusLogAsync ();
	public virtual void GetWeeklySchedule (byte daysToReturn, byte modeToReturn, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GetWeeklyScheduleAsync (byte daysToReturn, byte modeToReturn);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeControlSequenceOfOperation (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeControlSequenceOfOperationAsync ();
	public virtual void ReadAttributeLocalTemperature (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeLocalTemperatureAsync ();
	public virtual void ReadAttributeOccupiedCoolingSetpoint (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOccupiedCoolingSetpointAsync ();
	public virtual void ReadAttributeOccupiedHeatingSetpoint (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeOccupiedHeatingSetpointAsync ();
	public virtual void ReadAttributeSystemMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeSystemModeAsync ();
	public virtual void ReportAttributeLocalTemperature (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeLocalTemperatureAsync ();
	public virtual void SetWeeklySchedule (byte numberOfTransitionsForSequence, byte dayOfWeekForSequence, byte modeForSequence, byte payload, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetWeeklyScheduleAsync (byte numberOfTransitionsForSequence, byte dayOfWeekForSequence, byte modeForSequence, byte payload);
	public virtual void SetpointRaiseLower (byte mode, sbyte amount, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SetpointRaiseLowerAsync (byte mode, sbyte amount);
	public virtual void WriteAttributeControlSequenceOfOperation (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeControlSequenceOfOperationAsync (byte value);
	public virtual void WriteAttributeOccupiedCoolingSetpoint (short value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeOccupiedCoolingSetpointAsync (short value);
	public virtual void WriteAttributeOccupiedHeatingSetpoint (short value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeOccupiedHeatingSetpointAsync (short value);
	public virtual void WriteAttributeSystemMode (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeSystemModeAsync (byte value);
}

New Type: Chip.ChipTrustedRootCertificates

public class ChipTrustedRootCertificates : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipTrustedRootCertificates (Foundation.NSObjectFlag t);
	protected ChipTrustedRootCertificates (IntPtr handle);
	public ChipTrustedRootCertificates (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void AddTrustedRootCertificate (Foundation.NSData rootCertificate, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> AddTrustedRootCertificateAsync (Foundation.NSData rootCertificate);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void RemoveTrustedRootCertificate (Foundation.NSData trustedRootIdentifier, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> RemoveTrustedRootCertificateAsync (Foundation.NSData trustedRootIdentifier);
}

New Type: Chip.ChipTvChannel

public class ChipTvChannel : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipTvChannel (Foundation.NSObjectFlag t);
	protected ChipTvChannel (IntPtr handle);
	public ChipTvChannel (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ChangeChannel (string match, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ChangeChannelAsync (string match);
	public virtual void ChangeChannelByNumber (ushort majorNumber, ushort minorNumber, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ChangeChannelByNumberAsync (ushort majorNumber, ushort minorNumber);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeCurrentTvChannel (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentTvChannelAsync ();
	public virtual void ReadAttributeTvChannelLineup (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeTvChannelLineupAsync ();
	public virtual void ReadAttributeTvChannelList (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeTvChannelListAsync ();
	public virtual void SkipChannel (ushort count, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> SkipChannelAsync (ushort count);
}

New Type: Chip.ChipWakeOnLan

public class ChipWakeOnLan : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipWakeOnLan (Foundation.NSObjectFlag t);
	protected ChipWakeOnLan (IntPtr handle);
	public ChipWakeOnLan (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeWakeOnLanMacAddress (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeWakeOnLanMacAddressAsync ();
}

New Type: Chip.ChipWindowCovering

public class ChipWindowCovering : Chip.ChipCluster, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected ChipWindowCovering (Foundation.NSObjectFlag t);
	protected ChipWindowCovering (IntPtr handle);
	public ChipWindowCovering (ChipDevice device, byte endpoint, CoreFoundation.DispatchQueue queue);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual void ConfigureAttributeConfigStatus (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeConfigStatusAsync (ushort minInterval, ushort maxInterval);
	public virtual void ConfigureAttributeCurrentPositionLift (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentPositionLiftAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void ConfigureAttributeCurrentPositionTilt (ushort minInterval, ushort maxInterval, ushort change, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeCurrentPositionTiltAsync (ushort minInterval, ushort maxInterval, ushort change);
	public virtual void ConfigureAttributeWindowCoveringType (ushort minInterval, ushort maxInterval, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ConfigureAttributeWindowCoveringTypeAsync (ushort minInterval, ushort maxInterval);
	public virtual void DownClose (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> DownCloseAsync ();
	public virtual void GoToLiftPercentage (byte percentageLiftValue, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GoToLiftPercentageAsync (byte percentageLiftValue);
	public virtual void GoToLiftValue (ushort liftValue, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GoToLiftValueAsync (ushort liftValue);
	public virtual void GoToTiltPercentage (byte percentageTiltValue, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GoToTiltPercentageAsync (byte percentageTiltValue);
	public virtual void GoToTiltValue (ushort tiltValue, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> GoToTiltValueAsync (ushort tiltValue);
	public virtual void ReadAttributeClusterRevision (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeClusterRevisionAsync ();
	public virtual void ReadAttributeConfigStatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeConfigStatusAsync ();
	public virtual void ReadAttributeCurrentPositionLift (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentPositionLiftAsync ();
	public virtual void ReadAttributeCurrentPositionTilt (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeCurrentPositionTiltAsync ();
	public virtual void ReadAttributeInstalledClosedLimitLift (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInstalledClosedLimitLiftAsync ();
	public virtual void ReadAttributeInstalledClosedLimitTilt (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInstalledClosedLimitTiltAsync ();
	public virtual void ReadAttributeInstalledOpenLimitLift (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInstalledOpenLimitLiftAsync ();
	public virtual void ReadAttributeInstalledOpenLimitTilt (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeInstalledOpenLimitTiltAsync ();
	public virtual void ReadAttributeMode (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeModeAsync ();
	public virtual void ReadAttributeWindowCoveringType (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReadAttributeWindowCoveringTypeAsync ();
	public virtual void ReportAttributeConfigStatus (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeConfigStatusAsync ();
	public virtual void ReportAttributeCurrentPositionLift (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentPositionLiftAsync ();
	public virtual void ReportAttributeCurrentPositionTilt (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeCurrentPositionTiltAsync ();
	public virtual void ReportAttributeWindowCoveringType (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> ReportAttributeWindowCoveringTypeAsync ();
	public virtual void Stop (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> StopAsync ();
	public virtual void UpOpen (ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> UpOpenAsync ();
	public virtual void WriteAttributeMode (byte value, ChipResponseHandler responseHandler);
	public virtual System.Threading.Tasks.Task<ChipReadAttributeResult> WriteAttributeModeAsync (byte value);
}

New Type: Chip.IChipDevicePairingDelegate

public interface IChipDevicePairingDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}

New Type: Chip.IChipPersistentStorageDelegate

public interface IChipPersistentStorageDelegate : ObjCRuntime.INativeObject, System.IDisposable {
	// methods
	public virtual void DeleteValue (string key);
	public virtual string GetValue (string key);
	public virtual void SetValue (string key, string value);
}

New Namespace NearbyInteraction

New Type: NearbyInteraction.INISessionDelegate

public interface INISessionDelegate : ObjCRuntime.INativeObject, System.IDisposable {
}

New Type: NearbyInteraction.NIConfiguration

public class NIConfiguration : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NIConfiguration (Foundation.NSCoder coder);
	protected NIConfiguration (Foundation.NSObjectFlag t);
	protected NIConfiguration (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: NearbyInteraction.NIDiscoveryToken

public class NIDiscoveryToken : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NIDiscoveryToken (Foundation.NSCoder coder);
	protected NIDiscoveryToken (Foundation.NSObjectFlag t);
	protected NIDiscoveryToken (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: NearbyInteraction.NIErrorCode

[Serializable]
public enum NIErrorCode {
	ActiveSessionsLimitExceeded = -5885,
	InvalidConfiguration = -5888,
	ResourceUsageTimeout = -5886,
	SessionFailed = -5887,
	UnsupportedPlatform = -5889,
	UserDidNotAllow = -5884,
}

New Type: NearbyInteraction.NIErrorCodeExtensions

public static class NIErrorCodeExtensions {
	// methods
	public static Foundation.NSString GetDomain (this NIErrorCode self);
}

New Type: NearbyInteraction.NINearbyAccessoryConfiguration

public class NINearbyAccessoryConfiguration : NearbyInteraction.NIConfiguration, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NINearbyAccessoryConfiguration (Foundation.NSCoder coder);
	protected NINearbyAccessoryConfiguration (Foundation.NSObjectFlag t);
	protected NINearbyAccessoryConfiguration (IntPtr handle);
	public NINearbyAccessoryConfiguration (Foundation.NSData data, out Foundation.NSError error);
	// properties
	public virtual NIDiscoveryToken AccessoryDiscoveryToken { get; }
	public override IntPtr ClassHandle { get; }
}

New Type: NearbyInteraction.NINearbyObject

public class NINearbyObject : Foundation.NSObject, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NINearbyObject (Foundation.NSCoder coder);
	protected NINearbyObject (Foundation.NSObjectFlag t);
	protected NINearbyObject (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual OpenTK.Vector3 Direction { get; }
	public static OpenTK.Vector3 DirectionNotAvailable { get; }
	public virtual NIDiscoveryToken DiscoveryToken { get; }
	public virtual float Distance { get; }
	public static float DistanceNotAvailable { get; }
	// methods
	public virtual Foundation.NSObject Copy (Foundation.NSZone zone);
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: NearbyInteraction.NINearbyObjectRemovalReason

[Serializable]
public enum NINearbyObjectRemovalReason {
	PeerEnded = 1,
	Timeout = 0,
}

New Type: NearbyInteraction.NINearbyPeerConfiguration

public class NINearbyPeerConfiguration : NearbyInteraction.NIConfiguration, Foundation.INSCoding, Foundation.INSCopying, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NINearbyPeerConfiguration (Foundation.NSCoder coder);
	protected NINearbyPeerConfiguration (Foundation.NSObjectFlag t);
	public NINearbyPeerConfiguration (NIDiscoveryToken peerToken);
	protected NINearbyPeerConfiguration (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NIDiscoveryToken PeerDiscoveryToken { get; }
}

New Type: NearbyInteraction.NISession

public class NISession : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NISession ();
	protected NISession (Foundation.NSObjectFlag t);
	protected NISession (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual NIConfiguration Configuration { get; }
	public INISessionDelegate Delegate { get; set; }
	public virtual CoreFoundation.DispatchQueue DelegateQueue { get; set; }
	public virtual NIDiscoveryToken DiscoveryToken { get; }
	public static bool IsSupported { get; }
	public virtual Foundation.NSObject WeakDelegate { get; set; }
	// methods
	protected override void Dispose (bool disposing);
	public virtual void Invalidate ();
	public virtual void Pause ();
	public virtual void Run (NIConfiguration configuration);
}

New Type: NearbyInteraction.NISessionDelegate

public class NISessionDelegate : Foundation.NSObject, Foundation.INSObjectProtocol, INISessionDelegate, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public NISessionDelegate ();
	protected NISessionDelegate (Foundation.NSObjectFlag t);
	protected NISessionDelegate (IntPtr handle);
	// methods
	public virtual void DidGenerateShareableConfigurationData (NISession session, Foundation.NSData shareableConfigurationData, NINearbyObject object);
	public virtual void DidSessionInvalidate (NISession session, Foundation.NSError error);
	public virtual void DidSessionRemoveNearbyObjects (NISession session, NINearbyObject[] nearbyObjects, NINearbyObjectRemovalReason reason);
	public virtual void DidSessionUpdateNearbyObjects (NISession session, NINearbyObject[] nearbyObjects);
	public virtual void SessionSuspensionEnded (NISession session);
	public virtual void SessionWasSuspended (NISession session);
}

New Type: NearbyInteraction.NISessionDelegate_Extensions

public static class NISessionDelegate_Extensions {
	// methods
	public static void DidGenerateShareableConfigurationData (this INISessionDelegate This, NISession session, Foundation.NSData shareableConfigurationData, NINearbyObject object);
	public static void DidSessionInvalidate (this INISessionDelegate This, NISession session, Foundation.NSError error);
	public static void DidSessionRemoveNearbyObjects (this INISessionDelegate This, NISession session, NINearbyObject[] nearbyObjects, NINearbyObjectRemovalReason reason);
	public static void DidSessionUpdateNearbyObjects (this INISessionDelegate This, NISession session, NINearbyObject[] nearbyObjects);
	public static void SessionSuspensionEnded (this INISessionDelegate This, NISession session);
	public static void SessionWasSuspended (this INISessionDelegate This, NISession session);
}

New Namespace OSLog

New Type: OSLog.IOSLogEntryFromProcess

public interface IOSLogEntryFromProcess : ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual ulong ActivityIdentifier { get; }
	public virtual string Process { get; }
	public virtual int ProcessIdentifier { get; }
	public virtual string Sender { get; }
	public virtual ulong ThreadIdentifier { get; }
}

New Type: OSLog.IOSLogEntryWithPayload

public interface IOSLogEntryWithPayload : ObjCRuntime.INativeObject, System.IDisposable {
	// properties
	public virtual string Category { get; }
	public virtual OSLogMessageComponent[] Components { get; }
	public virtual string FormatString { get; }
	public virtual string Subsystem { get; }
}

New Type: OSLog.OSLogEntry

public class OSLogEntry : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected OSLogEntry (Foundation.NSObjectFlag t);
	protected OSLogEntry (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	public virtual string ComposedMessage { get; }
	public virtual Foundation.NSDate Date { get; }
	public virtual OSLogEntryStoreCategory StoreCategory { get; }
}

New Type: OSLog.OSLogEntryActivity

public class OSLogEntryActivity : OSLog.OSLogEntry, Foundation.INSObjectProtocol, IOSLogEntryFromProcess, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected OSLogEntryActivity (Foundation.NSObjectFlag t);
	protected OSLogEntryActivity (IntPtr handle);
	// properties
	public virtual ulong ActivityIdentifier { get; }
	public override IntPtr ClassHandle { get; }
	public virtual ulong ParentActivityIdentifier { get; }
	public virtual string Process { get; }
	public virtual int ProcessIdentifier { get; }
	public virtual string Sender { get; }
	public virtual ulong ThreadIdentifier { get; }
}

New Type: OSLog.OSLogEntryBoundary

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

New Type: OSLog.OSLogEntryLog

public class OSLogEntryLog : OSLog.OSLogEntry, Foundation.INSObjectProtocol, IOSLogEntryFromProcess, IOSLogEntryWithPayload, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected OSLogEntryLog (Foundation.NSObjectFlag t);
	protected OSLogEntryLog (IntPtr handle);
	// properties
	public virtual ulong ActivityIdentifier { get; }
	public virtual string Category { get; }
	public override IntPtr ClassHandle { get; }
	public virtual OSLogMessageComponent[] Components { get; }
	public virtual string FormatString { get; }
	public virtual OSLogEntryLogLevel Level { get; }
	public virtual string Process { get; }
	public virtual int ProcessIdentifier { get; }
	public virtual string Sender { get; }
	public virtual string Subsystem { get; }
	public virtual ulong ThreadIdentifier { get; }
}

New Type: OSLog.OSLogEntryLogLevel

[Serializable]
public enum OSLogEntryLogLevel {
	Debug = 1,
	Error = 4,
	Fault = 5,
	Info = 2,
	Notice = 3,
	Undefined = 0,
}

New Type: OSLog.OSLogEntrySignpost

public class OSLogEntrySignpost : OSLog.OSLogEntry, Foundation.INSObjectProtocol, IOSLogEntryFromProcess, IOSLogEntryWithPayload, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected OSLogEntrySignpost (Foundation.NSObjectFlag t);
	protected OSLogEntrySignpost (IntPtr handle);
	// properties
	public virtual ulong ActivityIdentifier { get; }
	public virtual string Category { get; }
	public override IntPtr ClassHandle { get; }
	public virtual OSLogMessageComponent[] Components { get; }
	public virtual string FormatString { get; }
	public virtual string Process { get; }
	public virtual int ProcessIdentifier { get; }
	public virtual string Sender { get; }
	public virtual ulong SignpostIdentifier { get; }
	public virtual string SignpostName { get; }
	public virtual OSLogEntrySignpostType SignpostType { get; }
	public virtual string Subsystem { get; }
	public virtual ulong ThreadIdentifier { get; }
}

New Type: OSLog.OSLogEntrySignpostType

[Serializable]
public enum OSLogEntrySignpostType {
	Event = 3,
	IntervalBegin = 1,
	IntervalEnd = 2,
	Undefined = 0,
}

New Type: OSLog.OSLogEntryStoreCategory

[Serializable]
public enum OSLogEntryStoreCategory {
	LongTerm1 = 4,
	LongTerm14 = 7,
	LongTerm3 = 5,
	LongTerm30 = 8,
	LongTerm7 = 6,
	LongTermAuto = 3,
	Metadata = 1,
	ShortTerm = 2,
	Undefined = 0,
}

New Type: OSLog.OSLogEnumerator

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

New Type: OSLog.OSLogEnumeratorOptions

[Serializable]
[Flags]
public enum OSLogEnumeratorOptions {
	Reverse = 1,
}

New Type: OSLog.OSLogMessageComponent

public class OSLogMessageComponent : Foundation.NSObject, Foundation.INSCoding, Foundation.INSObjectProtocol, Foundation.INSSecureCoding, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	public OSLogMessageComponent (Foundation.NSCoder coder);
	protected OSLogMessageComponent (Foundation.NSObjectFlag t);
	protected OSLogMessageComponent (IntPtr handle);
	// properties
	public virtual OSLogMessageComponentArgumentCategory ArgumentCategory { get; }
	public virtual Foundation.NSData ArgumentDataValue { get; }
	public virtual double ArgumentDoubleValue { get; }
	public virtual long ArgumentInt64Value { get; }
	public virtual Foundation.NSNumber ArgumentNumberValue { get; }
	public virtual string ArgumentStringValue { get; }
	public virtual ulong ArgumentUInt64Value { get; }
	public override IntPtr ClassHandle { get; }
	public virtual string FormatSubstring { get; }
	public virtual string Placeholder { get; }
	// methods
	public virtual void EncodeTo (Foundation.NSCoder encoder);
}

New Type: OSLog.OSLogMessageComponentArgumentCategory

[Serializable]
public enum OSLogMessageComponentArgumentCategory {
	Data = 1,
	Double = 2,
	Int64 = 3,
	String = 4,
	UInt64 = 5,
	Undefined = 0,
}

New Type: OSLog.OSLogPosition

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

New Type: OSLog.OSLogStore

public class OSLogStore : Foundation.NSObject, Foundation.INSObjectProtocol, ObjCRuntime.INativeObject, System.IDisposable, System.IEquatable<Foundation.NSObject> {
	// constructors
	protected OSLogStore (Foundation.NSObjectFlag t);
	protected OSLogStore (IntPtr handle);
	// properties
	public override IntPtr ClassHandle { get; }
	// methods
	public static OSLogStore CreateStore (Foundation.NSUrl url, out Foundation.NSError error);
	public static OSLogStore CreateStore (OSLogStoreScope scope, out Foundation.NSError error);
	public virtual OSLogEnumerator GetEntriesEnumerator (out Foundation.NSError error);
	public virtual OSLogEnumerator GetEntriesEnumerator (OSLogEnumeratorOptions options, OSLogPosition position, Foundation.NSPredicate predicate, out Foundation.NSError error);
	public virtual OSLogPosition GetPosition (Foundation.NSDate date);
	public virtual OSLogPosition GetPositionWithTimeIntervalSinceEnd (double seconds);
	public virtual OSLogPosition GetPositionWithTimeIntervalSinceLatestBoot (double seconds);
}

New Type: OSLog.OSLogStoreScope

[Serializable]
public enum OSLogStoreScope {
	CurrentProcessIdentifier = 1,
	System = 0,
}