monotouch.dll

Namespace MonoTouch

Type Changed: MonoTouch.Constants

Removed field:

	public static const string Version = "7.2.6";

Added fields:

  public static const string CloudKitLibrary = "/System/Library/Frameworks/CloudKit.framework/CloudKit";
  public static const string HealthKitLibrary = "/System/Library/Frameworks/HealthKit.framework/HealthKit";
  public static const string HomeKitLibrary = "/System/Library/Frameworks/HomeKit.framework/HomeKit";
  public static const string LocalAuthenticationLibrary = "/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication";
  public static const string MetalLibrary = "/System/Library/Frameworks/Metal.framework/Metal";
  public static const string PhotosLibrary = "/System/Library/Frameworks/Photos.framework/Photos";
  public static const string PhotosUILibrary = "/System/Library/Frameworks/PhotosUI.framework/PhotosUI";
  public static const string PushKitLibrary = "/System/Library/Frameworks/PushKit.framework/PushKit";
  public static const string SceneKitLibrary = "/System/Library/Frameworks/SceneKit.framework/SceneKit";
  public static const string Version = "7.9.0";

Namespace MonoTouch.Accounts

Type Changed: MonoTouch.Accounts.ACErrorCode

Added value:

  DeniedByPlugin = 17,

Namespace MonoTouch.AddressBookUI

Type Changed: MonoTouch.AddressBookUI.ABNewPersonViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Added properties:

  public virtual MonoTouch.Foundation.NSPredicate PredicateForEnablingPerson { get; set; }
  public virtual MonoTouch.Foundation.NSPredicate PredicateForSelectionOfPerson { get; set; }
  public virtual MonoTouch.Foundation.NSPredicate PredicateForSelectionOfProperty { get; set; }

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationControllerDelegate

Added methods:

  public virtual void DidSelectPerson (ABPeoplePickerNavigationController peoplePicker, System.IntPtr selectedPerson);
  public virtual void DidSelectPerson (ABPeoplePickerNavigationController peoplePicker, System.IntPtr selectedPerson, System.IntPtr abMultiValueIdentifier);

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationControllerDelegate_Extensions

Added methods:

  public static void DidSelectPerson (IABPeoplePickerNavigationControllerDelegate This, ABPeoplePickerNavigationController peoplePicker, System.IntPtr selectedPerson);
  public static void DidSelectPerson (IABPeoplePickerNavigationControllerDelegate This, ABPeoplePickerNavigationController peoplePicker, System.IntPtr selectedPerson, System.IntPtr abMultiValueIdentifier);

Type Changed: MonoTouch.AddressBookUI.ABPersonViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.AddressBookUI.ABUnknownPersonViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.AudioToolbox

Type Changed: MonoTouch.AudioToolbox.AudioFile

Obsoleted method:

  [Obsolete ("Use ReadPacketData instead")]
  public AudioFileError ReadPackets (bool useCache, out int numBytes, AudioStreamPacketDescription[] packetDescriptions, long startingPacket, ref int numPackets, System.IntPtr buffer);

Namespace MonoTouch.AudioUnit

Type Changed: MonoTouch.AudioUnit.AudioTypeEffect

Added value:

  SampleDelay = 1935961209,

Type Changed: MonoTouch.AudioUnit.AudioTypeMixer

Added value:

  Spacial = 862217581,

Obsoleted field:

  [Obsolete ("Replaced by Spacial")]
  Embedded3D = 862217581,

Type Changed: MonoTouch.AudioUnit.AudioTypeMusicDevice

Added value:

  MidiSynth = 1836284270,

Type Changed: MonoTouch.AudioUnit.AudioUnitParameterFlag

Added value:

  OmitFromPresets = 8192,

Type Changed: MonoTouch.AudioUnit.AudioUnitParameterType

Added values:

  ReverbFilterEnable = 18,
  ReverbFilterType = 17,
  SpatialAzimuth = 0,
  SpatialDistance = 2,
  SpatialElevation = 1,
  SpatialEnable = 5,
  SpatialGain = 3,
  SpatialGlobalReverbGain = 9,
  SpatialMaxGain = 7,
  SpatialMinGain = 6,
  SpatialObstructionAttenuation = 11,
  SpatialOcclusionAttenuation = 10,
  SpatialPlaybackRate = 4,
  SpatialReverbBlend = 8,

Type Changed: MonoTouch.AudioUnit.AudioUnitPropertyIDType

Added values:

  AttenuationCurve = 3013,
  BankName = 1007,
  DistanceParams = 3010,
  InstrumentCount = 1000,
  InstrumentName = 1001,
  InstrumentNumber = 1004,
  ParameterIDName = 34,
  ParameterStringFromValue = 33,
  ParameterValueFromString = 38,
  RenderingFlags = 3003,
  ReverbRoomType = 10,
  SoundBankURL = 1100,
  SpatializationAlgorithm = 3000,
  UsesInternalReverb = 1005,

New Type MonoTouch.AudioUnit.ScheduledAudioSliceFlag

[Serializable]
[Flags]
public enum ScheduledAudioSliceFlag {
  BeganToRender = 2,
  BeganToRenderLate = 4,
  Complete = 1,
  Interrupt = 16,
  InterruptAtLoop = 32,
  Loop = 8,
}

New Type MonoTouch.AudioUnit.SpatialMixerAttenuation

[Serializable]
public enum SpatialMixerAttenuation {
  Exponential = 1,
  Inverse = 2,
  Linear = 3,
  Power = 0,
}

New Type MonoTouch.AudioUnit.SpatialMixerRenderingFlags

[Serializable]
[Flags]
public enum SpatialMixerRenderingFlags {
  DistanceAttenuation = 4,
  InterAuralDelay = 1,
}

Namespace MonoTouch.AVFoundation

Type Changed: MonoTouch.AVFoundation.AVAsset

Added property:

  public virtual AVMetadataItem[] Metadata { get; }

Type Changed: MonoTouch.AVFoundation.AVAssetExportSession

Added properties:

  public virtual bool CanPerformMultiplePassesOverSourceMediaData { get; set; }
  public virtual MonoTouch.Foundation.NSUrl DirectoryForTemporaryFiles { get; set; }

Type Changed: MonoTouch.AVFoundation.AVAssetReaderOutput

Added property:

  public virtual bool SupportsRandomAccess { get; set; }

Added methods:

  public virtual void MarkConfigurationAsFinal ();
  public virtual void ResetForReadingTimeRanges (MonoTouch.Foundation.NSValue[] timeRanges);

Type Changed: MonoTouch.AVFoundation.AVAssetResourceLoaderDelegate

Added methods:

  public virtual void DidCancelAuthenticationChallenge (AVAssetResourceLoader resourceLoader, MonoTouch.Foundation.NSUrlAuthenticationChallenge authenticationChallenge);
  public virtual bool ShouldWaitForResponseToAuthenticationChallenge (AVAssetResourceLoader resourceLoader, MonoTouch.Foundation.NSUrlAuthenticationChallenge authenticationChallenge);

Type Changed: MonoTouch.AVFoundation.AVAssetResourceLoaderDelegate_Extensions

Added methods:

  public static void DidCancelAuthenticationChallenge (IAVAssetResourceLoaderDelegate This, AVAssetResourceLoader resourceLoader, MonoTouch.Foundation.NSUrlAuthenticationChallenge authenticationChallenge);
  public static bool ShouldWaitForResponseToAuthenticationChallenge (IAVAssetResourceLoaderDelegate This, AVAssetResourceLoader resourceLoader, MonoTouch.Foundation.NSUrlAuthenticationChallenge authenticationChallenge);

Type Changed: MonoTouch.AVFoundation.AVAssetResourceLoadingContentInformationRequest

Added property:

  public virtual MonoTouch.Foundation.NSDate RenewalDate { get; set; }

Added method:

  protected override void Dispose (bool disposing);

Type Changed: MonoTouch.AVFoundation.AVAssetResourceLoadingDataRequest

Obsoleted constructor:

  [Obsolete ("Type is not meant to be created by user code")]
  public AVAssetResourceLoadingDataRequest ();

Type Changed: MonoTouch.AVFoundation.AVAssetTrack

Added properties:

  public virtual AVMetadataItem[] Metadata { get; }
  public virtual bool RequiresFrameReordering { get; }

Type Changed: MonoTouch.AVFoundation.AVAssetTrackTrackAssociation

Added property:

  public static MonoTouch.Foundation.NSString MetadataReferent { get; }

Type Changed: MonoTouch.AVFoundation.AVAssetWriter

Added property:

  public virtual MonoTouch.Foundation.NSUrl DirectoryForTemporaryFiles { get; set; }

Type Changed: MonoTouch.AVFoundation.AVAssetWriterInput

Added properties:

  public virtual bool CanPerformMultiplePasses { get; }
  public virtual AVAssetWriterInputPassDescription CurrentPassDescription { get; }
  public virtual bool PerformsMultiPassEncodingIfSupported { get; set; }
  public virtual int PreferredMediaChunkAlignment { get; set; }
  public virtual MonoTouch.CoreMedia.CMTime PreferredMediaChunkDuration { get; set; }
  public virtual MonoTouch.Foundation.NSUrl SampleReferenceBaseUrl { get; set; }

Added methods:

  public virtual void MarkCurrentPassAsFinished ();
  public virtual void RespondToEachPassDescription (MonoTouch.CoreFoundation.DispatchQueue queue, System.Action block);

Type Changed: MonoTouch.AVFoundation.AVCaptureDevice

Added properties:

  public virtual MonoTouch.CoreMedia.CMTime ExposureDuration { get; }
  public virtual float ExposureTargetBias { get; }
  public virtual float ExposureTargetOffset { get; }
  public static float FocusModeLensPositionCurrent { get; }
  public virtual float ISO { get; }
  public virtual float LensAperture { get; }
  public virtual float MaxExposureTargetBias { get; }
  public virtual float MinExposureTargetBias { get; }

Added methods:

  public virtual void SetExposureModeCustom (MonoTouch.CoreMedia.CMTime duration, float ISO, System.Action<MonoTouch.CoreMedia.CMTime> completionHandlerr);
  public virtual void SetExposureTargetBias (float bias, System.Action<MonoTouch.CoreMedia.CMTime> completionHandler);

Type Changed: MonoTouch.AVFoundation.AVCaptureDevicePosition

Added value:

  Unspecified = 0,

Type Changed: MonoTouch.AVFoundation.AVMetadataFaceObject

Added interface:

  MonoTouch.Foundation.INSCopying

Added method:

  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);

Type Changed: MonoTouch.AVFoundation.AVUrlAsset

Added property:

  public static MonoTouch.Foundation.NSString HttpCookiesKey { get; }

New Type MonoTouch.AVFoundation.AVAssetReaderOutputMetadataAdaptor

public class AVAssetReaderOutputMetadataAdaptor : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public AVAssetReaderOutputMetadataAdaptor (MonoTouch.Foundation.NSCoder coder);
  public AVAssetReaderOutputMetadataAdaptor (MonoTouch.Foundation.NSObjectFlag t);
  public AVAssetReaderOutputMetadataAdaptor (System.IntPtr handle);
  public AVAssetReaderOutputMetadataAdaptor (AVAssetReaderTrackOutput trackOutput);
  // properties
  public virtual AVAssetReaderTrackOutput AssetReaderTrackOutput { get; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static AVAssetReaderOutputMetadataAdaptor GetAssetReaderOutputMetadataAdapter (AVAssetReaderTrackOutput trackOutput);
  public virtual AVTimedMetadataGroup NextTimedMetadataGroup ();
}

New Type MonoTouch.AVFoundation.AVAssetReaderSampleReferenceOutput

public class AVAssetReaderSampleReferenceOutput : MonoTouch.AVFoundation.AVAssetReaderOutput, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public AVAssetReaderSampleReferenceOutput (MonoTouch.Foundation.NSCoder coder);
  public AVAssetReaderSampleReferenceOutput (MonoTouch.Foundation.NSObjectFlag t);
  public AVAssetReaderSampleReferenceOutput (System.IntPtr handle);
  public AVAssetReaderSampleReferenceOutput (AVAssetTrack track);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual AVAssetTrack Track { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static AVAssetReaderSampleReferenceOutput GetAssetReaderSampleReferenceOutput (AVAssetTrack track);
}

New Type MonoTouch.AVFoundation.AVAssetWriterInputMetadataAdaptor

public class AVAssetWriterInputMetadataAdaptor : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public AVAssetWriterInputMetadataAdaptor (MonoTouch.Foundation.NSCoder coder);
  public AVAssetWriterInputMetadataAdaptor (MonoTouch.Foundation.NSObjectFlag t);
  public AVAssetWriterInputMetadataAdaptor (System.IntPtr handle);
  public AVAssetWriterInputMetadataAdaptor (AVAssetWriterInput assetWriterInput);
  // properties
  public virtual AVAssetWriterInput AssetWriterInput { get; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual bool AppendTimedMetadataGroup (AVTimedMetadataGroup timedMetadataGroup);
  protected override void Dispose (bool disposing);
  public static AVAssetWriterInputMetadataAdaptor GetAssetWriterInputMetadataAdaptor (AVAssetWriterInput input);
}

New Type MonoTouch.AVFoundation.AVAssetWriterInputPassDescription

public class AVAssetWriterInputPassDescription : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public AVAssetWriterInputPassDescription ();
  public AVAssetWriterInputPassDescription (MonoTouch.Foundation.NSCoder coder);
  public AVAssetWriterInputPassDescription (MonoTouch.Foundation.NSObjectFlag t);
  public AVAssetWriterInputPassDescription (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSValue[] SourceTimeRanges { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.AVFoundation.AVAudioCommonFormat

[Serializable]
public enum AVAudioCommonFormat {
  OtherFormat = 0,
  PCMFormatFloat32 = 1,
  PCMFormatFloat64 = 2,
  PCMFormatInt16 = 3,
  PCMFormatInt32 = 4,
}

Namespace MonoTouch.CoreAnimation

Type Changed: MonoTouch.CoreAnimation.CALayer

Added property:

  public virtual MonoTouch.Foundation.NSObject CompositingFilter { get; set; }

Type Changed: MonoTouch.CoreAnimation.CATransition

Removed property:

  public virtual MonoTouch.Foundation.NSObject filter { get; set; }

Added properties:

  [Obsolete ("The name has been fixed, use Filter instead")]
  public MonoTouch.Foundation.NSObject filter { get; set; }
  public virtual MonoTouch.Foundation.NSObject Filter { get; set; }

New Type MonoTouch.CoreAnimation.CAMetalDrawable_Extensions

public static class CAMetalDrawable_Extensions {
}

New Type MonoTouch.CoreAnimation.CAMetalLayer

public class CAMetalLayer : MonoTouch.CoreAnimation.CALayer, ICAMediaTiming, MonoTouch.Foundation.INSCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CAMetalLayer ();
  public CAMetalLayer (MonoTouch.Foundation.NSCoder coder);
  public CAMetalLayer (MonoTouch.Foundation.NSObjectFlag t);
  public CAMetalLayer (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Metal.IMTLDevice Device { get; set; }
  public virtual System.Drawing.RectangleF DrawableSize { get; set; }
  public virtual bool FramebufferOnly { get; set; }
  public virtual MonoTouch.Metal.MTLPixelFormat PixelFormat { get; set; }
  public virtual bool PresentsWithTransaction { get; set; }
  // methods
  public virtual ICAMetalDrawable CreateDrawable ();
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreAnimation.ICAMetalDrawable

public interface ICAMetalDrawable : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, MonoTouch.Metal.IMTLDrawable {
  // properties
  public virtual CAMetalLayer Layer { get; }
  public virtual MonoTouch.Metal.IMTLTexture Texture { get; }
}

Namespace MonoTouch.CoreData

Type Changed: MonoTouch.CoreData.NSPersistentStoreCoordinator

Obsoleted constructor:

  [Obsolete ("Use .ctor(NSManagedObjectModel)")]
  public NSPersistentStoreCoordinator ();

Namespace MonoTouch.CoreGraphics

Type Changed: MonoTouch.CoreGraphics.CGVector

Removed method:

  public override string ToString ();

Namespace MonoTouch.CoreImage

Type Changed: MonoTouch.CoreImage.CIAutoAdjustmentFilterOptions

Added fields:

  public bool? AutoAdjustCrop;
  public bool? AutoAdjustLevel;

Type Changed: MonoTouch.CoreImage.CIDetector

Added properties:

  public static MonoTouch.Foundation.NSString AspectRatio { get; }
  public static MonoTouch.Foundation.NSString FocalLength { get; }
  public static MonoTouch.Foundation.NSString TypeQRCode { get; }
  public static MonoTouch.Foundation.NSString TypeRectangle { get; }

Added methods:

  public static CIDetector CreateQRDetector (CIContext context, CIDetectorOptions detectorOptions);
  public static CIDetector CreateRectangleDetector (CIContext context, CIDetectorOptions detectorOptions);

Type Changed: MonoTouch.CoreImage.CIDetectorOptions

Added properties:

  public float? AspectRatio { get; set; }
  public float? FocalLength { get; set; }

Type Changed: MonoTouch.CoreImage.CIFilter

Added method:

  public static CIFilter GetFilter (string name, MonoTouch.Foundation.NSDictionary inputParameters);

Type Changed: MonoTouch.CoreImage.CIImage

Added property:

  public static int FormatRGBAf { get; }

Added methods:

  public virtual CIImage GetImage (string filterName, MonoTouch.Foundation.NSDictionary inputParameters);
  public virtual CIImage GetImage (CIImageOrientation orientation);
  public virtual CIImage GetImageByClampingToExtent ();
  public virtual MonoTouch.CoreGraphics.CGAffineTransform GetImageTransform (CIImageOrientation orientation);

New Type MonoTouch.CoreImage.CIAreaHistogram

public class CIAreaHistogram : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIAreaHistogram ();
  public CIAreaHistogram (System.IntPtr handle);
  // properties
  public float Count { get; set; }
  public CIVector Extent { get; set; }
  public float Scale { get; set; }
}

New Type MonoTouch.CoreImage.CIAztecCodeGenerator

public class CIAztecCodeGenerator : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIAztecCodeGenerator ();
  public CIAztecCodeGenerator (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIBarcodeFeature

public class CIBarcodeFeature : MonoTouch.CoreImage.CIFeature, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIBarcodeFeature ();
  public CIBarcodeFeature (MonoTouch.Foundation.NSCoder coder);
  public CIBarcodeFeature (MonoTouch.Foundation.NSObjectFlag t);
  public CIBarcodeFeature (System.IntPtr handle);
  // properties
  public virtual System.Drawing.PointF BottomLeft { get; }
  public virtual System.Drawing.PointF BottomRight { get; }
  public virtual System.Drawing.RectangleF Bounds { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData CodeRawData { get; }
  public virtual string CodeString { get; }
  public virtual string CodeType { get; }
  public virtual MonoTouch.Foundation.NSNumber ErrorCorrectionLevel { get; }
  public virtual System.Drawing.PointF TopLeft { get; }
  public virtual System.Drawing.PointF TopRight { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreImage.CICode128BarcodeGenerator

public class CICode128BarcodeGenerator : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CICode128BarcodeGenerator ();
  public CICode128BarcodeGenerator (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIDivideBlendMode

public class CIDivideBlendMode : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIDivideBlendMode ();
  public CIDivideBlendMode (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIGlassDistortion

public class CIGlassDistortion : MonoTouch.CoreImage.CIDistortionFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIGlassDistortion ();
  public CIGlassDistortion (System.IntPtr handle);
  // properties
  public float Scale { get; set; }
  public CIImage Texture { get; set; }
}

New Type MonoTouch.CoreImage.CIHistogramDisplayFilter

public class CIHistogramDisplayFilter : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIHistogramDisplayFilter ();
  public CIHistogramDisplayFilter (System.IntPtr handle);
  // properties
  public float Height { get; set; }
  public float HighLimit { get; set; }
  public float LowLimit { get; set; }
}

New Type MonoTouch.CoreImage.CILinearBurnBlendMode

public class CILinearBurnBlendMode : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CILinearBurnBlendMode ();
  public CILinearBurnBlendMode (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CILinearDodgeBlendMode

public class CILinearDodgeBlendMode : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CILinearDodgeBlendMode ();
  public CILinearDodgeBlendMode (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIPerspectiveCorrection

public class CIPerspectiveCorrection : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIPerspectiveCorrection ();
  public CIPerspectiveCorrection (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIPinLightBlendMode

public class CIPinLightBlendMode : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CIPinLightBlendMode ();
  public CIPinLightBlendMode (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CISubtractBlendMode

public class CISubtractBlendMode : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CISubtractBlendMode ();
  public CISubtractBlendMode (System.IntPtr handle);
}

Namespace MonoTouch.CoreLocation

Type Changed: MonoTouch.CoreLocation.CLBeaconRegion

Obsoleted constructor:

  [Obsolete ("Does not return a valid instance on iOS8")]
  public CLBeaconRegion ();

Type Changed: MonoTouch.CoreLocation.CLLocation

Added property:

  public virtual CLFloor Floor { get; }

Type Changed: MonoTouch.CoreLocation.CLLocationManager

Added event:

  public event System.EventHandler<CLVisitedEventArgs> DidVisit;

Added methods:

  public virtual void RequestAlwaysAuthorization ();
  public virtual void RequestWhenInUseAuthorization ();
  public virtual void StartMonitoringVisits ();
  public virtual void StopMonitoringVisits ();

Type Changed: MonoTouch.CoreLocation.CLLocationManagerDelegate

Added method:

  public virtual void DidVisit (CLLocationManager manager, CLVisit visit);

New Type MonoTouch.CoreLocation.CLFloor

public class CLFloor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CLFloor ();
  public CLFloor (MonoTouch.Foundation.NSCoder coder);
  public CLFloor (MonoTouch.Foundation.NSObjectFlag t);
  public CLFloor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual uint Level { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CoreLocation.CLVisit

public class CLVisit : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CLVisit ();
  public CLVisit (MonoTouch.Foundation.NSCoder coder);
  public CLVisit (MonoTouch.Foundation.NSObjectFlag t);
  public CLVisit (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSDate ArrivalDate { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual CLLocationCoordinate2D Coordinate { get; }
  public virtual MonoTouch.Foundation.NSDate DepartureDate { get; }
  public virtual double HorizontalAccuracy { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreLocation.CLVisitedEventArgs

public class CLVisitedEventArgs : System.EventArgs {
  // constructors
  public CLVisitedEventArgs (CLVisit visit);
  // properties
  public CLVisit Visit { get; set; }
}

Namespace MonoTouch.CoreMotion

New Type MonoTouch.CoreMotion.CMAltimeter

public class CMAltimeter : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CMAltimeter ();
  public CMAltimeter (MonoTouch.Foundation.NSCoder coder);
  public CMAltimeter (MonoTouch.Foundation.NSObjectFlag t);
  public CMAltimeter (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static bool IsRelativeAltitudeAvailable { get; }
  // methods
  public virtual void StartRelativeAltitudeUpdates (MonoTouch.Foundation.NSOperationQueue queue, System.Action<CMAltitudeData,MonoTouch.Foundation.NSError> handler);
  public virtual void StopRelativeAltitudeUpdates ();
}

New Type MonoTouch.CoreMotion.CMAltitudeData

public class CMAltitudeData : MonoTouch.CoreMotion.CMLogItem, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CMAltitudeData (MonoTouch.Foundation.NSCoder coder);
  public CMAltitudeData (MonoTouch.Foundation.NSObjectFlag t);
  public CMAltitudeData (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSNumber RelativeAltitude { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreMotion.CMPedometer

public class CMPedometer : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CMPedometer ();
  public CMPedometer (MonoTouch.Foundation.NSCoder coder);
  public CMPedometer (MonoTouch.Foundation.NSObjectFlag t);
  public CMPedometer (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static bool IsDistanceAvailable { get; }
  public static bool IsFloorCountingAvailable { get; }
  public static bool IsStepCountingAvailable { get; }
  // methods
  public virtual void QueryPedometerData (MonoTouch.Foundation.NSDate start, MonoTouch.Foundation.NSDate end, System.Action<CMPedometerData,MonoTouch.Foundation.NSError> handler);
  public virtual System.Threading.Tasks.Task<CMPedometerData> QueryPedometerDataAsync (MonoTouch.Foundation.NSDate start, MonoTouch.Foundation.NSDate end);
  public virtual void StartPedometerUpdates (MonoTouch.Foundation.NSDate start, System.Action<CMPedometerData,MonoTouch.Foundation.NSError> handler);
  public virtual void StopPedometerUpdates ();
}

New Type MonoTouch.CoreMotion.CMPedometerData

public class CMPedometerData : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CMPedometerData ();
  public CMPedometerData (MonoTouch.Foundation.NSCoder coder);
  public CMPedometerData (MonoTouch.Foundation.NSObjectFlag t);
  public CMPedometerData (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSNumber Distance { get; }
  public virtual MonoTouch.Foundation.NSDate EndDate { get; }
  public virtual MonoTouch.Foundation.NSNumber FloorsAscended { get; }
  public virtual MonoTouch.Foundation.NSNumber FloorsDescended { get; }
  public virtual MonoTouch.Foundation.NSNumber NumberOfSteps { get; }
  public virtual MonoTouch.Foundation.NSDate StartDate { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

Namespace MonoTouch.CoreVideo

Type Changed: MonoTouch.CoreVideo.CVPixelFormatDescription

Added fields:

  public static MonoTouch.Foundation.NSString ContainsRgb;
  public static MonoTouch.Foundation.NSString ContainsYCbCr;

Namespace MonoTouch.EventKitUI

Type Changed: MonoTouch.EventKitUI.EKCalendarChooser

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.EventKitUI.EKEventEditViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.EventKitUI.EKEventViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.ExternalAccessory

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessory

public class EAWiFiUnconfiguredAccessory : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public EAWiFiUnconfiguredAccessory ();
  public EAWiFiUnconfiguredAccessory (MonoTouch.Foundation.NSCoder coder);
  public EAWiFiUnconfiguredAccessory (MonoTouch.Foundation.NSObjectFlag t);
  public EAWiFiUnconfiguredAccessory (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string MacAddress { get; }
  public virtual string Manufacturer { get; }
  public virtual string Model { get; }
  public virtual string Name { get; }
  public virtual EAWiFiUnconfiguredAccessoryProperties Properties { get; }
  public virtual string Ssid { get; }
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser

public class EAWiFiUnconfiguredAccessoryBrowser : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public EAWiFiUnconfiguredAccessoryBrowser ();
  public EAWiFiUnconfiguredAccessoryBrowser (MonoTouch.Foundation.NSCoder coder);
  public EAWiFiUnconfiguredAccessoryBrowser (MonoTouch.Foundation.NSObjectFlag t);
  public EAWiFiUnconfiguredAccessoryBrowser (System.IntPtr handle);
  public EAWiFiUnconfiguredAccessoryBrowser (IEAWiFiUnconfiguredAccessoryBrowserDelegate accessoryBrowserDelegate, MonoTouch.CoreFoundation.DispatchQueue queue);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public EAWiFiUnconfiguredAccessoryBrowserDelegate Delegate { get; set; }
  public virtual MonoTouch.Foundation.NSSet UnconfiguredAccessories { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler<EAWiFiUnconfiguredAccessoryBrowserEventArgs> DidFindUnconfiguredAccessories;
  public event System.EventHandler<EAWiFiUnconfiguredAccessoryDidFinishEventArgs> DidFinishConfiguringAccessory;
  public event System.EventHandler<EAWiFiUnconfiguredAccessoryBrowserEventArgs> DidRemoveUnconfiguredAccessories;
  public event System.EventHandler<EAWiFiUnconfiguredAccessoryEventArgs> DidUpdateState;
  // methods
  protected override void Dispose (bool disposing);
  public virtual void StartSearchingForUnconfiguredAccessories (MonoTouch.Foundation.NSPredicate predicate);
  public virtual void StopSearchingForUnconfiguredAccessories ();
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserDelegate

public class EAWiFiUnconfiguredAccessoryBrowserDelegate : MonoTouch.Foundation.NSObject, IEAWiFiUnconfiguredAccessoryBrowserDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public EAWiFiUnconfiguredAccessoryBrowserDelegate ();
  public EAWiFiUnconfiguredAccessoryBrowserDelegate (MonoTouch.Foundation.NSCoder coder);
  public EAWiFiUnconfiguredAccessoryBrowserDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public EAWiFiUnconfiguredAccessoryBrowserDelegate (System.IntPtr handle);
  // methods
  public virtual void DidFindUnconfiguredAccessories (EAWiFiUnconfiguredAccessoryBrowser browser, MonoTouch.Foundation.NSSet accessories);
  public virtual void DidFinishConfiguringAccessory (EAWiFiUnconfiguredAccessoryBrowser browser, EAWiFiUnconfiguredAccessory accessory, MonoTouch.Foundation.NSError error);
  public virtual void DidRemoveUnconfiguredAccessories (EAWiFiUnconfiguredAccessoryBrowser browser, MonoTouch.Foundation.NSSet accessories);
  public virtual void DidUpdateState (EAWiFiUnconfiguredAccessoryBrowser browser, EAWiFiUnconfiguredAccessoryBrowserState state);
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserDelegate_Extensions

public static class EAWiFiUnconfiguredAccessoryBrowserDelegate_Extensions {
  // methods
  public static void DidFindUnconfiguredAccessories (IEAWiFiUnconfiguredAccessoryBrowserDelegate This, EAWiFiUnconfiguredAccessoryBrowser browser, MonoTouch.Foundation.NSSet accessories);
  public static void DidFinishConfiguringAccessory (IEAWiFiUnconfiguredAccessoryBrowserDelegate This, EAWiFiUnconfiguredAccessoryBrowser browser, EAWiFiUnconfiguredAccessory accessory, MonoTouch.Foundation.NSError error);
  public static void DidRemoveUnconfiguredAccessories (IEAWiFiUnconfiguredAccessoryBrowserDelegate This, EAWiFiUnconfiguredAccessoryBrowser browser, MonoTouch.Foundation.NSSet accessories);
  public static void DidUpdateState (IEAWiFiUnconfiguredAccessoryBrowserDelegate This, EAWiFiUnconfiguredAccessoryBrowser browser, EAWiFiUnconfiguredAccessoryBrowserState state);
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserEventArgs

public class EAWiFiUnconfiguredAccessoryBrowserEventArgs : System.EventArgs {
  // constructors
  public EAWiFiUnconfiguredAccessoryBrowserEventArgs (MonoTouch.Foundation.NSSet accessories);
  // properties
  public MonoTouch.Foundation.NSSet Accessories { get; set; }
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserState

[Serializable]
public enum EAWiFiUnconfiguredAccessoryBrowserState {
  Configuring = 3,
  Searching = 2,
  Stopped = 1,
  WiFiUnavailable = 0,
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryDidFinishEventArgs

public class EAWiFiUnconfiguredAccessoryDidFinishEventArgs : System.EventArgs {
  // constructors
  public EAWiFiUnconfiguredAccessoryDidFinishEventArgs (EAWiFiUnconfiguredAccessory accessory, MonoTouch.Foundation.NSError error);
  // properties
  public EAWiFiUnconfiguredAccessory Accessory { get; set; }
  public MonoTouch.Foundation.NSError Error { get; set; }
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryEventArgs

public class EAWiFiUnconfiguredAccessoryEventArgs : System.EventArgs {
  // constructors
  public EAWiFiUnconfiguredAccessoryEventArgs (EAWiFiUnconfiguredAccessoryBrowserState state);
  // properties
  public EAWiFiUnconfiguredAccessoryBrowserState State { get; set; }
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryProperties

[Serializable]
public enum EAWiFiUnconfiguredAccessoryProperties {
  SupportsAirPlay = 1,
  SupportsAirPrint = 2,
}

New Type MonoTouch.ExternalAccessory.IEAWiFiUnconfiguredAccessoryBrowserDelegate

public interface IEAWiFiUnconfiguredAccessoryBrowserDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

Namespace MonoTouch.Foundation

Type Changed: MonoTouch.Foundation.NSCachedUrlResponse

Added interface:

  INSSecureCoding

Type Changed: MonoTouch.Foundation.NSCalendar

Added properties:

  public virtual string AMSymbol { get; }
  public static NSString CalendarDayChangedNotification { get; }
  public virtual string[] EraSymbols { get; }
  public virtual string[] LongEraSymbols { get; }
  public virtual string[] MonthSymbols { get; }
  public virtual string PMSymbol { get; }
  public virtual string[] QuarterSymbols { get; }
  public virtual string[] ShortMonthSymbols { get; }
  public virtual string[] ShortQuarterSymbols { get; }
  public virtual string[] ShortStandaloneMonthSymbols { get; }
  public virtual string[] ShortStandaloneQuarterSymbols { get; }
  public virtual string[] ShortStandaloneWeekdaySymbols { get; }
  public virtual string[] ShortWeekdaySymbols { get; }
  public virtual string[] StandaloneMonthSymbols { get; }
  public virtual string[] StandaloneQuarterSymbols { get; }
  public virtual string[] StandaloneWeekdaySymbols { get; }
  public virtual string[] VeryShortMonthSymbols { get; }
  public virtual string[] VeryShortStandaloneMonthSymbols { get; }
  public virtual string[] VeryShortStandaloneWeekdaySymbols { get; }
  public virtual string[] VeryShortWeekdaySymbols { get; }
  public virtual string[] WeekdaySymbols { get; }

Added methods:

  public virtual NSComparisonResult CompareDate (NSDate date1, NSDate date2, NSCalendarUnit granularity);
  public virtual NSDateComponents ComponentsFromDateToDate (NSCalendarUnit unitFlags, NSDateComponents startingDate, NSDateComponents resultDate, NSCalendarOptions options);
  public virtual NSDateComponents ComponentsInTimeZone (NSTimeZone timezone, NSDate date);
  public virtual NSDate Date (int era, int year, int month, int date, int hour, int minute, int second, int nanosecond);
  public virtual NSDate DateByAddingUnit (NSCalendarUnit unit, int value, NSDate date, NSCalendarOptions options);
  public virtual NSDate DateBySettingsHour (int hour, int minute, int second, NSDate date, NSCalendarOptions options);
  public virtual NSDate DateBySettingUnit (NSCalendarUnit unit, int value, NSDate date, NSCalendarOptions options);
  public virtual NSDate DateForWeekOfYear (int era, int year, int week, int weekday, int hour, int minute, int second, int nanosecond);
  public virtual void EnumerateDatesStartingAfterDate (NSDate start, NSDateComponents matchingComponents, NSCalendarOptions options, EnumerateDatesCallback callback);
  public virtual NSDate FindNextDateAfterDateMatching (NSDate date, NSDateComponents components, NSCalendarOptions options);
  public virtual NSDate FindNextDateAfterDateMatching (NSDate date, NSCalendarUnit unit, int value, NSCalendarOptions options);
  public virtual NSDate FindNextDateAfterDateMatching (NSDate date, int hour, int minute, int second, NSCalendarOptions options);
  public virtual bool FindNextWeekend (out NSDate date, out double interval, NSCalendarOptions options, NSDate afterDate);
  public virtual int GetComponentFromDate (NSCalendarUnit unit, NSDate date);
  public virtual void GetComponentsFromDate (out int era, out int year, out int month, out int day, NSDate date);
  public virtual void GetComponentsFromDateForWeekOfYear (out int era, out int year, out int weekOfYear, out int weekday, NSDate date);
  public virtual void GetHourComponentsFromDate (out int hour, out int minute, out int second, out int nanosecond, NSDate date);
  public virtual bool IsDateInToday (NSDate date);
  public virtual bool IsDateInTomorrow (NSDate date);
  public virtual bool IsDateInWeekend (NSDate date);
  public virtual bool IsDateInYesterday (NSDate date);
  public virtual bool IsEqualToUnitGranularity (NSDate date1, NSDate date2, NSCalendarUnit unit);
  public virtual bool IsInSameDay (NSDate date1, NSDate date2);
  public virtual bool Matches (NSDate date, NSDateComponents components);
  public virtual bool RangeOfWeekendContainingDate (out NSDate weekendStartDate, out double interval, NSDate date);
  public virtual NSDate StartOfDayForDate (NSDate date);

Type Changed: MonoTouch.Foundation.NSCalendarType

Added values:

  Coptic = 11,
  EthiopicAmeteAlem = 12,
  EthiopicAmeteMihret = 13,
  IslamicTabular = 14,
  IslamicUmmAlQura = 15,

Type Changed: MonoTouch.Foundation.NSCalendarUnit

Added value:

  Nanosecond = 32768,

Type Changed: MonoTouch.Foundation.NSDateComponents

Added properties:

  public virtual bool IsValidDate { get; }
  public virtual int Nanosecond { get; set; }

Added methods:

  public virtual int GetValueForComponent (NSCalendarUnit unit);
  public virtual bool IsValidDateInCalendar (NSCalendar calendar);
  public virtual void SetValueForComponent (int value, NSCalendarUnit unit);

Type Changed: MonoTouch.Foundation.NSFileCoordinator

Added property:

  public virtual string PurposeIdentifier { get; set; }

Added method:

  public virtual void CoordinateAccessWithIntents (NSFileAccessIntent[] intents, NSOperationQueue queue, System.Action<NSError> accessor);

Type Changed: MonoTouch.Foundation.NSFileCoordinatorReadingOptions

Added values:

  ForUploading = 8,
  ImmediatelyAvailableMetadataOnly = 4,
  ResolvesSymbolicLink = 2,

Type Changed: MonoTouch.Foundation.NSIndexPath

Added interface:

  INSSecureCoding

Type Changed: MonoTouch.Foundation.NSIndexSet

Added interface:

  INSSecureCoding

Type Changed: MonoTouch.Foundation.NSMutableCharacterSet

Added properties:

  public static NSCharacterSet Alphanumerics { get; }
  public static NSCharacterSet Capitalized { get; }
  public static NSCharacterSet Controls { get; }
  public static NSCharacterSet DecimalDigits { get; }
  public static NSCharacterSet Decomposables { get; }
  public static NSCharacterSet Illegals { get; }
  public static NSCharacterSet Letters { get; }
  public static NSCharacterSet LowercaseLetters { get; }
  public static NSCharacterSet Marks { get; }
  public static NSCharacterSet Newlines { get; }
  public static NSCharacterSet Punctuation { get; }
  public static NSCharacterSet Symbols { get; }
  public static NSCharacterSet UppercaseLetters { get; }
  public static NSCharacterSet WhitespaceAndNewlines { get; }
  public static NSCharacterSet Whitespaces { get; }

Added methods:

  public static NSCharacterSet FromBitmap (NSData data);
  public static NSCharacterSet FromFile (string path);
  public static NSCharacterSet FromRange (NSRange aRange);
  public static NSCharacterSet FromString (string aString);

Type Changed: MonoTouch.Foundation.NSMutableIndexSet

Added interface:

  INSSecureCoding

Type Changed: MonoTouch.Foundation.NSUrl

Added methods:

  public virtual NSUrl AppendPathExtension (string extension);
  public static NSUrl CreateFileUrl (string[] pathComponents);
  public virtual NSUrl RemoveLastPathComponent ();
  public virtual NSUrl RemovePathExtension ();
  public static NSUrl ResolveAlias (NSUrl aliasFileUrl, NSUrlBookmarkResolutionOptions options, out NSError error);
  public virtual bool StartAccessingSecurityScopedResource ();
  public virtual void StopAccessingSecurityScopedResource ();

Type Changed: MonoTouch.Foundation.NSValue

Added properties:

  public virtual MonoTouch.CoreGraphics.CGVector CGVectorValue { get; }
  public virtual MonoTouch.SceneKit.SCNVector3 Vector3Value { get; }
  public virtual MonoTouch.SceneKit.SCNVector4 Vector4Value { get; }

Added methods:

  public static NSValue FromCGVector (MonoTouch.CoreGraphics.CGVector vector);
  public static NSValue FromVector (MonoTouch.SceneKit.SCNVector4 vector);
  public static NSValue FromVector (MonoTouch.SceneKit.SCNVector3 vector);

New Type MonoTouch.Foundation.EnumerateDatesCallback

public sealed delegate EnumerateDatesCallback : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public EnumerateDatesCallback (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (NSDate date, bool exactMatch, ref bool stop, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (ref bool stop, System.IAsyncResult result);
  public virtual void Invoke (NSDate date, bool exactMatch, ref bool stop);
}

New Type MonoTouch.Foundation.INSExtensionRequestHandling

public interface INSExtensionRequestHandling : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.Foundation.INSUserActivityDelegate

public interface INSUserActivityDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.Foundation.NSDateComponentsFormatter

public class NSDateComponentsFormatter : MonoTouch.Foundation.NSFormatter, INSCoding, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSDateComponentsFormatter ();
  public NSDateComponentsFormatter (NSCoder coder);
  public NSDateComponentsFormatter (NSObjectFlag t);
  public NSDateComponentsFormatter (System.IntPtr handle);
  // properties
  public virtual NSCalendarUnit AllowedUnits { get; set; }
  public virtual bool AllowsFractionalUnits { get; set; }
  public virtual NSCalendar Calendar { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool CollapsesLargestUnit { get; set; }
  public virtual NSFormattingContext FormattingContext { get; set; }
  public virtual bool IncludesApproximationPhrase { get; set; }
  public virtual bool IncludesTimeRemainingPhrase { get; set; }
  public virtual int MaximumUnitCount { get; set; }
  public virtual NSDateComponentsFormatterUnitsStyle UnitsStyle { get; set; }
  public virtual NSDateComponentsFormatterZeroFormattingBehavior ZeroFormattingBehavior { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual bool GetObjectValue (out NSObject obj, string str, out string error);
  public static string LocalizedStringFromDateComponents (NSDateComponents components, NSDateComponentsFormatterUnitsStyle unitsStyle);
  public virtual string StringForObjectValue (NSObject obj);
  public virtual string StringFromDate (NSDate startDate, NSDate endDate);
  public virtual string StringFromDateComponents (NSDateComponents components);
  public virtual string StringFromTimeInterval (double ti);
}

New Type MonoTouch.Foundation.NSDateComponentsFormatterUnitsStyle

[Serializable]
public enum NSDateComponentsFormatterUnitsStyle {
  Abbreviated = 1,
  Full = 3,
  Positional = 0,
  Short = 2,
  SpellOut = 4,
}

New Type MonoTouch.Foundation.NSDateComponentsFormatterZeroFormattingBehavior

[Serializable]
public enum NSDateComponentsFormatterZeroFormattingBehavior {
  Default = 1,
  DropAll = 14,
  DropLeading = 2,
  DropMiddle = 4,
  DropTrailing = 8,
  None = 0,
  Pad = 65536,
}

New Type MonoTouch.Foundation.NSDateIntervalFormatter

public class NSDateIntervalFormatter : MonoTouch.Foundation.NSFormatter, INSCoding, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSDateIntervalFormatter ();
  public NSDateIntervalFormatter (NSCoder coder);
  public NSDateIntervalFormatter (NSObjectFlag t);
  public NSDateIntervalFormatter (System.IntPtr handle);
  // properties
  public virtual NSCalendar Calendar { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual NSDateIntervalFormatterStyle DateStyle { get; set; }
  public virtual string DateTemplate { get; set; }
  public virtual NSLocale Locale { get; set; }
  public virtual NSDateIntervalFormatterStyle TimeStyle { get; set; }
  public virtual NSTimeZone TimeZone { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual string StringFromDate (NSDate fromDate, NSDate toDate);
}

New Type MonoTouch.Foundation.NSDateIntervalFormatterStyle

[Serializable]
public enum NSDateIntervalFormatterStyle {
  Full = 4,
  Long = 3,
  Medium = 2,
  None = 0,
  Short = 1,
}

New Type MonoTouch.Foundation.NSEnergyFormatter

public class NSEnergyFormatter : MonoTouch.Foundation.NSFormatter, INSCoding, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSEnergyFormatter ();
  public NSEnergyFormatter (NSCoder coder);
  public NSEnergyFormatter (NSObjectFlag t);
  public NSEnergyFormatter (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool ForFoodEnergyUse { get; set; }
  public virtual NSNumberFormatter NumberFormatter { get; set; }
  public virtual NSFormattingUnitStyle UnitStyle { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual bool GetObjectValue (out NSObject obj, string str, out string error);
  public virtual string StringFromJoules (double numberInJoules);
  public virtual string StringFromValue (double value, NSEnergyFormatterUnit unit);
  public virtual string UnitStringFromJoules (double numberInJoules, out NSEnergyFormatterUnit unitp);
  public virtual string UnitStringFromValue (double value, NSEnergyFormatterUnit unit);
}

New Type MonoTouch.Foundation.NSEnergyFormatterUnit

[Serializable]
public enum NSEnergyFormatterUnit {
  Calorie = 1793,
  Joule = 11,
  Kilocalorie = 1794,
  Kilojoule = 14,
}

New Type MonoTouch.Foundation.NSExtensionContext

public class NSExtensionContext : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSExtensionContext ();
  public NSExtensionContext (NSCoder coder);
  public NSExtensionContext (NSObjectFlag t);
  public NSExtensionContext (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual NSExtensionItem[] InputItems { get; }
  public static NSString ItemsAndErrorsKey { get; }
  // methods
  public virtual void CancelRequest (NSError error);
  public virtual void CompleteRequest (NSExtensionItem[] returningItems, System.Action<bool> completionHandler);
  protected override void Dispose (bool disposing);
  public virtual void OpenUrl (NSUrl url, System.Action<bool> completionHandler);
  public virtual System.Threading.Tasks.Task<bool> OpenUrlAsync (NSUrl url);
}

New Type MonoTouch.Foundation.NSExtensionItem

public class NSExtensionItem : MonoTouch.Foundation.NSObject, INSCoding, INSCopying, INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSExtensionItem ();
  public NSExtensionItem (NSCoder coder);
  public NSExtensionItem (NSObjectFlag t);
  public NSExtensionItem (System.IntPtr handle);
  // properties
  public virtual NSItemProvider[] Attachments { get; set; }
  public static NSString AttachmentsKey { get; }
  public virtual NSAttributedString AttributedContentText { get; set; }
  public static NSString AttributedContentTextKey { get; }
  public virtual NSAttributedString AttributedTitle { get; set; }
  public static NSString AttributedTitleKey { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual NSDictionary UserInfo { get; set; }
  // methods
  public virtual NSObject Copy (NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Foundation.NSExtensionRequestHandling

public class NSExtensionRequestHandling : MonoTouch.Foundation.NSObject, INSExtensionRequestHandling, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSExtensionRequestHandling ();
  public NSExtensionRequestHandling (NSCoder coder);
  public NSExtensionRequestHandling (NSObjectFlag t);
  public NSExtensionRequestHandling (System.IntPtr handle);
  // methods
  public virtual void BeginRequestWithExtensionContext (NSExtensionContext context);
}

New Type MonoTouch.Foundation.NSExtensionRequestHandling_Extensions

public static class NSExtensionRequestHandling_Extensions {
  // methods
  public static void BeginRequestWithExtensionContext (INSExtensionRequestHandling This, NSExtensionContext context);
}

New Type MonoTouch.Foundation.NSFileAccessIntent

public class NSFileAccessIntent : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSFileAccessIntent (NSCoder coder);
  public NSFileAccessIntent (NSObjectFlag t);
  public NSFileAccessIntent (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual NSUrl URL { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static NSFileAccessIntent ReadingIntentWithURL (NSUrl url, NSFileCoordinatorReadingOptions options);
  public static NSFileAccessIntent WritingIntentWithURL (NSUrl url, NSFileCoordinatorWritingOptions options);
}

New Type MonoTouch.Foundation.NSFormattingContext

[Serializable]
public enum NSFormattingContext {
  BeginningOfSentence = 4,
  Dynamic = 1,
  ListItem = 3,
  MiddleOfSentence = 5,
  Standalone = 2,
  Unknown = 0,
}

New Type MonoTouch.Foundation.NSFormattingUnitStyle

[Serializable]
public enum NSFormattingUnitStyle {
  Long = 3,
  Medium = 2,
  Short = 1,
}

New Type MonoTouch.Foundation.NSItemProvider

public class NSItemProvider : MonoTouch.Foundation.NSObject, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSItemProvider ();
  public NSItemProvider (NSCoder coder);
  public NSItemProvider (NSObjectFlag t);
  public NSItemProvider (System.IntPtr handle);
  public NSItemProvider (NSObject item, string typeIdentifier);
  public NSItemProvider (NSUrl fileUrl);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static NSString ErrorDomain { get; }
  public static NSString PreferredImageSizeKey { get; }
  public virtual string[] RegisteredTypeIdentifiers { get; }
  // methods
  public virtual NSObject Copy (NSZone zone);
  public virtual bool HasItemConformingToTypeIdentifier (string typeIdentifier);
  public virtual void LoadItemForTypeIdentifier (string typeIdentifier, NSDictionary options, System.Action<NSObject,MonoTouch.Foundation.NSError> completionHandler);
  public virtual void LoadPreviewImage (NSDictionary options, System.Action<NSObject,MonoTouch.Foundation.NSError> completionHandler);
  public virtual void RegisterItemForTypeIdentifier (string typeIdentifier, NSItemProviderLoadHandler loadHandler);
  public virtual void SetPreviewImageHandler (NSItemProviderLoadHandler handler);
}

New Type MonoTouch.Foundation.NSItemProviderCompletionHandler

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

New Type MonoTouch.Foundation.NSItemProviderErrorCode

[Serializable]
public enum NSItemProviderErrorCode {
  ItemUnavailable = -1000,
  None = 0,
  UnexpectedValueClass = -1100,
  Unknown = -1,
}

New Type MonoTouch.Foundation.NSItemProviderLoadHandler

public sealed delegate NSItemProviderLoadHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public NSItemProviderLoadHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (NSItemProviderCompletionHandler completionHandler, MonoTouch.ObjCRuntime.Class expectedValueClass, NSDictionary options, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (NSItemProviderCompletionHandler completionHandler, MonoTouch.ObjCRuntime.Class expectedValueClass, NSDictionary options);
}

New Type MonoTouch.Foundation.NSMassFormatter

public class NSMassFormatter : MonoTouch.Foundation.NSFormatter, INSCoding, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSMassFormatter ();
  public NSMassFormatter (NSCoder coder);
  public NSMassFormatter (NSObjectFlag t);
  public NSMassFormatter (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool ForPersonMassUse { get; set; }
  public virtual NSNumberFormatter NumberFormatter { get; set; }
  public virtual NSFormattingUnitStyle UnitStyle { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual bool GetObjectValue (out NSObject obj, string str, out string error);
  public virtual string StringFromKilograms (double numberInKilograms);
  public virtual string StringFromValue (double value, NSMassFormatterUnit unit);
  public virtual string UnitStringFromKilograms (double numberInKilograms, NSMassFormatterUnit unitp);
  public virtual string UnitStringFromValue (double value, NSMassFormatterUnit unit);
}

New Type MonoTouch.Foundation.NSMassFormatterUnit

[Serializable]
public enum NSMassFormatterUnit {
  Gram = 11,
  Kilogram = 14,
  Ounce = 1537,
  Pound = 1538,
  Stone = 1539,
}

New Type MonoTouch.Foundation.NSUserActivity

public class NSUserActivity : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSUserActivity ();
  public NSUserActivity (NSCoder coder);
  public NSUserActivity (NSObjectFlag t);
  public NSUserActivity (System.IntPtr handle);
  public NSUserActivity (string activityType);
  // properties
  public virtual string ActivityType { get; }
  public override System.IntPtr ClassHandle { get; }
  public NSUserActivityDelegate Delegate { get; set; }
  public virtual bool NeedsSave { get; set; }
  public virtual bool SupportsContinuationStreams { get; set; }
  public virtual string Title { get; set; }
  public virtual NSDictionary UserInfo { get; set; }
  public virtual NSObject WeakDelegate { get; set; }
  public virtual NSUrl WebPageUrl { get; set; }
  // methods
  public virtual void AddUserInfoEntries (NSDictionary otherDictionary);
  public virtual void BecomeCurrent ();
  protected override void Dispose (bool disposing);
  public virtual void GetContinuationStreams (System.Action<NSInputStream,MonoTouch.Foundation.NSOutputStream,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<NSUserActivityContinuation> GetContinuationStreamsAsync ();
  public virtual void Invalidate ();
}

New Type MonoTouch.Foundation.NSUserActivityContinuation

public class NSUserActivityContinuation {
  // constructors
  public NSUserActivityContinuation (NSInputStream arg1, NSOutputStream arg2);
  // properties
  public NSInputStream Arg1 { get; set; }
  public NSOutputStream Arg2 { get; set; }
}

New Type MonoTouch.Foundation.NSUserActivityDelegate

public class NSUserActivityDelegate : MonoTouch.Foundation.NSObject, INSUserActivityDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSUserActivityDelegate ();
  public NSUserActivityDelegate (NSCoder coder);
  public NSUserActivityDelegate (NSObjectFlag t);
  public NSUserActivityDelegate (System.IntPtr handle);
  // methods
  public virtual void UserActivityReceivedData (NSUserActivity userActivity, NSInputStream inputStream, NSOutputStream outputStream);
  public virtual void UserActivityWasContinued (NSUserActivity userActivity);
  public virtual void UserActivityWillSave (NSUserActivity userActivity);
}

New Type MonoTouch.Foundation.NSUserActivityDelegate_Extensions

public static class NSUserActivityDelegate_Extensions {
  // methods
  public static void UserActivityReceivedData (INSUserActivityDelegate This, NSUserActivity userActivity, NSInputStream inputStream, NSOutputStream outputStream);
  public static void UserActivityWasContinued (INSUserActivityDelegate This, NSUserActivity userActivity);
  public static void UserActivityWillSave (INSUserActivityDelegate This, NSUserActivity userActivity);
}

Namespace MonoTouch.GameController

Type Changed: MonoTouch.GameController.GCController

Added property:

  public virtual GCMotion Motion { get; }

Type Changed: MonoTouch.GameController.GCControllerButtonInput

Removed property:

  public virtual GCControllerButtonValueChangedHandler ValueChangedHandler { get; set; }

Added methods:

  public virtual void SetPressedChangedHandler (GCControllerButtonValueChanged handler);
  public virtual void SetValueChangedHandler (GCControllerButtonValueChanged handler);

Removed Type MonoTouch.GameController.GCControllerButtonValueChangedHandler

New Type MonoTouch.GameController.GCAcceleration

public struct GCAcceleration {
  // fields
  public double X;
  public double Y;
  public double Z;
  // methods
  public override string ToString ();
}

New Type MonoTouch.GameController.GCControllerButtonValueChanged

public sealed delegate GCControllerButtonValueChanged : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public GCControllerButtonValueChanged (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (GCControllerButtonInput button, float buttonValue, bool isPressed, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (GCControllerButtonInput button, float buttonValue, bool isPressed);
}

New Type MonoTouch.GameController.GCMotion

public class GCMotion : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public GCMotion ();
  public GCMotion (MonoTouch.Foundation.NSCoder coder);
  public GCMotion (MonoTouch.Foundation.NSObjectFlag t);
  public GCMotion (System.IntPtr handle);
  // properties
  public virtual GCQuaternion Attitude { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual GCController Controller { get; }
  public virtual GCAcceleration Gravity { get; }
  public virtual GCRotationRate rotationRate { get; }
  public virtual GCAcceleration UserAcceleration { get; }
  public virtual System.Action<GCMotion> ValueChangedHandler { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.GameController.GCQuaternion

public struct GCQuaternion {
  // fields
  public double W;
  public double X;
  public double Y;
  public double Z;
  // methods
  public override string ToString ();
}

New Type MonoTouch.GameController.GCRotationRate

public struct GCRotationRate {
  // fields
  public double X;
  public double Y;
  public double Z;
  // methods
  public override string ToString ();
}

Namespace MonoTouch.GameKit

Type Changed: MonoTouch.GameKit.GKAchievement

Added constructor:

  public GKAchievement (string identifier, GKPlayer player);

Added property:

  public virtual GKPlayer Player { get; }

Added methods:

  public virtual MonoTouch.UIKit.UIViewController ChallengeComposeController (string message, GKPlayer[] players, GKChallengeComposeHandler completionHandler);
  public virtual MonoTouch.UIKit.UIViewController ChallengeComposeController (GKPlayer[] playerIDs, string message, GKChallengeComposeHandler completionHandler);
  public virtual void SelectChallengeablePlayers (GKPlayer[] players, System.Action<GKPlayer[],MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<GKPlayer[]> SelectChallengeablePlayersAsync (GKPlayer[] players);

Type Changed: MonoTouch.GameKit.GKAchievementViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GameKit.GKChallenge

Added properties:

  public virtual GKPlayer IssuingPlayer { get; }
  public virtual GKPlayer ReceivingPlayer { get; }

Type Changed: MonoTouch.GameKit.GKError

Added values:

  PlayerPhotoFailure = 26,
  UbiquityContainerUnavailable = 27,

Type Changed: MonoTouch.GameKit.GKFriendRequestComposeViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Added method:

  public virtual void AddRecipientPlayers (GKPlayer[] players);

Type Changed: MonoTouch.GameKit.GKGameCenterViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GameKit.GKLeaderboard

Added constructor:

  public GKLeaderboard (GKPlayer[] players);

Type Changed: MonoTouch.GameKit.GKLeaderboardViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GameKit.GKLocalPlayer

Added methods:

  public virtual void LoadFriendPlayers (System.Action<GKPlayer[],MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<GKPlayer[]> LoadFriendPlayersAsync ();

Type Changed: MonoTouch.GameKit.GKMatchmakerViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GameKit.GKScore

Added method:

  public virtual MonoTouch.UIKit.UIViewController ChallengeComposeController (string message, GKPlayer[] players, GKChallengeComposeHandler completionHandler);

Type Changed: MonoTouch.GameKit.GKTurnBasedMatchmakerViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.GLKit

Type Changed: MonoTouch.GLKit.GLKView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GLKit.GLKViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.iAd

Type Changed: MonoTouch.iAd.ADBannerView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.ImageIO

Type Changed: MonoTouch.ImageIO.CGImageDestinationOptions

Added properties:

  public bool EmbedThumbnail { get; set; }
  public int? ImageMaxPixelSize { get; set; }
  public bool ShouldExcludeGPS { get; set; }

Type Changed: MonoTouch.ImageIO.CGImageProperties

Added properties:

  public static MonoTouch.Foundation.NSString PNGDelayTime { get; }
  public static MonoTouch.Foundation.NSString PNGLoopCount { get; }
  public static MonoTouch.Foundation.NSString PNGUnclampedDelayTime { get; }

Namespace MonoTouch.JavaScriptCore

Type Changed: MonoTouch.JavaScriptCore.JSContext

Added properties:

  public static JSValue CurrentCallee { get; }
  public virtual string Name { get; set; }

Added method:

  public virtual JSValue EvaluateScript (string script, MonoTouch.Foundation.NSUrl sourceUrl);

Type Changed: MonoTouch.JavaScriptCore.JSManagedValue

Added method:

  public static JSManagedValue Get (JSValue value, MonoTouch.Foundation.NSObject owner);

Namespace MonoTouch.MapKit

Type Changed: MonoTouch.MapKit.MKAnnotationView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKCircleView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKLaunchOptions

Added property:

  public MKMapCamera Camera { get; set; }

Type Changed: MonoTouch.MapKit.MKLocalSearch

Obsoleted constructor:

  [Obsolete ("This will not work on iOS8+")]
  public MKLocalSearch ();

Type Changed: MonoTouch.MapKit.MKMapView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKOverlayPathView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKOverlayView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKPinAnnotationView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKPolygonView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKPolylineView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MapKit.MKTileOverlayRenderer

Obsoleted constructor:

  [Obsolete ("This will not work on iOS8+")]
  public MKTileOverlayRenderer ();

Type Changed: MonoTouch.MapKit.MKUserTrackingBarButtonItem

Added interface:

  MonoTouch.UIKit.IUIAccessibilityIdentification

Namespace MonoTouch.MediaPlayer

Type Changed: MonoTouch.MediaPlayer.MPMediaPickerController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MediaPlayer.MPMoviePlayerViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MediaPlayer.MPVolumeView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.MessageUI

Type Changed: MonoTouch.MessageUI.MFMailComposeViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MessageUI.MFMessageComposeViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.MultipeerConnectivity

Type Changed: MonoTouch.MultipeerConnectivity.MCBrowserViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.ObjCRuntime

Type Changed: MonoTouch.ObjCRuntime.Messaging

Namespace MonoTouch.PassKit

Type Changed: MonoTouch.PassKit.PKAddPassesViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.PassKit.PKPassKitErrorCode

Added value:

  NotEntitled = 4,

New Type MonoTouch.PassKit.PKObject

public class PKObject : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PKObject ();
  public PKObject (MonoTouch.Foundation.NSCoder coder);
  public PKObject (MonoTouch.Foundation.NSObjectFlag t);
  public PKObject (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

Namespace MonoTouch.QuickLook

Type Changed: MonoTouch.QuickLook.QLPreviewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.Social

Type Changed: MonoTouch.Social.SLComposeViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

New Type MonoTouch.Social.SLComposeServiceViewController

public class SLComposeServiceViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIContentContainer, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SLComposeServiceViewController ();
  public SLComposeServiceViewController (MonoTouch.Foundation.NSCoder coder);
  public SLComposeServiceViewController (MonoTouch.Foundation.NSObjectFlag t);
  public SLComposeServiceViewController (System.IntPtr handle);
  // properties
  public virtual MonoTouch.UIKit.UIViewController AutoCompletionViewController { get; set; }
  public virtual MonoTouch.Foundation.NSNumber CharactersRemaining { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string ContentText { get; }
  public virtual string Placeholder { get; set; }
  public virtual MonoTouch.UIKit.UITextView TextView { get; }
  // methods
  public virtual void Cancel ();
  public virtual void DidSelectCancel ();
  public virtual void DidSelectPost ();
  protected override void Dispose (bool disposing);
  public virtual SLComposeSheetConfigurationItem[] GetConfigurationItems ();
  public virtual bool IsContentValid ();
  public virtual MonoTouch.UIKit.UIView LoadPreviewView ();
  public virtual void PopConfigurationViewController ();
  public virtual void PresentationAnimationDidFinish ();
  public virtual void PushConfigurationViewController (MonoTouch.UIKit.UIViewController viewController);
  public virtual void ReloadConfigurationItems ();
  public virtual void ValidateContent ();
}

New Type MonoTouch.Social.SLComposeSheetConfigurationItem

public class SLComposeSheetConfigurationItem : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SLComposeSheetConfigurationItem ();
  public SLComposeSheetConfigurationItem (MonoTouch.Foundation.NSCoder coder);
  public SLComposeSheetConfigurationItem (MonoTouch.Foundation.NSObjectFlag t);
  public SLComposeSheetConfigurationItem (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Title { get; set; }
  public virtual string Value { get; set; }
  public virtual bool ValuePending { get; set; }
  // methods
  public virtual void SetTapHandler (System.Action tapHandler);
}

Namespace MonoTouch.SpriteKit

Type Changed: MonoTouch.SpriteKit.SKAction

Added methods:

  public static SKAction FollowPath (MonoTouch.CoreGraphics.CGPath path, bool offset, bool orient, float speed);
  public static SKAction FollowPath (MonoTouch.CoreGraphics.CGPath path, float speed);
  public static SKAction Hide ();
  public static SKAction ReachTo (System.Drawing.PointF position, SKNode rootNode, float velocity);
  public static SKAction ReachTo (System.Drawing.PointF position, SKNode rootNode, double secs);
  public static SKAction ReachToNode (SKNode node, SKNode rootNode, double sec);
  public static SKAction ReachToNode (SKNode node, SKNode rootNode, float velocity);
  public static SKAction StrengthBy (float strength, double sec);
  public static SKAction StrengthTo (float strength, double sec);
  public static SKAction Unhide ();

Type Changed: MonoTouch.SpriteKit.SKEffectNode

Added property:

  public virtual SKShader Shader { get; set; }

Type Changed: MonoTouch.SpriteKit.SKEmitterNode

Added properties:

  public virtual uint FieldBitMask { get; set; }
  public virtual float ParticleZPositionSpeed { get; set; }
  public virtual SKShader Shader { get; set; }

Type Changed: MonoTouch.SpriteKit.SKLabelNode

Added method:

  public static SKLabelNode FromText (string text);

Type Changed: MonoTouch.SpriteKit.SKNode

Added properties:

  public virtual SKConstraint[] Constraints { get; set; }
  public virtual SKReachConstraints ReachConstraints { get; set; }

Type Changed: MonoTouch.SpriteKit.SKPhysicsBody

Added properties:

  public virtual float Charge { get; set; }
  public virtual uint FieldBitMask { get; set; }
  public virtual bool Pinned { get; set; }

Added methods:

  public static SKPhysicsBody Create (SKTexture texture, float alphaThreshold, System.Drawing.SizeF size);
  public static SKPhysicsBody Create (SKTexture texture, System.Drawing.SizeF size);
  public static SKPhysicsBody CreateBodyFromPath (MonoTouch.CoreGraphics.CGPath path);
  public static SKPhysicsBody CreateCircularBody (float radius);
  public static SKPhysicsBody CreateCircularBody (float radius, System.Drawing.PointF center);
  public static SKPhysicsBody CreateEdge (System.Drawing.PointF fromPoint, System.Drawing.PointF toPoint);
  public static SKPhysicsBody CreateEdgeChain (MonoTouch.CoreGraphics.CGPath path);
  public static SKPhysicsBody CreateEdgeLoop (MonoTouch.CoreGraphics.CGPath path);
  public static SKPhysicsBody CreateEdgeLoop (System.Drawing.RectangleF rect);
  public static SKPhysicsBody CreateRectangularBody (System.Drawing.SizeF size);
  public static SKPhysicsBody CreateRectangularBody (System.Drawing.SizeF size, System.Drawing.PointF center);
  public static SKPhysicsBody FromBodies (SKPhysicsBody[] bodies);

Obsoleted methods:

  [Obsolete ("Use the method FromBodies instead")]
  public static SKPhysicsBody BodyWithBodies (SKPhysicsBody[] bodies);

  [Obsolete ("Use the CreateCircularBody method instead")]
  public static SKPhysicsBody BodyWithCircleOfRadius (float radius, System.Drawing.PointF center);

  [Obsolete ("Use the CreateCircularBody method instead")]
  public static SKPhysicsBody BodyWithCircleOfRadius (float radius);

  [Obsolete ("Use the CreateEdgeChain method instead")]
  public static SKPhysicsBody BodyWithEdgeChainFromPath (MonoTouch.CoreGraphics.CGPath path);

  [Obsolete ("Use the CreateEdge method instead")]
  public static SKPhysicsBody BodyWithEdgeFromPoint (System.Drawing.PointF fromPoint, System.Drawing.PointF toPoint);

  [Obsolete ("Use the CreateEdgeLoop method instead")]
  public static SKPhysicsBody BodyWithEdgeLoopFromPath (MonoTouch.CoreGraphics.CGPath path);

  [Obsolete ("Use the CreateEdgeLoop method instead")]
  public static SKPhysicsBody BodyWithEdgeLoopFromRect (System.Drawing.RectangleF rect);

  [Obsolete ("Use the CreateBodyFromPath method instead")]
  public static SKPhysicsBody BodyWithPolygonFromPath (MonoTouch.CoreGraphics.CGPath path);

  [Obsolete ("Use the CreateRectangularBody method instead")]
  public static SKPhysicsBody BodyWithRectangleOfSize (System.Drawing.SizeF size);

  [Obsolete ("Use the CreateRectangularBody method instead")]
  public static SKPhysicsBody BodyWithRectangleOfSize (System.Drawing.SizeF size, System.Drawing.PointF center);

Type Changed: MonoTouch.SpriteKit.SKPhysicsContact

Added property:

  public virtual MonoTouch.CoreGraphics.CGVector ContactNormal { get; }

Type Changed: MonoTouch.SpriteKit.SKPhysicsJoint

Added properties:

  public virtual MonoTouch.CoreGraphics.CGVector ReactionForce { get; }
  public virtual float ReactionTorque { get; }

Type Changed: MonoTouch.SpriteKit.SKPhysicsJointPin

Added property:

  public virtual float RotationSpeed { get; set; }

Type Changed: MonoTouch.SpriteKit.SKPhysicsWorld

Added methods:

  public virtual MonoTouch.CoreGraphics.CGVector SampleField (SKFieldNode field, System.Drawing.PointF position);
  public virtual MonoTouch.CoreGraphics.CGVector SampleFields (System.Drawing.PointF position);

Type Changed: MonoTouch.SpriteKit.SKScene

Added properties:

  public SKSceneDelegate Delegate { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }

Added methods:

  public virtual void DidApplyConstriants ();
  public virtual void DidFinishUpdate ();

Type Changed: MonoTouch.SpriteKit.SKShapeNode

Added properties:

  public virtual SKShader FillShader { get; set; }
  public virtual SKTexture FillTexture { get; set; }
  public virtual SKShader StrokeShader { get; set; }
  public virtual SKTexture StrokeTexture { get; set; }

Added methods:

  public static SKShapeNode FromCircle (float radius);
  public static SKShapeNode FromEllipse (System.Drawing.SizeF size);
  public static SKShapeNode FromEllipse (System.Drawing.RectangleF rect);
  public static SKShapeNode FromPath (MonoTouch.CoreGraphics.CGPath path);
  public static SKShapeNode FromPath (MonoTouch.CoreGraphics.CGPath path, bool centered);
  public static SKShapeNode FromPoints (ref System.Drawing.PointF points, uint numPoints);
  public static SKShapeNode FromRect (System.Drawing.SizeF size);
  public static SKShapeNode FromRect (System.Drawing.RectangleF rect, float cornerRadius);
  public static SKShapeNode FromRect (System.Drawing.SizeF size, float cornerRadius);
  public static SKShapeNode FromRect (System.Drawing.RectangleF rect);
  public static SKShapeNode FromSplinePoints (ref System.Drawing.PointF points, uint numPoints);

Type Changed: MonoTouch.SpriteKit.SKSpriteNode

Added properties:

  public virtual uint LightingBitMask { get; set; }
  public virtual SKTexture NormalTexture { get; set; }
  public virtual SKShader Shader { get; set; }
  public virtual uint ShadowCastBitMask { get; set; }
  public virtual uint ShadowedBitMask { get; set; }

Added methods:

  public static SKSpriteNode Create (SKTexture texture, SKTexture normalMap);
  public static SKSpriteNode Create (string imageName, bool generateNormalMap);

Type Changed: MonoTouch.SpriteKit.SKTexture

Added methods:

  public virtual SKTexture CreateTextureByGeneratingNormalMap ();
  public virtual SKTexture CreateTextureByGeneratingNormalMap (float smoothness, float contrast);
  public static SKTexture FromData (MonoTouch.Foundation.NSData pixelData, System.Drawing.SizeF size, bool flipped);
  public static SKTexture FromTextureNoise (float smoothness, System.Drawing.SizeF size, bool grayscale);
  public static SKTexture FromTextureVectorNoise (float smoothness, System.Drawing.SizeF size);

Type Changed: MonoTouch.SpriteKit.SKTextureAtlas

Added method:

  public static SKTextureAtlas FromDictionary (MonoTouch.Foundation.NSDictionary properties);

Type Changed: MonoTouch.SpriteKit.SKView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Added properties:

  public virtual bool AllowsTransparency { get; set; }
  public virtual bool ShouldCullNonVisibleNodes { get; set; }
  public virtual bool ShowsFields { get; set; }
  public virtual bool ShowsQuadCount { get; set; }

Added method:

  public virtual SKTexture TextureFromNode (SKNode node, System.Drawing.RectangleF crop);

New Type MonoTouch.SpriteKit.ISKSceneDelegate

public interface ISKSceneDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SpriteKit.SK3DNode

public class SK3DNode : MonoTouch.SpriteKit.SKNode, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SK3DNode ();
  public SK3DNode (MonoTouch.Foundation.NSCoder coder);
  public SK3DNode (MonoTouch.Foundation.NSObjectFlag t);
  public SK3DNode (System.IntPtr handle);
  public SK3DNode (System.Drawing.SizeF viewportSize);
  // properties
  public virtual bool AutoenablesDefaultLighting { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Loops { get; set; }
  public virtual bool Playing { get; set; }
  public virtual MonoTouch.SceneKit.SCNNode PointOfView { get; set; }
  public virtual double SceneTime { get; set; }
  public virtual MonoTouch.SceneKit.SCNScene ScnScene { get; set; }
  public virtual System.Drawing.SizeF ViewportSize { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public static SK3DNode FromViewportSize (System.Drawing.SizeF viewportSize);
  public virtual MonoTouch.SceneKit.SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.Foundation.NSDictionary options);
  public MonoTouch.SceneKit.SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.SceneKit.SCNHitTestOptions options);
  public virtual OpenTK.Vector3 ProjectPoint (OpenTK.Vector3 point);
  public virtual OpenTK.Vector3 UnprojectPoint (OpenTK.Vector3 point);
}

New Type MonoTouch.SpriteKit.SKConstraint

public class SKConstraint : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKConstraint ();
  public SKConstraint (MonoTouch.Foundation.NSCoder coder);
  public SKConstraint (MonoTouch.Foundation.NSObjectFlag t);
  public SKConstraint (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Enabled { get; set; }
  public virtual SKNode ReferenceNode { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SKConstraint CreateDistance (SKRange range, SKNode node);
  public static SKConstraint CreateDistance (SKRange range, System.Drawing.PointF point);
  public static SKConstraint CreateDistance (SKRange range, System.Drawing.PointF point, SKNode node);
  public static SKConstraint CreateOrientToNode (SKNode node, SKRange radians);
  public static SKConstraint CreateOrientToPoint (System.Drawing.PointF point, SKNode node, SKRange radians);
  public static SKConstraint CreateOrientToPoint (System.Drawing.PointF point, SKRange radians);
  public static SKConstraint CreateRestriction (SKRange xRange, SKRange yRange);
  public static SKConstraint CreateXRestriction (SKRange range);
  public static SKConstraint CreateYRestriction (SKRange range);
  public static SKConstraint CreateZRotation (SKRange zRange);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SpriteKit.SKFieldForceEvaluator

public sealed delegate SKFieldForceEvaluator : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SKFieldForceEvaluator (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (OpenTK.Vector3 position, OpenTK.Vector3 velocity, float mass, float charge, double time, System.AsyncCallback callback, object object);
  public virtual OpenTK.Vector3 EndInvoke (System.IAsyncResult result);
  public virtual OpenTK.Vector3 Invoke (OpenTK.Vector3 position, OpenTK.Vector3 velocity, float mass, float charge, double time);
}

New Type MonoTouch.SpriteKit.SKFieldNode

public class SKFieldNode : MonoTouch.SpriteKit.SKNode, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKFieldNode ();
  public SKFieldNode (MonoTouch.Foundation.NSCoder coder);
  public SKFieldNode (MonoTouch.Foundation.NSObjectFlag t);
  public SKFieldNode (System.IntPtr handle);
  // properties
  public virtual float AnimationSpeed { get; set; }
  public virtual uint CategoryBitMask { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual OpenTK.Vector3 Direction { get; set; }
  public virtual bool Enabled { get; set; }
  public virtual bool Exclusive { get; set; }
  public virtual float Falloff { get; set; }
  public virtual float MinimumRadius { get; set; }
  public virtual SKRegion Region { get; set; }
  public virtual float Smoothness { get; set; }
  public virtual float Strength { get; set; }
  public virtual SKTexture Texture { get; set; }
  // methods
  public static SKFieldNode CraeteVortexField ();
  public static SKFieldNode CreateCustomField (SKFieldForceEvaluator evaluator);
  public static SKFieldNode CreateDragField ();
  public static SKFieldNode CreateLinearGravityField (OpenTK.Vector3 direction);
  public static SKFieldNode CreateMagneticField ();
  public static SKFieldNode CreateNoiseField (float smoothness, float speed);
  public static SKFieldNode CreateRadialGravityField ();
  public static SKFieldNode CreateSpringField ();
  public static SKFieldNode CreateTurbulenceField (float smoothness, float speed);
  public static SKFieldNode CreateVelocityField (OpenTK.Vector3 direction);
  public static SKFieldNode CreateVelocityField (SKTexture velocityTexture);
  public static SKFieldNode CreeateElectricField ();
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SpriteKit.SKLightNode

public class SKLightNode : MonoTouch.SpriteKit.SKNode, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKLightNode ();
  public SKLightNode (MonoTouch.Foundation.NSCoder coder);
  public SKLightNode (MonoTouch.Foundation.NSObjectFlag t);
  public SKLightNode (System.IntPtr handle);
  // properties
  public virtual MonoTouch.UIKit.UIColor AmbientColor { get; set; }
  public virtual uint CategoryBitMask { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Enabled { get; set; }
  public virtual float Falloff { get; set; }
  public virtual MonoTouch.UIKit.UIColor LightColor { get; set; }
  public virtual MonoTouch.UIKit.UIColor ShadowColor { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SpriteKit.SKMutableTexture

public class SKMutableTexture : MonoTouch.SpriteKit.SKTexture, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKMutableTexture (MonoTouch.Foundation.NSCoder coder);
  public SKMutableTexture (MonoTouch.Foundation.NSObjectFlag t);
  public SKMutableTexture (System.IntPtr handle);
  public SKMutableTexture (System.Drawing.SizeF size);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static SKMutableTexture Create (System.Drawing.SizeF size);
  public virtual void ModifyPixelData (SKTextureModify modifyMethod);
}

New Type MonoTouch.SpriteKit.SKRange

public class SKRange : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKRange ();
  public SKRange (MonoTouch.Foundation.NSCoder coder);
  public SKRange (MonoTouch.Foundation.NSObjectFlag t);
  public SKRange (System.IntPtr handle);
  public SKRange (float lowerLimit, float upperLimier);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float LowerLimit { get; set; }
  public virtual float UpperLimit { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SKRange Create (float lower, float upper);
  public static SKRange CreateConstant (float value);
  public static SKRange CreateUnlimited ();
  public static SKRange CreateWithLowerLimit (float lower);
  public static SKRange CreateWithUpperLimit (float upper);
  public static SKRange CreateWithVariance (float value, float variance);
}

New Type MonoTouch.SpriteKit.SKReachConstraints

public class SKReachConstraints : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKReachConstraints ();
  public SKReachConstraints (MonoTouch.Foundation.NSCoder coder);
  public SKReachConstraints (MonoTouch.Foundation.NSObjectFlag t);
  public SKReachConstraints (System.IntPtr handle);
  public SKReachConstraints (float lowerAngleLimit, float upperAngleLimit);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float LowerAngleLimit { get; set; }
  public virtual float UpperAngleLimit { get; set; }
}

New Type MonoTouch.SpriteKit.SKRegion

public class SKRegion : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKRegion ();
  public SKRegion (MonoTouch.Foundation.NSCoder coder);
  public SKRegion (MonoTouch.Foundation.NSObjectFlag t);
  public SKRegion (System.IntPtr handle);
  public SKRegion (float radius);
  public SKRegion (System.Drawing.SizeF size);
  public SKRegion (MonoTouch.CoreGraphics.CGPath path);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static SKRegion InfiniteRegion { get; }
  public virtual MonoTouch.CoreGraphics.CGPath Path { get; }
  // methods
  public virtual bool ContainsPoint (System.Drawing.PointF point);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual SKRegion CreateDifference (SKRegion region);
  public virtual SKRegion CreateIntersection (SKRegion region);
  public virtual SKRegion CreateUnion (SKRegion region);
  public virtual SKRegion InverseRegion ();
}

New Type MonoTouch.SpriteKit.SKSceneDelegate

public class SKSceneDelegate : MonoTouch.Foundation.NSObject, ISKSceneDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKSceneDelegate ();
  public SKSceneDelegate (MonoTouch.Foundation.NSCoder coder);
  public SKSceneDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public SKSceneDelegate (System.IntPtr handle);
  // methods
  public virtual void DidApplyConstraints (SKScene scene);
  public virtual void DidEvaluateActions (SKScene scene);
  public virtual void DidFinishUpdate (SKScene scene);
  public virtual void DidSimulatePhysics (SKScene scene);
  public virtual void Update (double currentTime, SKScene scene);
}

New Type MonoTouch.SpriteKit.SKSceneDelegate_Extensions

public static class SKSceneDelegate_Extensions {
  // methods
  public static void DidApplyConstraints (ISKSceneDelegate This, SKScene scene);
  public static void DidEvaluateActions (ISKSceneDelegate This, SKScene scene);
  public static void DidFinishUpdate (ISKSceneDelegate This, SKScene scene);
  public static void DidSimulatePhysics (ISKSceneDelegate This, SKScene scene);
  public static void Update (ISKSceneDelegate This, double currentTime, SKScene scene);
}

New Type MonoTouch.SpriteKit.SKShader

public class SKShader : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKShader ();
  public SKShader (MonoTouch.Foundation.NSCoder coder);
  public SKShader (MonoTouch.Foundation.NSObjectFlag t);
  public SKShader (System.IntPtr handle);
  public SKShader (string shaderSourceCode);
  public SKShader (string sharedSourceCode, SKUniform[] uniforms);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Source { get; set; }
  public virtual SKUniform[] Uniforms { get; set; }
  // methods
  public virtual void AddUniform (SKUniform uniform);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SKShader Create ();
  protected override void Dispose (bool disposing);
  public static SKShader FromFile (string name);
  public static SKShader FromShaderSourceCode (string source, SKUniform[] uniforms);
  public static SKShader FromShaderSourceCode (string source);
  public virtual SKUniform GetUniform (string uniformName);
  public virtual bool IsValid ();
  public virtual void RemoveUniform (string uniforName);
}

New Type MonoTouch.SpriteKit.SKTextureModify

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

New Type MonoTouch.SpriteKit.SKUniform

public class SKUniform : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SKUniform ();
  public SKUniform (string name, OpenTK.Matrix3 value);
  public SKUniform (string name, OpenTK.Vector4 value);
  public SKUniform (string name, OpenTK.Vector3 value);
  public SKUniform (string name, OpenTK.Vector2 value);
  public SKUniform (string name, float value);
  public SKUniform (string name, SKTexture texture);
  public SKUniform (string name);
  public SKUniform (System.IntPtr handle);
  public SKUniform (MonoTouch.Foundation.NSObjectFlag t);
  public SKUniform (MonoTouch.Foundation.NSCoder coder);
  public SKUniform (string name, OpenTK.Matrix4 value);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual OpenTK.Matrix3 FloatMatrix3Value { get; set; }
  public virtual OpenTK.Matrix4 FloatMatrix4Value { get; set; }
  public virtual float FloatValue { get; set; }
  public virtual OpenTK.Vector2 FloatVector2Value { get; set; }
  public virtual OpenTK.Vector3 FloatVector3Value { get; set; }
  public virtual OpenTK.Vector4 FloatVector4Value { get; set; }
  public virtual string Name { get; }
  public virtual SKTexture TextureValue { get; set; }
  public virtual SKUniformType UniformType { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SpriteKit.SKUniformType

[Serializable]
public enum SKUniformType {
  Float = 1,
  FloatMatrix2 = 5,
  FloatMatrix3 = 6,
  FloatMatrix4 = 7,
  FloatVector2 = 2,
  FloatVector3 = 3,
  FloatVector4 = 4,
  None = 0,
  Texture = 8,
}

Namespace MonoTouch.StoreKit

Type Changed: MonoTouch.StoreKit.SKPaymentTransactionState

Added value:

  Deferred = 4,

Type Changed: MonoTouch.StoreKit.SKStoreProductParameterKey

Added properties:

  public static MonoTouch.Foundation.NSString AffiliateToken { get; }
  public static MonoTouch.Foundation.NSString CampaignToken { get; }

Type Changed: MonoTouch.StoreKit.SKStoreProductViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.StoreKit.StoreProductParameters

Added properties:

  public string AffiliateToken { get; set; }
  public string CampaignToken { get; set; }

Namespace MonoTouch.Twitter

Type Changed: MonoTouch.Twitter.TWTweetComposeViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.UIKit

Type Changed: MonoTouch.UIKit.NSLayoutAttribute

Added values:

  FirstBaseline = 12,
  LastBaseline = 11,

Type Changed: MonoTouch.UIKit.NSLayoutFormatOptions

Added values:

  AlignAllFirstBaseline = 4096,
  AlignAllLastBaseline = 2048,

Type Changed: MonoTouch.UIKit.UIAccessibility

Added properties:

  public static bool DarkerSystemColosEnabled { get; }
  public static bool IsBoldTextEnabled { get; }
  public static bool IsGrayscaleEnabled { get; }
  public static bool IsReduceMotionEnabled { get; }
  public static bool IsReduceTransparencyEnabled { get; }
  public static bool IsSwitchControlRunning { get; }

Type Changed: MonoTouch.UIKit.UIActionSheet

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIActivityIndicatorView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIActivityViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Obsoleted property:

  [Obsolete ("Use SetCompletionWithItemsHandler instead")]
  public virtual System.Action<MonoTouch.Foundation.NSString,System.Boolean> CompletionHandler { get; set; }

Added method:

  public virtual void SetCompletionHandler (UIActivityViewControllerCompletion completionHandler);

Type Changed: MonoTouch.UIKit.UIAlertView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIApplication

Added properties:

  public virtual UIUserNotificationSettings CurrentUserNotificationSettings { get; }
  public virtual bool IsRegisteredForRemoteNotifications { get; }
  public static MonoTouch.Foundation.NSString OpenSettingsUrlString { get; }

Added methods:

  public virtual void RegisterForRemoteNotifications ();
  public virtual void RegisterUserNotificationSettings (UIUserNotificationSettings notificationSettings);

Type Changed: MonoTouch.UIKit.UIApplicationDelegate

Added methods:

  public virtual bool ContinueUserActivity (UIApplication application, MonoTouch.Foundation.NSUserActivity userActivity, UIApplicationRestorationHandler completionHandler);
  public virtual void DidFailToContinueUserActivitiy (UIApplication application, string userActivityType, MonoTouch.Foundation.NSError error);
  public virtual void DidRegisterUserNotificationSettings (UIApplication application, UIUserNotificationSettings notificationSettings);
  public virtual void HandleAction (UIApplication application, string actionIdentifier, UILocalNotification localNotification, System.Action completionHandler);
  public virtual void HandleAction (UIApplication application, string actionIdentifier, MonoTouch.Foundation.NSDictionary remoteNotificationInfo, System.Action completionHandler);
  public virtual bool WillContinueUserActivity (UIApplication application, string userActivityType);

Type Changed: MonoTouch.UIKit.UIApplicationDelegate_Extensions

Added methods:

  public static bool ContinueUserActivity (IUIApplicationDelegate This, UIApplication application, MonoTouch.Foundation.NSUserActivity userActivity, UIApplicationRestorationHandler completionHandler);
  public static void DidFailToContinueUserActivitiy (IUIApplicationDelegate This, UIApplication application, string userActivityType, MonoTouch.Foundation.NSError error);
  public static void DidRegisterUserNotificationSettings (IUIApplicationDelegate This, UIApplication application, UIUserNotificationSettings notificationSettings);
  public static void HandleAction (IUIApplicationDelegate This, UIApplication application, string actionIdentifier, UILocalNotification localNotification, System.Action completionHandler);
  public static void HandleAction (IUIApplicationDelegate This, UIApplication application, string actionIdentifier, MonoTouch.Foundation.NSDictionary remoteNotificationInfo, System.Action completionHandler);
  public static bool WillContinueUserActivity (IUIApplicationDelegate This, UIApplication application, string userActivityType);

Type Changed: MonoTouch.UIKit.UIBarButtonItem

Added interface:

  IUIAccessibilityIdentification

Type Changed: MonoTouch.UIKit.UIBarButtonItemStyle

Obsoleted field:

  [Obsolete ("Use UIBarButtonItemStyle.Plain when the minimum deployment target is iOS 7")]
  Bordered = 1,

Type Changed: MonoTouch.UIKit.UIBarItem

Added interface:

  IUIAccessibilityIdentification

Added properties:

  public virtual System.Drawing.PointF AccessibilityActivationPoint { get; set; }
  public virtual bool AccessibilityElementsHidden { get; set; }
  public virtual System.Drawing.RectangleF AccessibilityFrame { get; set; }
  public virtual string AccessibilityHint { get; set; }
  public virtual string AccessibilityIdentifier { get; set; }
  public virtual string AccessibilityLabel { get; set; }
  public virtual string AccessibilityLanguage { get; set; }
  public virtual UIBezierPath AccessibilityPath { get; set; }
  public virtual UIAccessibilityTrait AccessibilityTraits { get; set; }
  public virtual string AccessibilityValue { get; set; }
  public virtual bool AccessibilityViewIsModal { get; set; }
  public static MonoTouch.Foundation.NSString AnnouncementDidFinishNotification { get; }
  public static int AnnouncementNotification { get; }
  public static MonoTouch.Foundation.NSString BoldTextStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString ClosedCaptioningStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString GuidedAccessStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString InvertColorsStatusDidChangeNotification { get; }
  public virtual bool IsAccessibilityElement { get; set; }
  public static int LayoutChangedNotification { get; }
  public static MonoTouch.Foundation.NSString MonoAudioStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString NotificationSwitchControlIdentifier { get; }
  public static int PageScrolledNotification { get; }
  public static MonoTouch.Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
  public static int ScreenChangedNotification { get; }
  public virtual bool ShouldGroupAccessibilityChildren { get; set; }
  public static MonoTouch.Foundation.NSString SpeechAttributeLanguage { get; }
  public static MonoTouch.Foundation.NSString SpeechAttributePitch { get; }
  public static MonoTouch.Foundation.NSString SpeechAttributePunctuation { get; }
  public static MonoTouch.Foundation.NSString SwitchControlStatusDidChangeNotification { get; }
  public static long TraitAdjustable { get; }
  public static long TraitAllowsDirectInteraction { get; }
  public static long TraitButton { get; }
  public static long TraitCausesPageTurn { get; }
  public static long TraitHeader { get; }
  public static long TraitImage { get; }
  public static long TraitKeyboardKey { get; }
  public static long TraitLink { get; }
  public static long TraitNone { get; }
  public static long TraitNotEnabled { get; }
  public static long TraitPlaysSound { get; }
  public static long TraitSearchField { get; }
  public static long TraitSelected { get; }
  public static long TraitStartsMediaSession { get; }
  public static long TraitStaticText { get; }
  public static long TraitSummaryElement { get; }
  public static long TraitUpdatesFrequently { get; }
  public static int UIAccessibilityPauseAssistiveTechnologyNotification { get; }
  public static int UIAccessibilityResumeAssistiveTechnologyNotification { get; }
  public static MonoTouch.Foundation.NSString VoiceOverStatusChanged { get; }

Added method:

  public virtual bool AccessibilityActivate ();

New Type MonoTouch.UIKit.Notifications

public static class Notifications {
  // methods
  public static MonoTouch.Foundation.NSObject ObserveAnnouncementDidFinish (System.EventHandler<UIAccessibilityAnnouncementFinishedEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveBoldTextStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveClosedCaptioningStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveGrayscaleStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveGuidedAccessStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveInvertColorsStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveMonoAudioStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveReduceMotionStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveReduceTransparencyStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveSwitchControlStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
}

Type Changed: MonoTouch.UIKit.UIBarMetrics

Added values:

  Compact = 1,
  CompactPrompt = 102,
  Condensed = 2,

Obsoleted fields:

  [Obsolete ("Use UIBarMetrics.Compact instead")]
  LandscapePhone = 1,

  [Obsolete ("Use UIBarMetrics.CompactPrompt instead")]
  LandscapePhonePrompt = 102,

Type Changed: MonoTouch.UIKit.UIButton

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UICollectionReusableView

Added interface:

  IUITraitEnvironment

Added method:

  public virtual UICollectionViewLayoutAttributes PreferredLayoutAttributesFittingAttributes (UICollectionViewLayoutAttributes layoutAttributes);

Type Changed: MonoTouch.UIKit.UICollectionView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UICollectionViewCell

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UICollectionViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Added methods:

  public virtual void WillDisplayCell (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
  public virtual void WillDisplaySupplementaryView (UICollectionView collectionView, UICollectionReusableView view, string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UICollectionViewDelegate

Added methods:

  public virtual void WillDisplayCell (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
  public virtual void WillDisplaySupplementaryView (UICollectionView collectionView, UICollectionReusableView view, string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UICollectionViewDelegate_Extensions

Added methods:

  public static void WillDisplayCell (IUICollectionViewDelegate This, UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
  public static void WillDisplaySupplementaryView (IUICollectionViewDelegate This, UICollectionView collectionView, UICollectionReusableView view, string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UICollectionViewDelegateFlowLayout

Added methods:

  public override void WillDisplayCell (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
  public override void WillDisplaySupplementaryView (UICollectionView collectionView, UICollectionReusableView view, string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UICollectionViewFlowLayout

Added property:

  public virtual System.Drawing.SizeF EstimatedItemSize { get; set; }

Type Changed: MonoTouch.UIKit.UICollectionViewLayout

Added methods:

  public virtual UICollectionViewLayoutInvalidationContext GetInvalidationContext (UICollectionViewLayoutAttributes preferredAttributes, UICollectionViewLayoutAttributes originalAttributes);
  public virtual bool ShouldInvalidateLayout (UICollectionViewLayoutAttributes preferredAttributes, UICollectionViewLayoutAttributes originalAttributes);

Type Changed: MonoTouch.UIKit.UICollectionViewLayoutInvalidationContext

Added properties:

  public virtual System.Drawing.PointF ContentOffsetAdjustment { get; set; }
  public virtual System.Drawing.SizeF ContentSizeAdjustment { get; set; }
  public virtual MonoTouch.Foundation.NSDictionary InvalidatedDecorationIndexPaths { get; }
  public virtual MonoTouch.Foundation.NSIndexPath[] InvalidatedItemIndexPaths { get; }
  public virtual MonoTouch.Foundation.NSDictionary InvalidatedSupplementaryIndexPaths { get; }

Added methods:

  protected override void Dispose (bool disposing);
  public virtual void InvalidateDecorationElements (MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath[] indexPaths);
  public virtual void InvalidateItems (MonoTouch.Foundation.NSIndexPath[] indexPaths);
  public virtual void InvalidateSupplementaryElements (MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath[] indexPaths);

Type Changed: MonoTouch.UIKit.UICollectionViewSource

Added methods:

  public virtual void WillDisplayCell (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
  public virtual void WillDisplaySupplementaryView (UICollectionView collectionView, UICollectionReusableView view, string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UIControl

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIDatePicker

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIDocument

Added property:

  public virtual MonoTouch.Foundation.NSUserActivity UserActivity { get; set; }

Added methods:

  public virtual void RestoreUserActivityState (MonoTouch.Foundation.NSUserActivity userActivity);
  public virtual void UpdateUserActivityState (MonoTouch.Foundation.NSUserActivity userActivity);

Type Changed: MonoTouch.UIKit.UIGestureRecognizer

Added methods:

  public virtual bool ShouldBeRequiredToFailByGestureRecognizer (UIGestureRecognizer otherGestureRecognizer);
  public virtual bool ShouldRequireFailureOfGestureRecognizer (UIGestureRecognizer otherGestureRecognizer);

Type Changed: MonoTouch.UIKit.UIImage

Added interface:

  IUIAccessibilityIdentification

Added properties:

  public virtual string AccessibilityIdentifier { get; set; }
  public virtual UIImageAsset ImageAsset { get; }
  public virtual UITraitCollection TraitCollection { get; }

Added method:

  public static UIImage ImageBundle (string name, MonoTouch.Foundation.NSBundle bundle, UITraitCollection traitCollection);

Type Changed: MonoTouch.UIKit.UIImagePickerController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIImageView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIInputView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIInterfaceOrientation

Added value:

  Unknown = 0,

Type Changed: MonoTouch.UIKit.UILabel

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UILocalNotification

Added properties:

  public virtual string Category { get; set; }
  public virtual MonoTouch.CoreLocation.CLRegion Region { get; set; }
  public virtual bool RegionTriggersOnce { get; set; }

Type Changed: MonoTouch.UIKit.UIModalPresentationStyle

Added values:

  OverCurrentContext = 6,
  OverFullScreen = 5,
  Popover = 7,

Type Changed: MonoTouch.UIKit.UINavigationBar

Added interfaces:

  IUIBarPositioning
  IUITraitEnvironment

Added property:

  public virtual UIBarPosition BarPosition { get; }

Type Changed: MonoTouch.UIKit.UINavigationController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Added properties:

  public virtual UIPanGestureRecognizer BarCondenseGestureRecognizer { get; }
  public virtual UITapGestureRecognizer BarHideGestureRecognizer { get; }
  public virtual bool CondensesBarsOnSwipe { get; set; }
  public virtual bool CondensesBarsWhenKeyboardAppears { get; set; }
  public virtual bool HidesBarsOnTap { get; set; }
  public virtual bool HidesBarsWhenVerticallyCompact { get; set; }
  public virtual bool NavigationBarCondensed { get; set; }

Added method:

  public virtual void ShowViewController (UIViewController vc, MonoTouch.Foundation.NSObject sender);

Type Changed: MonoTouch.UIKit.UIPageControl

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIPageViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIPickerView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIPopoverBackgroundView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIPrintFormatter

Added property:

  public virtual UIEdgeInsets PerPageContentInsets { get; set; }

Type Changed: MonoTouch.UIKit.UIPrintInteractionController

Added property:

  public virtual bool ShowsPaperSelectionForLoadedPapers { get; set; }

Added method:

  public virtual bool PrintToPrinter (UIPrinter printer, UIPrintInteractionCompletionHandler completion);

Type Changed: MonoTouch.UIKit.UIProgressView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIReferenceLibraryViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIRefreshControl

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIResponder

Added properties:

  public virtual UIInputViewController InputAccessoryViewController { get; }
  public virtual UIInputViewController InputViewController { get; }
  public virtual MonoTouch.Foundation.NSUserActivity UserActivity { get; set; }

Added methods:

  public virtual void RestoreUserActivityState (MonoTouch.Foundation.NSUserActivity activity);
  public virtual void UpdateUserActivityState (MonoTouch.Foundation.NSUserActivity activity);

Type Changed: MonoTouch.UIKit.UIScreen

Added interface:

  IUITraitEnvironment

Added properties:

  public virtual System.Drawing.RectangleF NativeBounds { get; }
  public virtual float NativeScale { get; }
  public virtual UITraitCollection TraitCollection { get; }

Added method:

  public virtual void TraitCollectionDidChange (UITraitCollection previousTraitCollection);

Type Changed: MonoTouch.UIKit.UIScrollView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UISearchBar

Added interfaces:

  IUIBarPositioning
  IUITraitEnvironment

Added properties:

  public virtual UIBarPosition BarPosition { get; }
  public virtual bool EnablesReturnKeyAutomatically { get; set; }
  public virtual UIKeyboardAppearance KeyboardAppearance { get; set; }
  public virtual UIReturnKeyType ReturnKeyType { get; set; }
  public virtual bool SecureTextEntry { get; set; }

Type Changed: MonoTouch.UIKit.UISegmentedControl

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UISlider

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UISplitViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Added properties:

  public static float AutomaticDimension { get; }
  public virtual bool Collapsed { get; }
  public UISplitViewControllerCanCollapsePredicate CollapseSecondViewController { get; set; }
  public virtual UISplitViewControllerDisplayMode DisplayMode { get; }
  public virtual UIBarButtonItem DisplayModeButtonItem { get; }
  public UISplitViewControllerDisplayEvent EventShowDetailViewController { get; set; }
  public UISplitViewControllerDisplayEvent EventShowViewController { get; set; }
  public UISplitViewControllerGetViewController GetPrimaryViewControllerForCollapsingSplitViewController { get; set; }
  public UISplitViewControllerGetViewController GetPrimaryViewControllerForExpandingSplitViewController { get; set; }
  public System.Func<UISplitViewController,MonoTouch.UIKit.UIInterfaceOrientationMask> GetSupportedInterfaceOrientations { get; set; }
  public UISplitViewControllerFetchTargetForActionHandler GetTargetDisplayModeForAction { get; set; }
  public virtual float MaximumPrimaryColumnWidth { get; set; }
  public virtual float MinimumPrimaryColumnWidth { get; set; }
  public virtual UISplitViewControllerDisplayMode PreferredDisplayMode { get; set; }
  public System.Func<UISplitViewController,MonoTouch.UIKit.UIInterfaceOrientation> PreferredInterfaceOrientationForPresentation { get; set; }
  public virtual float PreferredPrimaryColumnWidthFraction { get; set; }
  public virtual float PrimaryColumnWidth { get; }
  public UISplitViewControllerGetSecondaryViewController SeparateSecondaryViewController { get; set; }

Added event:

  public event System.EventHandler<UISplitViewControllerDisplayModeEventArgs> WillChangeDisplayMode;

Removed methods:

  public virtual UIInterfaceOrientationMask GetSupportedInterfaceOrientations (UISplitViewController splitViewController);
  public virtual UIInterfaceOrientation PreferredInterfaceOrientationForPresentation (UISplitViewController splitViewController);

Added methods:

  public virtual void ShowDetailViewController (UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public virtual void ShowViewController (UIViewController vc, MonoTouch.Foundation.NSObject sender);

Type Changed: MonoTouch.UIKit.UISplitViewControllerDelegate

Added methods:

  public virtual bool CollapseSecondViewController (UISplitViewController splitViewController, UIViewController secondaryViewController, UIViewController primaryViewController);
  public virtual bool EventShowDetailViewController (UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public virtual bool EventShowViewController (UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public virtual UIViewController GetPrimaryViewControllerForCollapsingSplitViewController (UISplitViewController splitViewController);
  public virtual UIViewController GetPrimaryViewControllerForExpandingSplitViewController (UISplitViewController splitViewController);
  public virtual UIInterfaceOrientationMask GetSupportedInterfaceOrientations (UISplitViewController splitViewController);
  public virtual UISplitViewControllerDisplayMode GetTargetDisplayModeForAction (UISplitViewController svc);
  public virtual UIInterfaceOrientation PreferredInterfaceOrientationForPresentation (UISplitViewController splitViewController);
  public virtual UIViewController SeparateSecondaryViewController (UISplitViewController splitViewController, UIViewController primaryViewController);
  public virtual void WillChangeDisplayMode (UISplitViewController svc, UISplitViewControllerDisplayMode displayMode);

Type Changed: MonoTouch.UIKit.UISplitViewControllerDelegate_Extensions

Added methods:

  public static bool CollapseSecondViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController, UIViewController secondaryViewController, UIViewController primaryViewController);
  public static bool EventShowDetailViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public static bool EventShowViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public static UIViewController GetPrimaryViewControllerForCollapsingSplitViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController);
  public static UIViewController GetPrimaryViewControllerForExpandingSplitViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController);
  public static UIInterfaceOrientationMask GetSupportedInterfaceOrientations (IUISplitViewControllerDelegate This, UISplitViewController splitViewController);
  public static UISplitViewControllerDisplayMode GetTargetDisplayModeForAction (IUISplitViewControllerDelegate This, UISplitViewController svc);
  public static UIInterfaceOrientation PreferredInterfaceOrientationForPresentation (IUISplitViewControllerDelegate This, UISplitViewController splitViewController);
  public static UIViewController SeparateSecondaryViewController (IUISplitViewControllerDelegate This, UISplitViewController splitViewController, UIViewController primaryViewController);
  public static void WillChangeDisplayMode (IUISplitViewControllerDelegate This, UISplitViewController svc, UISplitViewControllerDisplayMode displayMode);

Type Changed: MonoTouch.UIKit.UIStepper

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UISwitch

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITabBar

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITabBarController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITabBarItem

Added interface:

  IUIAccessibilityIdentification

Type Changed: MonoTouch.UIKit.UITableView

Added interface:

  IUITraitEnvironment

Added property:

  public virtual UIVisualEffect SeparatorEffect { get; set; }

Type Changed: MonoTouch.UIKit.UITableViewCell

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITableViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITableViewHeaderFooterView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITextField

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITextView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIToolbar

Added interfaces:

  IUIBarPositioning
  IUITraitEnvironment

Added property:

  public virtual UIBarPosition BarPosition { get; }

Type Changed: MonoTouch.UIKit.UITouch

Added properties:

  public virtual float MajorRadius { get; }
  public virtual float MajorRadiusTolerance { get; }

Type Changed: MonoTouch.UIKit.UITransitionContext

Added properties:

  public static MonoTouch.Foundation.NSString FromViewKey { get; }
  public static MonoTouch.Foundation.NSString ToViewKey { get; }

Type Changed: MonoTouch.UIKit.UIUserInterfaceIdiom

Added value:

  Unspecified = -1,

Type Changed: MonoTouch.UIKit.UIVideoEditorController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIView

Added interface:

  IUITraitEnvironment

Added properties:

  public static MonoTouch.Foundation.NSString BoldTextStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
  public virtual UIView MaskView { get; set; }
  public static MonoTouch.Foundation.NSString NotificationSwitchControlIdentifier { get; }
  public static MonoTouch.Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
  public static MonoTouch.Foundation.NSString SwitchControlStatusDidChangeNotification { get; }
  public virtual UITraitCollection TraitCollection { get; }
  public static int UIAccessibilityPauseAssistiveTechnologyNotification { get; }
  public static int UIAccessibilityResumeAssistiveTechnologyNotification { get; }

Added methods:

  public virtual System.Drawing.SizeF SystemLayoutSizeFittingSize (System.Drawing.SizeF targetSize, float horizontalFittingPriority, float verticalFittingPriority);
  public virtual void TraitCollectionDidChange (UITraitCollection previousTraitCollection);

Type Changed: MonoTouch.UIKit.UIView.Notifications

Added methods:

  public static MonoTouch.Foundation.NSObject ObserveBoldTextStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveDarkerSystemColorsStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveGrayscaleStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveReduceMotionStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveReduceTransparencyStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
  public static MonoTouch.Foundation.NSObject ObserveSwitchControlStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);

Type Changed: MonoTouch.UIKit.UIViewController

Added interfaces:

  IUIContentContainer
  IUITraitEnvironment

Added properties:

  public virtual MonoTouch.Foundation.NSExtensionContext ExtensionContext { get; }
  public virtual UILayoutSupport LeftLayoutGuide { get; }
  public virtual UIPopoverPresentationController PopoverPresentationController { get; }
  public virtual UIPresentationController PresentationController { get; }
  public virtual UILayoutSupport RightLayoutGuide { get; }
  public static MonoTouch.Foundation.NSString ShowDetailTargetDidChangeNotification { get; }
  public virtual UITraitCollection TraitCollection { get; }

Added methods:

  public virtual UITraitCollection GetOverrideTraitCollectionForChildViewController (UIViewController childViewController);
  public virtual System.Drawing.SizeF GetSizeForChildContentContainer (IUIContentContainer contentContainer, System.Drawing.SizeF parentContainerSize);
  public virtual UIViewController GetTargetViewControllerForAction (MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSObject sender);
  public virtual void PreferredContentSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void SetOverrideTraitCollection (UITraitCollection collection, UIViewController childViewController);
  public virtual void ShowDetailViewController (UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public virtual void ShowViewController (UIViewController vc, MonoTouch.Foundation.NSObject sender);
  public virtual void SystemLayoutFittingSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void TraitCollectionDidChange (UITraitCollection previousTraitCollection);
  public virtual void ViewWillTransitionToSize (System.Drawing.SizeF toSize, IUIViewControllerTransitionCoordinator coordinator);
  public virtual void WillTransitionToTraitCollection (UITraitCollection traitCollection, IUIViewControllerTransitionCoordinator coordinator);

Type Changed: MonoTouch.UIKit.UIViewControllerContextTransitioning

Added method:

  public virtual UIView GetViewFor (MonoTouch.Foundation.NSString uiTransitionContextToOrFromKey);

Type Changed: MonoTouch.UIKit.UIViewControllerContextTransitioning_Extensions

Added method:

  public static UIView GetViewFor (IUIViewControllerContextTransitioning This, MonoTouch.Foundation.NSString uiTransitionContextToOrFromKey);

Type Changed: MonoTouch.UIKit.UIViewControllerTransitionCoordinatorContext_Extensions

Added method:

  public static MonoTouch.CoreGraphics.CGAffineTransform TargetTransform (IUIViewControllerTransitionCoordinatorContext This);

Type Changed: MonoTouch.UIKit.UIViewControllerTransitioningDelegate

Added method:

  public virtual UIPresentationController GetPresentationControllerForPresentedViewController (UIViewController presentedViewController, UIViewController presentingViewController, UIViewController sourceViewController);

Type Changed: MonoTouch.UIKit.UIViewControllerTransitioningDelegate_Extensions

Added method:

  public static UIPresentationController GetPresentationControllerForPresentedViewController (IUIViewControllerTransitioningDelegate This, UIViewController presentedViewController, UIViewController presentingViewController, UIViewController sourceViewController);

Type Changed: MonoTouch.UIKit.UIWebView

Added interface:

  IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIWindow

Added interface:

  IUITraitEnvironment

New Type MonoTouch.UIKit.IUIAdaptivePresentationControllerDelegate

public interface IUIAdaptivePresentationControllerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUIAppearanceContainer

public interface IUIAppearanceContainer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUIContentContainer

public interface IUIContentContainer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual System.Drawing.SizeF PreferredContentSize { get; }
  // methods
  public virtual System.Drawing.SizeF GetSizeForChildContentContainer (IUIContentContainer contentContainer, System.Drawing.SizeF parentContainerSize);
  public virtual void PreferredContentSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void SystemLayoutFittingSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void ViewWillTransitionToSize (System.Drawing.SizeF toSize, IUIViewControllerTransitionCoordinator coordinator);
  public virtual void WillTransitionToTraitCollection (UITraitCollection traitCollection, IUIViewControllerTransitionCoordinator coordinator);
}

New Type MonoTouch.UIKit.IUIDocumentMenuDelegate

public interface IUIDocumentMenuDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void DidPickDocumentPicker (UIDocumentMenuViewController documentMenu, UIDocumentPickerViewController documentPicker);
  public virtual void WasCancelled (UIDocumentMenuViewController documentMenu);
}

New Type MonoTouch.UIKit.IUIDocumentPickerDelegate

public interface IUIDocumentPickerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void DidPickDocument (UIDocumentPickerViewController controller, MonoTouch.Foundation.NSUrl url);
}

New Type MonoTouch.UIKit.IUIPopoverPresentationControllerDelegate

public interface IUIPopoverPresentationControllerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUIPrinterPickerControllerDelegate

public interface IUIPrinterPickerControllerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUISearchControllerDelegate

public interface IUISearchControllerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUISearchResultsUpdating

public interface IUISearchResultsUpdating : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.IUITextDocumentProxy

public interface IUITextDocumentProxy : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual string DocumentContextAfterInput { get; }
  public virtual string DocumentContextBeforeInput { get; }
}

New Type MonoTouch.UIKit.IUITraitEnvironment

public interface IUITraitEnvironment : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.UIKit.NSCoder_UIGeometryKeyedCoding

public static class NSCoder_UIGeometryKeyedCoding {
  // methods
  public static MonoTouch.CoreGraphics.CGAffineTransform DecodeCGAffineTransform (MonoTouch.Foundation.NSCoder This, string key);
  public static System.Drawing.PointF DecodeCGPoint (MonoTouch.Foundation.NSCoder This, string key);
  public static System.Drawing.RectangleF DecodeCGRect (MonoTouch.Foundation.NSCoder This, string key);
  public static System.Drawing.SizeF DecodeCGSize (MonoTouch.Foundation.NSCoder This, string key);
  public static MonoTouch.CoreGraphics.CGVector DecodeCGVector (MonoTouch.Foundation.NSCoder This, string key);
  public static UIEdgeInsets DecodeUIEdgeInsets (MonoTouch.Foundation.NSCoder This, string key);
  public static UIOffset DecodeUIOffsetForKey (MonoTouch.Foundation.NSCoder This, string key);
  public static void Encode (MonoTouch.Foundation.NSCoder This, UIEdgeInsets edgeInsets, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, MonoTouch.CoreGraphics.CGAffineTransform transform, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, System.Drawing.RectangleF rect, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, System.Drawing.SizeF size, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, MonoTouch.CoreGraphics.CGVector vector, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, System.Drawing.PointF point, string forKey);
  public static void Encode (MonoTouch.Foundation.NSCoder This, UIOffset uiOffset, string forKey);
}

New Type MonoTouch.UIKit.NSFileProviderExtension

public class NSFileProviderExtension : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NSFileProviderExtension ();
  public NSFileProviderExtension (MonoTouch.Foundation.NSCoder coder);
  public NSFileProviderExtension (MonoTouch.Foundation.NSObjectFlag t);
  public NSFileProviderExtension (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSUrl DocumentStorageUrl { get; }
  public virtual string ProviderIdentifier { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual string GetPersistentIdentifier (MonoTouch.Foundation.NSUrl itemUrl);
  public static MonoTouch.Foundation.NSUrl GetPlaceholderUrl (MonoTouch.Foundation.NSUrl url);
  public virtual MonoTouch.Foundation.NSUrl GetUrlForItem (string persistentIdentifier);
  public virtual void ItemChangedAtUrl (MonoTouch.Foundation.NSUrl url);
  public virtual void ProvidePlaceholderAtUrl (MonoTouch.Foundation.NSUrl url, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task ProvidePlaceholderAtUrlAsync (MonoTouch.Foundation.NSUrl url);
  public virtual void StartProvidingItemAtUrl (MonoTouch.Foundation.NSUrl url, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task StartProvidingItemAtUrlAsync (MonoTouch.Foundation.NSUrl url);
  public virtual void StopProvidingItemAtUrl (MonoTouch.Foundation.NSUrl url);
  public static bool WritePlaceholder (MonoTouch.Foundation.NSUrl placeholderUrl, MonoTouch.Foundation.NSDictionary metadata, ref MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.UIKit.NSIdentifier

public static class NSIdentifier {
  // methods
  public static string Identifier (NSLayoutConstraint This);
}

New Type MonoTouch.UIKit.UIAccessibilityCustomAction

public class UIAccessibilityCustomAction : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIAccessibilityCustomAction ();
  public UIAccessibilityCustomAction (MonoTouch.Foundation.NSCoder coder);
  public UIAccessibilityCustomAction (MonoTouch.Foundation.NSObjectFlag t);
  public UIAccessibilityCustomAction (System.IntPtr handle);
  public UIAccessibilityCustomAction (string name, MonoTouch.Foundation.NSObject target, MonoTouch.ObjCRuntime.Selector selector);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; set; }
  public virtual MonoTouch.ObjCRuntime.Selector Selector { get; set; }
  public virtual MonoTouch.Foundation.NSObject Target { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UIAccessibilityNavigationStyle

[Serializable]
public enum UIAccessibilityNavigationStyle {
  Automatic = 0,
  Combined = 2,
  Separate = 1,
}

New Type MonoTouch.UIKit.UIActivityViewControllerCompletion

public sealed delegate UIActivityViewControllerCompletion : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UIActivityViewControllerCompletion (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.Foundation.NSString activityType, bool completed, MonoTouch.Foundation.NSObject[] FIXME_FIND_THE_RIGHT_STRONG_TYPE, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.Foundation.NSString activityType, bool completed, MonoTouch.Foundation.NSObject[] FIXME_FIND_THE_RIGHT_STRONG_TYPE, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.UIKit.UIAdaptivePresentationControllerDelegate

public class UIAdaptivePresentationControllerDelegate : MonoTouch.Foundation.NSObject, IUIAdaptivePresentationControllerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIAdaptivePresentationControllerDelegate ();
  public UIAdaptivePresentationControllerDelegate (MonoTouch.Foundation.NSCoder coder);
  public UIAdaptivePresentationControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UIAdaptivePresentationControllerDelegate (System.IntPtr handle);
  // methods
  public virtual UIModalPresentationStyle GetAdaptivePresentationStyle (UIPresentationController forPresentationController);
  public virtual UIViewController GetViewControllerForAdaptivePresentation (UIPresentationController controller, UIModalPresentationStyle style);
}

New Type MonoTouch.UIKit.UIAdaptivePresentationControllerDelegate_Extensions

public static class UIAdaptivePresentationControllerDelegate_Extensions {
  // methods
  public static UIModalPresentationStyle GetAdaptivePresentationStyle (IUIAdaptivePresentationControllerDelegate This, UIPresentationController forPresentationController);
  public static UIViewController GetViewControllerForAdaptivePresentation (IUIAdaptivePresentationControllerDelegate This, UIPresentationController controller, UIModalPresentationStyle style);
}

New Type MonoTouch.UIKit.UIAlertAction

public class UIAlertAction : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIAlertAction ();
  public UIAlertAction (MonoTouch.Foundation.NSCoder coder);
  public UIAlertAction (MonoTouch.Foundation.NSObjectFlag t);
  public UIAlertAction (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Enabled { get; set; }
  public virtual UIAlertActionStyle Style { get; }
  public virtual string Title { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static UIAlertAction Create (string title, UIAlertActionStyle style, System.Action<UIAlertAction> handler);
  public static System.Threading.Tasks.Task<UIAlertAction> CreateAsync (string title, UIAlertActionStyle style);
  public static System.Threading.Tasks.Task<UIAlertAction> CreateAsync (string title, UIAlertActionStyle style, out UIAlertAction result);
}

New Type MonoTouch.UIKit.UIAlertActionStyle

[Serializable]
public enum UIAlertActionStyle {
  Cancel = 1,
  Default = 0,
  Destructive = 2,
}

New Type MonoTouch.UIKit.UIAlertController

public class UIAlertController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIAlertController ();
  public UIAlertController (MonoTouch.Foundation.NSCoder coder);
  public UIAlertController (MonoTouch.Foundation.NSObjectFlag t);
  public UIAlertController (System.IntPtr handle);
  // properties
  public virtual UIAlertAction[] Actions { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string Message { get; set; }
  public virtual UIAlertControllerStyle PreferredStyle { get; }
  public virtual UITextField[] TextFields { get; }
  public virtual string Title { get; set; }
  // methods
  public virtual void AddAction (UIAlertAction action);
  public virtual void AddTextField (System.Action<UITextField> configurationHandler);
  public static UIAlertController Create (string title, string message, UIAlertControllerStyle preferredStyle);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UIAlertControllerStyle

[Serializable]
public enum UIAlertControllerStyle {
  ActionSheet = 0,
  Alert = 1,
}

New Type MonoTouch.UIKit.UIAppearanceContainer

public class UIAppearanceContainer : MonoTouch.Foundation.NSObject, IUIAppearanceContainer, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIAppearanceContainer ();
  public UIAppearanceContainer (MonoTouch.Foundation.NSCoder coder);
  public UIAppearanceContainer (MonoTouch.Foundation.NSObjectFlag t);
  public UIAppearanceContainer (System.IntPtr handle);
}

New Type MonoTouch.UIKit.UIAppearanceContainer_Extensions

public static class UIAppearanceContainer_Extensions {
}

New Type MonoTouch.UIKit.UIApplicationRestorationHandler

public sealed delegate UIApplicationRestorationHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UIApplicationRestorationHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.Foundation.NSObject[] uidocumentOrResponderObjects, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.Foundation.NSObject[] uidocumentOrResponderObjects);
}

New Type MonoTouch.UIKit.UIBlurEffect

public class UIBlurEffect : MonoTouch.UIKit.UIVisualEffect, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIBlurEffect ();
  public UIBlurEffect (MonoTouch.Foundation.NSCoder coder);
  public UIBlurEffect (MonoTouch.Foundation.NSObjectFlag t);
  public UIBlurEffect (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static UIBlurEffect FromStyle (UIBlurEffectStyle style);
}

New Type MonoTouch.UIKit.UIBlurEffectStyle

[Serializable]
public enum UIBlurEffectStyle {
  Dark = 2,
  ExtraLight = 0,
  Light = 1,
}

New Type MonoTouch.UIKit.UIContentContainer

public abstract class UIContentContainer : MonoTouch.Foundation.NSObject, IUIContentContainer, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIContentContainer ();
  public UIContentContainer (MonoTouch.Foundation.NSCoder coder);
  public UIContentContainer (MonoTouch.Foundation.NSObjectFlag t);
  public UIContentContainer (System.IntPtr handle);
  // properties
  public virtual System.Drawing.SizeF PreferredContentSize { get; }
  // methods
  public virtual System.Drawing.SizeF GetSizeForChildContentContainer (IUIContentContainer contentContainer, System.Drawing.SizeF parentContainerSize);
  public virtual void PreferredContentSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void SystemLayoutFittingSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void ViewWillTransitionToSize (System.Drawing.SizeF toSize, IUIViewControllerTransitionCoordinator coordinator);
  public virtual void WillTransitionToTraitCollection (UITraitCollection traitCollection, IUIViewControllerTransitionCoordinator coordinator);
}

New Type MonoTouch.UIKit.UIContentContainer_Extensions

public static class UIContentContainer_Extensions {
}

New Type MonoTouch.UIKit.UIDocumentMenuDelegate

public abstract class UIDocumentMenuDelegate : MonoTouch.Foundation.NSObject, IUIDocumentMenuDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIDocumentMenuDelegate ();
  public UIDocumentMenuDelegate (MonoTouch.Foundation.NSCoder coder);
  public UIDocumentMenuDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UIDocumentMenuDelegate (System.IntPtr handle);
  // methods
  public virtual void DidPickDocumentPicker (UIDocumentMenuViewController documentMenu, UIDocumentPickerViewController documentPicker);
  public virtual void WasCancelled (UIDocumentMenuViewController documentMenu);
}

New Type MonoTouch.UIKit.UIDocumentMenuDelegate_Extensions

public static class UIDocumentMenuDelegate_Extensions {
}

New Type MonoTouch.UIKit.UIDocumentMenuDocumentPickedEventArgs

public class UIDocumentMenuDocumentPickedEventArgs : System.EventArgs {
  // constructors
  public UIDocumentMenuDocumentPickedEventArgs (UIDocumentPickerViewController documentPicker);
  // properties
  public UIDocumentPickerViewController DocumentPicker { get; set; }
}

New Type MonoTouch.UIKit.UIDocumentMenuOrder

[Serializable]
public enum UIDocumentMenuOrder {
  First = 0,
  Last = 1,
}

New Type MonoTouch.UIKit.UIDocumentMenuViewController

public class UIDocumentMenuViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIDocumentMenuViewController ();
  public UIDocumentMenuViewController (MonoTouch.Foundation.NSCoder coder);
  public UIDocumentMenuViewController (MonoTouch.Foundation.NSObjectFlag t);
  public UIDocumentMenuViewController (System.IntPtr handle);
  public UIDocumentMenuViewController (string[] allowedUTIs, UIDocumentPickerMode mode);
  public UIDocumentMenuViewController (MonoTouch.Foundation.NSUrl url, UIDocumentPickerMode mode);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public UIDocumentMenuDelegate Delegate { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler<UIDocumentMenuDocumentPickedEventArgs> DidPickDocumentPicker;
  public event System.EventHandler WasCancelled;
  // methods
  public virtual void AddOption (string title, UIImage image, UIDocumentMenuOrder order, System.Action completionHandler);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UIDocumentPickedEventArgs

public class UIDocumentPickedEventArgs : System.EventArgs {
  // constructors
  public UIDocumentPickedEventArgs (MonoTouch.Foundation.NSUrl url);
  // properties
  public MonoTouch.Foundation.NSUrl Url { get; set; }
}

New Type MonoTouch.UIKit.UIDocumentPickerDelegate

public abstract class UIDocumentPickerDelegate : MonoTouch.Foundation.NSObject, IUIDocumentPickerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIDocumentPickerDelegate ();
  public UIDocumentPickerDelegate (MonoTouch.Foundation.NSCoder coder);
  public UIDocumentPickerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UIDocumentPickerDelegate (System.IntPtr handle);
  // methods
  public virtual void DidPickDocument (UIDocumentPickerViewController controller, MonoTouch.Foundation.NSUrl url);
  public virtual void WasCancelled (UIDocumentPickerViewController controller);
}

New Type MonoTouch.UIKit.UIDocumentPickerDelegate_Extensions

public static class UIDocumentPickerDelegate_Extensions {
  // methods
  public static void WasCancelled (IUIDocumentPickerDelegate This, UIDocumentPickerViewController controller);
}

New Type MonoTouch.UIKit.UIDocumentPickerExtensionViewController

public class UIDocumentPickerExtensionViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIDocumentPickerExtensionViewController ();
  public UIDocumentPickerExtensionViewController (MonoTouch.Foundation.NSCoder coder);
  public UIDocumentPickerExtensionViewController (MonoTouch.Foundation.NSObjectFlag t);
  public UIDocumentPickerExtensionViewController (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual UIDocumentPickerMode DocumentPickerMode { get; }
  public virtual MonoTouch.Foundation.NSUrl DocumentStorageUrl { get; }
  public virtual MonoTouch.Foundation.NSUrl OriginalUrl { get; }
  public virtual string ProviderIdentifier { get; }
  public virtual string[] ValidTypes { get; }
  // methods
  public virtual void DismissGrantingAccess (MonoTouch.Foundation.NSUrl url);
  protected override void Dispose (bool disposing);
  public virtual void PrepareForPresentation (UIDocumentPickerMode mode);
}

New Type MonoTouch.UIKit.UIDocumentPickerMode

[Serializable]
public enum UIDocumentPickerMode {
  ExportToService = 2,
  Import = 0,
  MoveToService = 3,
  Open = 1,
}

New Type MonoTouch.UIKit.UIDocumentPickerViewController

public class UIDocumentPickerViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIDocumentPickerViewController ();
  public UIDocumentPickerViewController (MonoTouch.Foundation.NSCoder coder);
  public UIDocumentPickerViewController (MonoTouch.Foundation.NSObjectFlag t);
  public UIDocumentPickerViewController (System.IntPtr handle);
  public UIDocumentPickerViewController (string[] allowedUTIs, UIDocumentPickerMode mode);
  public UIDocumentPickerViewController (MonoTouch.Foundation.NSUrl url, UIDocumentPickerMode mode);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public UIDocumentPickerDelegate Delegate { get; set; }
  public virtual UIDocumentPickerMode DocumentPickerMode { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler<UIDocumentPickedEventArgs> DidPickDocument;
  public event System.EventHandler WasCancelled;
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UIImageAsset

public class UIImageAsset : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIImageAsset ();
  public UIImageAsset (MonoTouch.Foundation.NSCoder coder);
  public UIImageAsset (MonoTouch.Foundation.NSObjectFlag t);
  public UIImageAsset (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual UIImage FromTraitCollection (UITraitCollection traitCollection);
  public virtual void RegisterImage (UIImage image, UITraitCollection traitCollection);
  public virtual void UnregisterImageWithTraitCollection (UITraitCollection traitCollection);
}

New Type MonoTouch.UIKit.UIInputViewController

public class UIInputViewController : MonoTouch.UIKit.UIViewController, IUITextInputDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment {
  // constructors
  public UIInputViewController ();
  public UIInputViewController (MonoTouch.Foundation.NSCoder coder);
  public UIInputViewController (MonoTouch.Foundation.NSObjectFlag t);
  public UIInputViewController (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual UIInputView InputView { get; set; }
  public virtual IUITextDocumentProxy TextDocumentProxy { get; }
  // methods
  public virtual void AdvanceToNextInputMode ();
  public virtual void DismissKeyboard ();
  protected override void Dispose (bool disposing);
  public virtual void RequestSupplementaryLexicon (System.Action<UILexicon> completionHandler);
  public virtual System.Threading.Tasks.Task<UILexicon> RequestSupplementaryLexiconAsync ();
  public virtual void SelectionDidChange (MonoTouch.Foundation.NSObject uiTextInput);
  public virtual void SelectionWillChange (MonoTouch.Foundation.NSObject uiTextInput);
  public virtual void TextDidChange (MonoTouch.Foundation.NSObject textInput);
  public virtual void TextWillChange (MonoTouch.Foundation.NSObject textInput);
}

New Type MonoTouch.UIKit.UILexicon

public class UILexicon : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UILexicon ();
  public UILexicon (MonoTouch.Foundation.NSCoder coder);
  public UILexicon (MonoTouch.Foundation.NSObjectFlag t);
  public UILexicon (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual UILexiconEntry[] Entries { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UILexiconEntry

public class UILexiconEntry : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UILexiconEntry ();
  public UILexiconEntry (MonoTouch.Foundation.NSCoder coder);
  public UILexiconEntry (MonoTouch.Foundation.NSObjectFlag t);
  public UILexiconEntry (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string DocumentText { get; }
  public virtual string UserInput { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.UIKit.UIMutableUserNotificationAction

public class UIMutableUserNotificationAction : MonoTouch.UIKit.UIUserNotificationAction, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIMutableUserNotificationAction ();
  public UIMutableUserNotificationAction (MonoTouch.Foundation.NSCoder coder);
  public UIMutableUserNotificationAction (MonoTouch.Foundation.NSObjectFlag t);
  public UIMutableUserNotificationAction (System.IntPtr handle);
  // properties
  public virtual UIUserNotificationActivationMode ActivationMode { get; set; }
  public virtual bool AuthenticationRequired { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Destructive { get; set; }
  public virtual string Identifier { get; set; }
  public virtual string Title { get; set; }
}

New Type MonoTouch.UIKit.UIMutableUserNotificationCategory

public class UIMutableUserNotificationCategory : MonoTouch.UIKit.UIUserNotificationCategory, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIMutableUserNotificationCategory ();
  public UIMutableUserNotificationCategory (MonoTouch.Foundation.NSCoder coder);
  public UIMutableUserNotificationCategory (MonoTouch.Foundation.NSObjectFlag t);
  public UIMutableUserNotificationCategory (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Identifier { get; set; }
  // methods
  public virtual void SetActions (UIUserNotificationAction[] actions, UIUserNotificationActionContext context);
}

New Type MonoTouch.UIKit.UIPopoverPresentationController

public class UIPopoverPresentationController : MonoTouch.UIKit.UIPresentationController, IUIAppearanceContainer, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIPopoverPresentationController (MonoTouch.Foundation.NSCoder coder);
  public UIPopoverPresentationController (MonoTouch.Foundation.NSObjectFlag t);
  public UIPopoverPresentationController (System.IntPtr handle);
  // properties
  public virtual UIPopoverArrowDirection ArrowDirection { get; }
  public virtual UIColor BackgroundColor { get; set; }
  public virtual UIBarButtonItem BarButtonItem { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public UIPopoverPresentationControllerDelegate Delegat { get; set; }
  public virtual UIView[] PassthroughViews { get; set; }
  public virtual UIPopoverArrowDirection PermittedArrowDirections { get; set; }
  public virtual System.Drawing.SizeF PopoverContentSize { get; set; }
  public virtual UIEdgeInsets PopoverLayoutMargins { get; set; }
  public virtual System.Drawing.RectangleF SourceRect { get; set; }
  public virtual UIView SourceView { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UIPopoverPresentationControllerDelegate

public class UIPopoverPresentationControllerDelegate : MonoTouch.UIKit.UIAdaptivePresentationControllerDelegate, IUIPopoverPresentationControllerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IUIAdaptivePresentationControllerDelegate {
  // constructors
  public UIPopoverPresentationControllerDelegate ();
  public UIPopoverPresentationControllerDelegate (MonoTouch.Foundation.NSCoder coder);
  public UIPopoverPresentationControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UIPopoverPresentationControllerDelegate (System.IntPtr handle);
  // methods
  public virtual void DidDismissPopover (UIPopoverPresentationController popoverPresentationController);
  public override UIModalPresentationStyle GetAdaptivePresentationStyle (UIPresentationController forPresentationController);
  public override UIViewController GetViewControllerForAdaptivePresentation (UIPresentationController controller, UIModalPresentationStyle style);
  public virtual void PrepareForPopoverPresentation (UIPopoverPresentationController popoverPresentationController);
  public virtual bool ShouldDismissPopover (UIPopoverPresentationController popoverPresentationController);
  public virtual void WillRepositionPopover (UIPopoverPresentationController popoverPresentationController, System.Drawing.RectangleF targetRect, UIView inView);
}

New Type MonoTouch.UIKit.UIPopoverPresentationControllerDelegate_Extensions

public static class UIPopoverPresentationControllerDelegate_Extensions {
  // methods
  public static void DidDismissPopover (IUIPopoverPresentationControllerDelegate This, UIPopoverPresentationController popoverPresentationController);
  public static void PrepareForPopoverPresentation (IUIPopoverPresentationControllerDelegate This, UIPopoverPresentationController popoverPresentationController);
  public static bool ShouldDismissPopover (IUIPopoverPresentationControllerDelegate This, UIPopoverPresentationController popoverPresentationController);
  public static void WillRepositionPopover (IUIPopoverPresentationControllerDelegate This, UIPopoverPresentationController popoverPresentationController, System.Drawing.RectangleF targetRect, UIView inView);
}

New Type MonoTouch.UIKit.UIPresentationController

public class UIPresentationController : MonoTouch.Foundation.NSObject, IUIAppearanceContainer, IUIContentContainer, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIPresentationController ();
  public UIPresentationController (MonoTouch.Foundation.NSCoder coder);
  public UIPresentationController (MonoTouch.Foundation.NSObjectFlag t);
  public UIPresentationController (System.IntPtr handle);
  public UIPresentationController (UIViewController presentingViewController, UIViewController presentedViewController);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual UIView ContainerView { get; }
  public UIAdaptivePresentationControllerDelegate Delegate { get; set; }
  public virtual System.Drawing.RectangleF FrameOfPresentedViewInContainerView { get; }
  public virtual UITraitCollection OverrideTraitCollection { get; set; }
  public virtual System.Drawing.SizeF PreferredContentSize { get; }
  public virtual UIModalPresentationStyle PresentationStyle { get; }
  public virtual UIView PresentedView { get; }
  public virtual UIViewController PresentedViewController { get; }
  public virtual UIViewController PresentingViewController { get; }
  public virtual bool ShouldPresentInFullscreen { get; }
  public virtual bool ShouldRemovePresentersView { get; }
  public virtual UITraitCollection TraitCollection { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  public virtual UIModalPresentationStyle AdaptivePresentationStyle ();
  public virtual void ContainerViewDidLayoutSubviews ();
  public virtual void ContainerViewWillLayoutSubviews ();
  public virtual void DismissalTransitionDidEnd (bool completed);
  public virtual void DismissalTransitionWillBegin ();
  protected override void Dispose (bool disposing);
  public virtual System.Drawing.SizeF GetSizeForChildContentContainer (IUIContentContainer contentContainer, System.Drawing.SizeF parentContainerSize);
  public virtual void PreferredContentSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void PresentationTransitionDidEnd (bool completed);
  public virtual void PresentationTransitionWillBegin ();
  public virtual void SystemLayoutFittingSizeDidChangeForChildContentContainer (IUIContentContainer container);
  public virtual void TraitCollectionDidChange (UITraitCollection previousTraitCollection);
  public virtual void ViewWillTransitionToSize (System.Drawing.SizeF toSize, IUIViewControllerTransitionCoordinator coordinator);
  public virtual void WillTransitionToTraitCollection (UITraitCollection traitCollection, IUIViewControllerTransitionCoordinator coordinator);
}

New Type MonoTouch.UIKit.UIPrinter

public class UIPrinter : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIPrinter (MonoTouch.Foundation.NSCoder coder);
  public UIPrinter (MonoTouch.Foundation.NSObjectFlag t);
  public UIPrinter (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string DisplayLocation { get; }
  public virtual string DisplayName { get; }
  public virtual string MakeAndModel { get; }
  public virtual UIPrinterJobTypes SupportedJobTypes { get; }
  public virtual bool SupportsColor { get; }
  public virtual bool SupportsDuplex { get; }
  public virtual MonoTouch.Foundation.NSUrl Url { get; }
  // methods
  public virtual void ContactPrinter (UIPrinterContactPrinterHandler completionHandler);
  protected override void Dispose (bool disposing);
  public static UIPrinter FromUrl (MonoTouch.Foundation.NSUrl url);
}

New Type MonoTouch.UIKit.UIPrinterContactPrinterHandler

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

New Type MonoTouch.UIKit.UIPrinterJobTypes

[Serializable]
public enum UIPrinterJobTypes {
  Document = 1,
  Envelope = 2,
  Label = 4,
  LargeFormat = 64,
  Photo = 8,
  Postcard = 128,
  Receipt = 16,
  Roll = 32,
  Unknown = 0,
}

New Type MonoTouch.UIKit.UIPrinterPickerCompletionHandler

public sealed delegate UIPrinterPickerCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UIPrinterPickerCompletionHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UIPrinterPickerController printerPickerController, bool userDidSelect, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (UIPrinterPickerController printerPickerController, bool userDidSelect, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.UIKit.UIPrinterPickerController

public class UIPrinterPickerController : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIPrinterPickerController (MonoTouch.Foundation.NSCoder coder);
  public UIPrinterPickerController (MonoTouch.Foundation.NSObjectFlag t);
  public UIPrinterPickerController (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public UIPrinterPickerControllerDelegate Delegate { get; set; }
  public virtual UIPrinter SelectedPrinter { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  public virtual void Dismiss (bool animated);
  protected override void Dispose (bool disposing);
  public static UIPrinterPickerController FromPrinter (UIPrinter printer);
  public virtual bool Present (bool animated, UIPrinterPickerCompletionHandler completion);
  public virtual bool PresentFromBarButtonItem (UIBarButtonItem item, bool animated, UIPrinterPickerCompletionHandler completion);
  public virtual bool PresentFromRect (System.Drawing.RectangleF rect, UIView view, bool animated, UIPrinterPickerCompletionHandler completion);
}

New Type MonoTouch.UIKit.UIPrinterPickerControllerDelegate

public class UIPrinterPickerControllerDelegate : MonoTouch.Foundation.NSObject, IUIPrinterPickerControllerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIPrinterPickerControllerDelegate ();
  public UIPrinterPickerControllerDelegate (MonoTouch.Foundation.NSCoder coder);
  public UIPrinterPickerControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UIPrinterPickerControllerDelegate (System.IntPtr handle);
  // methods
  public virtual void DidDismiss (UIPrinterPickerController printerPickerController);
  public virtual void DidPresent (UIPrinterPickerController printerPickerController);
  public virtual void DidSelectPrinter (UIPrinterPickerController printerPickerController);
  public virtual UIViewController GetParentViewController (UIPrinterPickerController printerPickerController);
  public virtual bool ShouldShowPrinter (UIPrinterPickerController printerPickerController, UIPrinter printer);
  public virtual void WillDismiss (UIPrinterPickerController printerPickerController);
  public virtual void WillPresent (UIPrinterPickerController printerPickerController);
}

New Type MonoTouch.UIKit.UIPrinterPickerControllerDelegate_Extensions

public static class UIPrinterPickerControllerDelegate_Extensions {
  // methods
  public static void DidDismiss (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
  public static void DidPresent (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
  public static void DidSelectPrinter (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
  public static UIViewController GetParentViewController (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
  public static bool ShouldShowPrinter (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController, UIPrinter printer);
  public static void WillDismiss (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
  public static void WillPresent (IUIPrinterPickerControllerDelegate This, UIPrinterPickerController printerPickerController);
}

New Type MonoTouch.UIKit.UISearchController

public class UISearchController : MonoTouch.UIKit.UIViewController, IUIViewControllerAnimatedTransitioning, IUIViewControllerTransitioningDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, IUIContentContainer, IUITraitEnvironment {
  // constructors
  public UISearchController ();
  public UISearchController (MonoTouch.Foundation.NSCoder coder);
  public UISearchController (MonoTouch.Foundation.NSObjectFlag t);
  public UISearchController (System.IntPtr handle);
  public UISearchController (UIViewController searchResultsController);
  // properties
  public virtual bool Active { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public UISearchControllerDelegate Delegate { get; set; }
  public virtual bool DimsBackgroundDuringPresentation { get; set; }
  public virtual bool HidesNavigationBarDuringPresentation { get; set; }
  public virtual UISearchBar SearchBar { get; }
  public virtual UIViewController SearchResultsController { get; }
  public virtual UISearchResultsUpdating SearchResultsUpdater { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  public virtual void AnimateTransition (IUIViewControllerContextTransitioning transitionContext);
  public virtual void AnimationEnded (bool transitionCompleted);
  protected override void Dispose (bool disposing);
  public virtual IUIViewControllerAnimatedTransitioning GetAnimationControllerForDismissedController (UIViewController dismissed);
  public virtual IUIViewControllerInteractiveTransitioning GetInteractionControllerForDismissal (IUIViewControllerAnimatedTransitioning animator);
  public virtual IUIViewControllerInteractiveTransitioning GetInteractionControllerForPresentation (IUIViewControllerAnimatedTransitioning animator);
  public virtual UIPresentationController GetPresentationControllerForPresentedViewController (UIViewController presentedViewController, UIViewController presentingViewController, UIViewController sourceViewController);
  public virtual IUIViewControllerAnimatedTransitioning PresentingController (UIViewController presented, UIViewController presenting, UIViewController source);
  public virtual double TransitionDuration (IUIViewControllerContextTransitioning transitionContext);
}

New Type MonoTouch.UIKit.UISearchControllerDelegate

public class UISearchControllerDelegate : MonoTouch.Foundation.NSObject, IUISearchControllerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UISearchControllerDelegate ();
  public UISearchControllerDelegate (MonoTouch.Foundation.NSCoder coder);
  public UISearchControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public UISearchControllerDelegate (System.IntPtr handle);
  // methods
  public virtual void DidDismissSearchController (UISearchController searchController);
  public virtual void DidPresentSearchController (UISearchController searchController);
  public virtual void PresentSearchController (UISearchController searchController);
  public virtual void WillDismissSearchController (UISearchController searchController);
  public virtual void WillPresentSearchController (UISearchController searchController);
}

New Type MonoTouch.UIKit.UISearchControllerDelegate_Extensions

public static class UISearchControllerDelegate_Extensions {
  // methods
  public static void DidDismissSearchController (IUISearchControllerDelegate This, UISearchController searchController);
  public static void DidPresentSearchController (IUISearchControllerDelegate This, UISearchController searchController);
  public static void PresentSearchController (IUISearchControllerDelegate This, UISearchController searchController);
  public static void WillDismissSearchController (IUISearchControllerDelegate This, UISearchController searchController);
  public static void WillPresentSearchController (IUISearchControllerDelegate This, UISearchController searchController);
}

New Type MonoTouch.UIKit.UISearchResultsUpdating

public class UISearchResultsUpdating : MonoTouch.Foundation.NSObject, IUISearchResultsUpdating, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UISearchResultsUpdating ();
  public UISearchResultsUpdating (MonoTouch.Foundation.NSCoder coder);
  public UISearchResultsUpdating (MonoTouch.Foundation.NSObjectFlag t);
  public UISearchResultsUpdating (System.IntPtr handle);
  // methods
  public virtual void UpdateSearchResultsForSearchController (UISearchController searchController);
}

New Type MonoTouch.UIKit.UISearchResultsUpdating_Extensions

public static class UISearchResultsUpdating_Extensions {
  // methods
  public static void UpdateSearchResultsForSearchController (IUISearchResultsUpdating This, UISearchController searchController);
}

New Type MonoTouch.UIKit.UISplitViewController_UIViewController

public static class UISplitViewController_UIViewController {
  // methods
  public static void CollapseSecondaryViewController (UIViewController This, UIViewController secondaryViewController, UISplitViewController splitViewController);
  public static UISplitViewController GetSplitViewController (UIViewController This);
  public static UIViewController SeparateSecondaryViewControllerForSplitViewController (UIViewController This, UISplitViewController splitViewController);
}

New Type MonoTouch.UIKit.UISplitViewControllerCanCollapsePredicate

public sealed delegate UISplitViewControllerCanCollapsePredicate : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UISplitViewControllerCanCollapsePredicate (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UISplitViewController splitViewController, UIViewController secondaryViewController, UIViewController primaryViewController, System.AsyncCallback callback, object object);
  public virtual bool EndInvoke (System.IAsyncResult result);
  public virtual bool Invoke (UISplitViewController splitViewController, UIViewController secondaryViewController, UIViewController primaryViewController);
}

New Type MonoTouch.UIKit.UISplitViewControllerDisplayEvent

public sealed delegate UISplitViewControllerDisplayEvent : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UISplitViewControllerDisplayEvent (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender, System.AsyncCallback callback, object object);
  public virtual bool EndInvoke (System.IAsyncResult result);
  public virtual bool Invoke (UISplitViewController splitViewController, UIViewController vc, MonoTouch.Foundation.NSObject sender);
}

New Type MonoTouch.UIKit.UISplitViewControllerDisplayMode

[Serializable]
public enum UISplitViewControllerDisplayMode {
  AllVisible = 2,
  Automatic = 0,
  PrimaryHidden = 1,
  PrimaryOverlay = 3,
}

New Type MonoTouch.UIKit.UISplitViewControllerDisplayModeEventArgs

public class UISplitViewControllerDisplayModeEventArgs : System.EventArgs {
  // constructors
  public UISplitViewControllerDisplayModeEventArgs (UISplitViewControllerDisplayMode displayMode);
  // properties
  public UISplitViewControllerDisplayMode DisplayMode { get; set; }
}

New Type MonoTouch.UIKit.UISplitViewControllerFetchTargetForActionHandler

public sealed delegate UISplitViewControllerFetchTargetForActionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UISplitViewControllerFetchTargetForActionHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UISplitViewController svc, System.AsyncCallback callback, object object);
  public virtual UISplitViewControllerDisplayMode EndInvoke (System.IAsyncResult result);
  public virtual UISplitViewControllerDisplayMode Invoke (UISplitViewController svc);
}

New Type MonoTouch.UIKit.UISplitViewControllerGetSecondaryViewController

public sealed delegate UISplitViewControllerGetSecondaryViewController : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UISplitViewControllerGetSecondaryViewController (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UISplitViewController splitViewController, UIViewController primaryViewController, System.AsyncCallback callback, object object);
  public virtual UIViewController EndInvoke (System.IAsyncResult result);
  public virtual UIViewController Invoke (UISplitViewController splitViewController, UIViewController primaryViewController);
}

New Type MonoTouch.UIKit.UISplitViewControllerGetViewController

public sealed delegate UISplitViewControllerGetViewController : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public UISplitViewControllerGetViewController (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (UISplitViewController splitViewController, System.AsyncCallback callback, object object);
  public virtual UIViewController EndInvoke (System.IAsyncResult result);
  public virtual UIViewController Invoke (UISplitViewController splitViewController);
}

New Type MonoTouch.UIKit.UITextDocumentProxy

public abstract class UITextDocumentProxy : MonoTouch.Foundation.NSObject, IUITextDocumentProxy, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UITextDocumentProxy ();
  public UITextDocumentProxy (MonoTouch.Foundation.NSCoder coder);
  public UITextDocumentProxy (MonoTouch.Foundation.NSObjectFlag t);
  public UITextDocumentProxy (System.IntPtr handle);
  // properties
  public virtual UITextAutocapitalizationType AutocapitalizationType { get; set; }
  public virtual UITextAutocorrectionType AutocorrectionType { get; set; }
  public virtual string DocumentContextAfterInput { get; }
  public virtual string DocumentContextBeforeInput { get; }
  public virtual bool EnablesReturnKeyAutomatically { get; set; }
  public virtual bool HasText { get; }
  public virtual UIKeyboardAppearance KeyboardAppearance { get; set; }
  public virtual UIKeyboardType KeyboardType { get; set; }
  public virtual UIReturnKeyType ReturnKeyType { get; set; }
  public virtual bool SecureTextEntry { get; set; }
  public virtual UITextSpellCheckingType SpellCheckingType { get; set; }
  // methods
  public virtual void DeleteBackward ();
  public virtual void InsertText (string text);
}

New Type MonoTouch.UIKit.UITextDocumentProxy_Extensions

public static class UITextDocumentProxy_Extensions {
}

New Type MonoTouch.UIKit.UITraitCollection

public class UITraitCollection : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UITraitCollection ();
  public UITraitCollection (MonoTouch.Foundation.NSCoder coder);
  public UITraitCollection (MonoTouch.Foundation.NSObjectFlag t);
  public UITraitCollection (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float DisplayScale { get; }
  public virtual UIUserInterfaceSizeClass HorizontalSizeClass { get; }
  public virtual UIUserInterfaceIdiom UserInterfaceIdiom { get; }
  public virtual UIUserInterfaceSizeClass VerticalSizeClass { get; }
  // methods
  public virtual bool Contains (UITraitCollection trait);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static UITraitCollection FromDisplayScale (float scale);
  public static UITraitCollection FromHorizontalSizeClass (UIUserInterfaceSizeClass horizontalSizeClass);
  public static UITraitCollection FromTraitsFromCollections (MonoTouch.Foundation.NSObject[] traitCollections);
  public static UITraitCollection FromUserInterfaceIdiom (UIUserInterfaceIdiom idiom);
  public static UITraitCollection FromVerticalSizeClass (UIUserInterfaceSizeClass verticalSizeClass);
}

New Type MonoTouch.UIKit.UITraitEnvironment

public class UITraitEnvironment : MonoTouch.Foundation.NSObject, IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UITraitEnvironment ();
  public UITraitEnvironment (MonoTouch.Foundation.NSCoder coder);
  public UITraitEnvironment (MonoTouch.Foundation.NSObjectFlag t);
  public UITraitEnvironment (System.IntPtr handle);
  // properties
  public virtual UITraitCollection TraitCollection { get; }
  // methods
  public virtual void TraitCollectionDidChange (UITraitCollection previousTraitCollection);
}

New Type MonoTouch.UIKit.UITraitEnvironment_Extensions

public static class UITraitEnvironment_Extensions {
  // methods
  public static void TraitCollectionDidChange (IUITraitEnvironment This, UITraitCollection previousTraitCollection);
}

New Type MonoTouch.UIKit.UIUserInterfaceSizeClass

[Serializable]
public enum UIUserInterfaceSizeClass {
  Compact = 1,
  Regular = 2,
  Unspecified = 0,
}

New Type MonoTouch.UIKit.UIUserNotificationAction

public class UIUserNotificationAction : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIUserNotificationAction ();
  public UIUserNotificationAction (MonoTouch.Foundation.NSCoder coder);
  public UIUserNotificationAction (MonoTouch.Foundation.NSObjectFlag t);
  public UIUserNotificationAction (System.IntPtr handle);
  // properties
  public virtual UIUserNotificationActivationMode ActivationMode { get; }
  public virtual bool AuthenticationRequired { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Destructive { get; }
  public virtual string Identifier { get; }
  public virtual string Title { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual MonoTouch.Foundation.NSObject MutableCopy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.UIKit.UIUserNotificationActionContext

[Serializable]
public enum UIUserNotificationActionContext {
  Default = 0,
  Minimal = 1,
}

New Type MonoTouch.UIKit.UIUserNotificationActivationMode

[Serializable]
public enum UIUserNotificationActivationMode {
  Background = 1,
  Foreground = 0,
}

New Type MonoTouch.UIKit.UIUserNotificationCategory

public class UIUserNotificationCategory : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIUserNotificationCategory ();
  public UIUserNotificationCategory (MonoTouch.Foundation.NSCoder coder);
  public UIUserNotificationCategory (MonoTouch.Foundation.NSObjectFlag t);
  public UIUserNotificationCategory (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Identifier { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual UIUserNotificationAction[] GetActionsForContext (UIUserNotificationActionContext context);
  public virtual MonoTouch.Foundation.NSObject MutableCopy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.UIKit.UIUserNotificationSettings

public class UIUserNotificationSettings : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIUserNotificationSettings ();
  public UIUserNotificationSettings (MonoTouch.Foundation.NSCoder coder);
  public UIUserNotificationSettings (MonoTouch.Foundation.NSObjectFlag t);
  public UIUserNotificationSettings (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSSet Categories { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual UIUserNotificationType Types { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public static UIUserNotificationSettings GetSettingsForTypes (UIUserNotificationType types, MonoTouch.Foundation.NSSet categories);
}

New Type MonoTouch.UIKit.UIUserNotificationType

[Serializable]
[Flags]
public enum UIUserNotificationType {
  Alert = 4,
  Badge = 1,
  None = 0,
  Sound = 2,
}

New Type MonoTouch.UIKit.UIVibrancyEffect

public class UIVibrancyEffect : MonoTouch.UIKit.UIVisualEffect, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIVibrancyEffect ();
  public UIVibrancyEffect (MonoTouch.Foundation.NSCoder coder);
  public UIVibrancyEffect (MonoTouch.Foundation.NSObjectFlag t);
  public UIVibrancyEffect (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static UIVibrancyEffect FromBlurEffect (UIBlurEffect blurEffect);
}

New Type MonoTouch.UIKit.UIVisualEffect

public class UIVisualEffect : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public UIVisualEffect ();
  public UIVisualEffect (MonoTouch.Foundation.NSCoder coder);
  public UIVisualEffect (MonoTouch.Foundation.NSObjectFlag t);
  public UIVisualEffect (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.UIKit.UIVisualEffectView

public class UIVisualEffectView : MonoTouch.UIKit.UIView, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, System.Collections.IEnumerable, IUIAccessibilityIdentification, IUIDynamicItem, IUITraitEnvironment {
  // constructors
  public UIVisualEffectView ();
  public UIVisualEffectView (MonoTouch.Foundation.NSCoder coder);
  public UIVisualEffectView (MonoTouch.Foundation.NSObjectFlag t);
  public UIVisualEffectView (System.IntPtr handle);
  public UIVisualEffectView (UIVisualEffect effect);
  // properties
  public static UIVisualEffectView.UIVisualEffectViewAppearance Appearance { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual UIView ContentView { get; }
  public virtual UIVisualEffect Effect { get; }
  // methods
  public static UIVisualEffectView.UIVisualEffectViewAppearance AppearanceWhenContainedIn (System.Type[] containers);
  protected override void Dispose (bool disposing);
  public static UIVisualEffectView.UIVisualEffectViewAppearance GetAppearance<T> ();

  // inner types
  public class UIVisualEffectViewAppearance : MonoTouch.UIKit.UIView+UIViewAppearance, IUIAppearance, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  }
}

Namespace OpenTK

New Type OpenTK.Matrix2

[Serializable]
public struct Matrix2, System.IEquatable<Matrix2> {
  // constructors
  public Matrix2 (ref Matrix2 matrix);
  public Matrix2 (float r0c0, float r0c1, float r1c0, float r1c1);
  public Matrix2 (float[] floatArray);
  // fields
  public static Matrix2 Identity;
  public float R0C0;
  public float R0C1;
  public float R1C0;
  public float R1C1;
  public static Matrix2 Zero;
  // properties
  public float Determinant { get; }
  public float Item { get; set; }
  public float Item { get; set; }
  // methods
  public static void Add (ref Matrix2 left, ref Matrix2 right, out Matrix2 result);
  public void Add (ref Matrix2 matrix, out Matrix2 result);
  public void Add (ref Matrix2 matrix);
  public static bool Equals (ref Matrix2 left, ref Matrix2 right);
  public virtual bool Equals (Matrix2 matrix);
  public bool Equals (ref Matrix2 matrix);
  public bool EqualsApprox (ref Matrix2 matrix, float tolerance);
  public static bool EqualsApprox (ref Matrix2 left, ref Matrix2 right, float tolerance);
  public override int GetHashCode ();
  public void Multiply (float scalar);
  public void Multiply (ref Matrix2 matrix);
  public void Multiply (float scalar, out Matrix2 result);
  public static void Multiply (ref Matrix2 left, ref Matrix2 right, out Matrix2 result);
  public static void Multiply (ref Matrix2 matrix, float scalar, out Matrix2 result);
  public void Multiply (ref Matrix2 matrix, out Matrix2 result);
  public static System.IntPtr op_Explicit (Matrix2 matrix);
  public static float* op_Explicit (Matrix2 matrix);
  public static float[] op_Explicit (Matrix2 matrix);
  public void Rotate (float angle);
  public void Rotate (float angle, out Matrix2 result);
  public static void Rotate (ref Matrix2 matrix, float angle, out Matrix2 result);
  public static void RotateMatrix (float angle, out Matrix2 result);
  public void Subtract (ref Matrix2 matrix);
  public static void Subtract (ref Matrix2 left, ref Matrix2 right, out Matrix2 result);
  public void Subtract (ref Matrix2 matrix, out Matrix2 result);
  public override string ToString ();
  public void Transform (ref Vector2 vector, out Vector2 result);
  public static void Transform (ref Matrix2 matrix, ref Vector2 vector);
  public static void Transform (ref Matrix2 matrix, ref Vector2 vector, out Vector2 result);
  public void Transform (ref Vector2 vector);
  public static void Transpose (ref Matrix2 matrix, out Matrix2 result);
  public void Transpose (out Matrix2 result);
  public void Transpose ();
}

New Namespace monotouch

New Type monotouch.HKUnit

public class HKUnit {
  // constructors
  public HKUnit ();
  // fields
  public static const double MolarMassBloodGlucose;
}

New Namespace MonoTouch.CloudKit

New Type MonoTouch.CloudKit.CKAccountStatus

[Serializable]
public enum CKAccountStatus {
  Available = 1,
  CouldNotDetermine = 0,
  NoAccount = 3,
  Restricted = 2,
}

New Type MonoTouch.CloudKit.CKApplicationPermissions

[Serializable]
public enum CKApplicationPermissions {
  UserDiscoverability = 1,
}

New Type MonoTouch.CloudKit.CKApplicationPermissionStatus

[Serializable]
public enum CKApplicationPermissionStatus {
  CouldNotComplete = 1,
  Denied = 2,
  Granted = 3,
  InitialState = 0,
}

New Type MonoTouch.CloudKit.CKAsset

public class CKAsset : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKAsset (MonoTouch.Foundation.NSCoder coder);
  public CKAsset (MonoTouch.Foundation.NSObjectFlag t);
  public CKAsset (System.IntPtr handle);
  public CKAsset (MonoTouch.Foundation.NSUrl fileURL);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSUrl FileUrl { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKContainer

public class CKContainer : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKContainer (MonoTouch.Foundation.NSCoder coder);
  public CKContainer (MonoTouch.Foundation.NSObjectFlag t);
  public CKContainer (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string ContainerIdentifier { get; }
  public static CKContainer DefaultContainer { get; }
  public static MonoTouch.Foundation.NSString OwnerDefaultName { get; }
  public virtual CKDatabase PrivateCloudDatabase { get; }
  public virtual CKDatabase PublicCloudDatabase { get; }
  // methods
  public virtual void AddOperation (CKOperation operation);
  public virtual void DiscoverAllContactUserInfos (System.Action<CKDiscoveredUserInfo[],MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKDiscoveredUserInfo[]> DiscoverAllContactUserInfosAsync ();
  public virtual void DiscoverUserInfo (CKRecordID userRecordId, System.Action<CKDiscoveredUserInfo,MonoTouch.Foundation.NSError> completionHandler);
  public virtual void DiscoverUserInfo (string email, System.Action<CKDiscoveredUserInfo,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKDiscoveredUserInfo> DiscoverUserInfoAsync (string email);
  public virtual System.Threading.Tasks.Task<CKDiscoveredUserInfo> DiscoverUserInfoAsync (CKRecordID userRecordId);
  protected override void Dispose (bool disposing);
  public virtual void FetchUserRecordId (System.Action<CKRecordID,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordID> FetchUserRecordIdAsync ();
  public static CKContainer FromIdentifier (string containerIdentifier);
  public virtual void GetAccountStatus (System.Action<CKAccountStatus,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKAccountStatus> GetAccountStatusAsync ();
  public virtual void RequestApplicationPermission (CKApplicationPermissions applicationPermission, System.Action<CKApplicationPermissionStatus,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKApplicationPermissionStatus> RequestApplicationPermissionAsync (CKApplicationPermissions applicationPermission);
  public virtual void StatusForApplicationPermission (CKApplicationPermissions applicationPermission, System.Action<CKApplicationPermissionStatus,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKApplicationPermissionStatus> StatusForApplicationPermissionAsync (CKApplicationPermissions applicationPermission);
}

New Type MonoTouch.CloudKit.CKDatabase

public class CKDatabase : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKDatabase (MonoTouch.Foundation.NSCoder coder);
  public CKDatabase (MonoTouch.Foundation.NSObjectFlag t);
  public CKDatabase (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual void AddOperation (CKDatabaseOperation operation);
  public virtual void DeleteRecord (CKRecordID recordId, System.Action<CKRecordID,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordID> DeleteRecordAsync (CKRecordID recordId);
  public virtual void DeleteRecordZone (CKRecordZoneID zoneId, System.Action<CKRecordZoneID,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordZoneID> DeleteRecordZoneAsync (CKRecordZoneID zoneId);
  public virtual void DeleteSubscription (string subscriptionID, CKDatabaseDeleteSubscriptionHandler completionHandler);
  public virtual System.Threading.Tasks.Task<string> DeleteSubscriptionAsync (string subscriptionID);
  public virtual void FetchAllRecordZones (System.Action<CKRecordZone[],MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordZone[]> FetchAllRecordZonesAsync ();
  public virtual void FetchAllSubscriptions (System.Action<MonoTouch.Foundation.NSArray,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<MonoTouch.Foundation.NSArray> FetchAllSubscriptionsAsync ();
  public virtual void FetchRecord (CKRecordID recordId, System.Action<CKRecord,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecord> FetchRecordAsync (CKRecordID recordId);
  public virtual void FetchRecordZone (CKRecordZoneID zoneId, System.Action<CKRecordZone,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordZone> FetchRecordZoneAsync (CKRecordZoneID zoneId);
  public virtual void FetchSubscription (string subscriptionId, System.Action<CKSubscription,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKSubscription> FetchSubscriptionAsync (string subscriptionId);
  public virtual void PerformQuery (CKQuery query, CKRecordZoneID zoneId, System.Action<CKRecordZone,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordZone> PerformQueryAsync (CKQuery query, CKRecordZoneID zoneId);
  public virtual void SaveRecord (CKRecord record, System.Action<CKRecord,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecord> SaveRecordAsync (CKRecord record);
  public virtual void SaveRecordZone (CKRecordZone zone, System.Action<CKRecordZone,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKRecordZone> SaveRecordZoneAsync (CKRecordZone zone);
  public virtual void SaveSubscription (CKSubscription subscription, System.Action<CKSubscription,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<CKSubscription> SaveSubscriptionAsync (CKSubscription subscription);
}

New Type MonoTouch.CloudKit.CKDatabaseDeleteSubscriptionHandler

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

New Type MonoTouch.CloudKit.CKDatabaseOperation

public class CKDatabaseOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKDatabaseOperation ();
  public CKDatabaseOperation (MonoTouch.Foundation.NSCoder coder);
  public CKDatabaseOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKDatabaseOperation (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKDatabase Database { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKDiscoverAllContactsOperation

public class CKDiscoverAllContactsOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKDiscoverAllContactsOperation ();
  public CKDiscoverAllContactsOperation (MonoTouch.Foundation.NSCoder coder);
  public CKDiscoverAllContactsOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKDiscoverAllContactsOperation (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual System.Action<CKDiscoveredUserInfo[],MonoTouch.Foundation.NSError> DiscoverAllContactsHandler { get; }
}

New Type MonoTouch.CloudKit.CKDiscoveredUserInfo

public class CKDiscoveredUserInfo : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKDiscoveredUserInfo ();
  public CKDiscoveredUserInfo (MonoTouch.Foundation.NSCoder coder);
  public CKDiscoveredUserInfo (MonoTouch.Foundation.NSObjectFlag t);
  public CKDiscoveredUserInfo (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string FirstName { get; }
  public virtual string LastName { get; }
  public virtual CKRecordID UserRecordId { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKDiscoverUserInfosCompletionHandler

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

New Type MonoTouch.CloudKit.CKDiscoverUserInfosOperation

public class CKDiscoverUserInfosOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKDiscoverUserInfosOperation ();
  public CKDiscoverUserInfosOperation (MonoTouch.Foundation.NSCoder coder);
  public CKDiscoverUserInfosOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKDiscoverUserInfosOperation (System.IntPtr handle);
  public CKDiscoverUserInfosOperation (string[] emailAddresses, CKRecordID[] userRecordIDs);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKDiscoverUserInfosCompletionHandler Completed { set; }
  public virtual string[] EmailAddresses { get; set; }
  public virtual CKRecordID[] UserRecordIds { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKErrorCode

[Serializable]
public enum CKErrorCode {
  AssetFileModified = 17,
  AssetFileNotFound = 16,
  BadContainer = 5,
  BadDatabase = 24,
  BatchRequestFailed = 22,
  ChangeTokenExpired = 21,
  ConstraintViolation = 19,
  IncompatibleVersion = 18,
  InternalError = 1,
  InvalidArguments = 12,
  MissingEntitlement = 8,
  NetworkFailure = 4,
  NetworkUnavailable = 3,
  NotAuthenticated = 9,
  OperationCancelled = 20,
  PartialFailure = 2,
  PermissionFailure = 10,
  QuotaExceeded = 25,
  RequestRateLimited = 7,
  ResultsTruncated = 13,
  ServerRecordChanged = 14,
  ServerRejectedRequest = 15,
  ServiceUnavailable = 6,
  UnknownItem = 11,
  ZoneBusy = 23,
  ZoneNotFound = 26,
}

New Type MonoTouch.CloudKit.CKErrorFields

public static class CKErrorFields {
  // properties
  public static MonoTouch.Foundation.NSString ErrorDomain { get; }
  public static MonoTouch.Foundation.NSString ErrorRetryAfterKey { get; }
  public static MonoTouch.Foundation.NSString PartialErrorsByItemIdKey { get; }
  public static MonoTouch.Foundation.NSString RecordChangedErrorAncestorRecordKey { get; }
  public static MonoTouch.Foundation.NSString RecordChangedErrorClientRecordKey { get; }
  public static MonoTouch.Foundation.NSString RecordChangedErrorServerRecordKey { get; }
}

New Type MonoTouch.CloudKit.CKFetchNotificationChangesOperation

public class CKFetchNotificationChangesOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKFetchNotificationChangesOperation ();
  public CKFetchNotificationChangesOperation (MonoTouch.Foundation.NSCoder coder);
  public CKFetchNotificationChangesOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKFetchNotificationChangesOperation (System.IntPtr handle);
  public CKFetchNotificationChangesOperation (CKServerChangeToken previousServerChangeToken);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual System.Action<CKServerChangeToken,MonoTouch.Foundation.NSError> Completed { set; }
  public virtual System.Action<CKNotification> NotificationChanged { set; }
  public virtual CKServerChangeToken PreviousServerChangeToken { get; set; }
  public virtual uint ResultsLimit { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKFetchRecordChangesHandler

public sealed delegate CKFetchRecordChangesHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public CKFetchRecordChangesHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (CKServerChangeToken serverChangeToken, MonoTouch.Foundation.NSData clientChangeTokenData, MonoTouch.Foundation.NSError operationError, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (CKServerChangeToken serverChangeToken, MonoTouch.Foundation.NSData clientChangeTokenData, MonoTouch.Foundation.NSError operationError);
}

New Type MonoTouch.CloudKit.CKFetchRecordChangesOperation

public class CKFetchRecordChangesOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKFetchRecordChangesOperation ();
  public CKFetchRecordChangesOperation (MonoTouch.Foundation.NSCoder coder);
  public CKFetchRecordChangesOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKFetchRecordChangesOperation (System.IntPtr handle);
  public CKFetchRecordChangesOperation (CKRecordZoneID recordZoneID, CKServerChangeToken previousServerChangeToken);
  // properties
  public virtual CKFetchRecordChangesHandler AllChangesReported { set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string[] DesiredKeys { get; set; }
  public virtual bool MoreComing { get; }
  public virtual CKServerChangeToken PreviousServerChangeToken { get; set; }
  public virtual System.Action<CKRecord> RecordChanged { set; }
  public virtual System.Action<CKRecordID> RecordDeleted { set; }
  public virtual CKRecordZoneID RecordZoneId { get; set; }
  public virtual uint ResultsLimit { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKFetchRecordsCompletedHandler

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

New Type MonoTouch.CloudKit.CKFetchRecordsOperation

public class CKFetchRecordsOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKFetchRecordsOperation ();
  public CKFetchRecordsOperation (MonoTouch.Foundation.NSCoder coder);
  public CKFetchRecordsOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKFetchRecordsOperation (System.IntPtr handle);
  public CKFetchRecordsOperation (CKRecordID[] recordIds);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKFetchRecordsCompletedHandler Completed { set; }
  public virtual string[] DesiredKeys { get; set; }
  public virtual System.Action<CKRecord,MonoTouch.CloudKit.CKRecordID,MonoTouch.Foundation.NSError> PerRecordCompletion { set; }
  public virtual System.Action<CKRecordID,System.Double> PerRecordProgress { set; }
  public virtual CKRecordID[] RecordIds { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public static CKFetchRecordsOperation FetchCurrentUserRecordOperation ();
}

New Type MonoTouch.CloudKit.CKFetchRecordZonesOperation

public class CKFetchRecordZonesOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKFetchRecordZonesOperation ();
  public CKFetchRecordZonesOperation (MonoTouch.Foundation.NSCoder coder);
  public CKFetchRecordZonesOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKFetchRecordZonesOperation (System.IntPtr handle);
  public CKFetchRecordZonesOperation (CKRecordZoneID[] zoneIds);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKRecordZoneCompleteHandler Completed { set; }
  public virtual CKRecordZoneID[] RecordZoneIds { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public static CKFetchRecordZonesOperation FetchAllRecordZonesOperation ();
}

New Type MonoTouch.CloudKit.CKFetchSubscriptionsCompleteHandler

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

New Type MonoTouch.CloudKit.CKFetchSubscriptionsOperation

public class CKFetchSubscriptionsOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKFetchSubscriptionsOperation ();
  public CKFetchSubscriptionsOperation (MonoTouch.Foundation.NSCoder coder);
  public CKFetchSubscriptionsOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKFetchSubscriptionsOperation (System.IntPtr handle);
  public CKFetchSubscriptionsOperation (string[] subscriptionIds);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKFetchSubscriptionsCompleteHandler Completed { set; }
  public virtual string[] SubscriptionIds { get; set; }
  // methods
  public static CKFetchSubscriptionsOperation FetchAllSubscriptionsOperation ();
}

New Type MonoTouch.CloudKit.CKLocationSortDescriptor

public class CKLocationSortDescriptor : MonoTouch.Foundation.NSSortDescriptor, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, MonoTouch.Foundation.INSCopying {
  // constructors
  public CKLocationSortDescriptor ();
  public CKLocationSortDescriptor (MonoTouch.Foundation.NSCoder coder);
  public CKLocationSortDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public CKLocationSortDescriptor (System.IntPtr handle);
  public CKLocationSortDescriptor (string key, MonoTouch.CoreLocation.CLLocation relativeLocation);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.CoreLocation.CLLocation RelativeLocation { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKMarkNotificationsReadHandler

public sealed delegate CKMarkNotificationsReadHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public CKMarkNotificationsReadHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (CKNotificationID[] notificationIDsMarkedRead, MonoTouch.Foundation.NSError operationError, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (CKNotificationID[] notificationIDsMarkedRead, MonoTouch.Foundation.NSError operationError);
}

New Type MonoTouch.CloudKit.CKMarkNotificationsReadOperation

public class CKMarkNotificationsReadOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKMarkNotificationsReadOperation (MonoTouch.Foundation.NSCoder coder);
  public CKMarkNotificationsReadOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKMarkNotificationsReadOperation (System.IntPtr handle);
  public CKMarkNotificationsReadOperation (CKNotificationID[] notificationIds);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKMarkNotificationsReadHandler Completed { set; }
  public virtual CKNotificationID[] NotificationIds { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKModifyBadgeOperation

public class CKModifyBadgeOperation : MonoTouch.CloudKit.CKOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKModifyBadgeOperation ();
  public CKModifyBadgeOperation (MonoTouch.Foundation.NSCoder coder);
  public CKModifyBadgeOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKModifyBadgeOperation (System.IntPtr handle);
  public CKModifyBadgeOperation (uint badgeValue);
  // properties
  public virtual uint BadgeValue { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual System.Action<MonoTouch.Foundation.NSError> Completed { set; }
  public virtual bool ThisDeviceOnly { get; set; }
}

New Type MonoTouch.CloudKit.CKModifyRecordsOperation

public class CKModifyRecordsOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKModifyRecordsOperation ();
  public CKModifyRecordsOperation (MonoTouch.Foundation.NSCoder coder);
  public CKModifyRecordsOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKModifyRecordsOperation (System.IntPtr handle);
  public CKModifyRecordsOperation (CKRecord[] records, CKRecordID[] recordIds);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData ClientChangeTokenData { get; set; }
  public virtual CKModifyRecordsOperationHandler Completed { set; }
  public virtual System.Action<CKRecord,MonoTouch.Foundation.NSError> PerRecordCompletion { set; }
  public virtual System.Action<CKRecord,System.Double> PerRecordProgress { set; }
  public virtual CKRecordID[] RecordIdsToDelete { get; set; }
  public virtual CKRecord[] RecordsToSave { get; set; }
  public virtual CKRecordSavePolicy SavePolicy { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKModifyRecordsOperationHandler

public sealed delegate CKModifyRecordsOperationHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public CKModifyRecordsOperationHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (CKRecord[] savedRecords, CKRecordID[] deletedRecordIds, MonoTouch.Foundation.NSError operationError, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (CKRecord[] savedRecords, CKRecordID[] deletedRecordIds, MonoTouch.Foundation.NSError operationError);
}

New Type MonoTouch.CloudKit.CKModifyRecordZonesHandler

public sealed delegate CKModifyRecordZonesHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public CKModifyRecordZonesHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (CKRecordZone[] savedRecordZones, CKRecordZoneID[] deletedRecordZoneIds, MonoTouch.Foundation.NSError operationError, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (CKRecordZone[] savedRecordZones, CKRecordZoneID[] deletedRecordZoneIds, MonoTouch.Foundation.NSError operationError);
}

New Type MonoTouch.CloudKit.CKModifyRecordZonesOperation

public class CKModifyRecordZonesOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKModifyRecordZonesOperation ();
  public CKModifyRecordZonesOperation (MonoTouch.Foundation.NSCoder coder);
  public CKModifyRecordZonesOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKModifyRecordZonesOperation (System.IntPtr handle);
  public CKModifyRecordZonesOperation (CKRecordZone[] recordZonesToSave, CKRecordZoneID[] recordZoneIdsToDelete);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKModifyRecordZonesHandler Completed { set; }
  public virtual CKRecordZoneID[] RecordZoneIdsToDelete { get; set; }
  public virtual CKRecordZone[] RecordZonesToSave { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKModifySubscriptionsHandler

public sealed delegate CKModifySubscriptionsHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public CKModifySubscriptionsHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (CKSubscription[] savedSubscriptions, string[] deletedSubscriptionIds, MonoTouch.Foundation.NSError operationError, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (CKSubscription[] savedSubscriptions, string[] deletedSubscriptionIds, MonoTouch.Foundation.NSError operationError);
}

New Type MonoTouch.CloudKit.CKModifySubscriptionsOperation

public class CKModifySubscriptionsOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKModifySubscriptionsOperation ();
  public CKModifySubscriptionsOperation (MonoTouch.Foundation.NSCoder coder);
  public CKModifySubscriptionsOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKModifySubscriptionsOperation (System.IntPtr handle);
  public CKModifySubscriptionsOperation (CKSubscription[] subscriptionsToSave, string[] subscriptionIdsToDelete);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKModifySubscriptionsHandler Completed { set; }
  public virtual string[] SubscriptionIdsToDelete { get; set; }
  public virtual CKSubscription[] SubscriptionsToSave { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKNotification

public class CKNotification : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKNotification (MonoTouch.Foundation.NSCoder coder);
  public CKNotification (MonoTouch.Foundation.NSObjectFlag t);
  public CKNotification (System.IntPtr handle);
  // properties
  public virtual string AlertActionLocalizationKey { get; }
  public virtual string AlertBody { get; }
  public virtual string AlertLaunchImage { get; }
  public virtual string[] AlertLocalizationArgs { get; }
  public virtual string AlertLocalizationKey { get; }
  public virtual MonoTouch.Foundation.NSNumber Badge { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string ContainerIdentifier { get; }
  public virtual bool IsPruned { get; }
  public virtual CKNotificationID NotificationId { get; }
  public virtual CKNotificationType NotificationType { get; }
  public virtual string SoundName { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static CKNotification FromRemoteNotificationDictionary (MonoTouch.Foundation.NSDictionary notificationDictionary);
}

New Type MonoTouch.CloudKit.CKNotificationID

public class CKNotificationID : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKNotificationID ();
  public CKNotificationID (MonoTouch.Foundation.NSCoder coder);
  public CKNotificationID (MonoTouch.Foundation.NSObjectFlag t);
  public CKNotificationID (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CloudKit.CKNotificationInfo

public class CKNotificationInfo : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKNotificationInfo ();
  public CKNotificationInfo (MonoTouch.Foundation.NSCoder coder);
  public CKNotificationInfo (MonoTouch.Foundation.NSObjectFlag t);
  public CKNotificationInfo (System.IntPtr handle);
  // properties
  public virtual string AlertActionLocalizationKey { get; set; }
  public virtual string AlertBody { get; set; }
  public virtual string AlertLaunchImage { get; set; }
  public virtual string[] AlertLocalizationArgs { get; set; }
  public virtual string AlertLocalizationKey { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string[] DesiredKeys { get; set; }
  public virtual bool ShouldBadge { get; set; }
  public virtual string SoundName { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CloudKit.CKNotificationType

[Serializable]
public enum CKNotificationType {
  Query = 1,
  ReadNotification = 3,
  RecordZone = 2,
}

New Type MonoTouch.CloudKit.CKOperation

public class CKOperation : MonoTouch.Foundation.NSOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKOperation (MonoTouch.Foundation.NSCoder coder);
  public CKOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKOperation (System.IntPtr handle);
  // properties
  public virtual bool AllowsCellularAccess { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual CKContainer Container { get; set; }
  public virtual bool UsesBackgroundSession { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKQuery

public class CKQuery : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKQuery (MonoTouch.Foundation.NSCoder coder);
  public CKQuery (MonoTouch.Foundation.NSObjectFlag t);
  public CKQuery (System.IntPtr handle);
  public CKQuery (string recordType, MonoTouch.Foundation.NSPredicate predicate);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSPredicate Predicate { get; }
  public virtual string RecordType { get; }
  public virtual MonoTouch.Foundation.NSSortDescriptor[] SortDescriptors { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKQueryCursor

public class CKQueryCursor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKQueryCursor (MonoTouch.Foundation.NSCoder coder);
  public CKQueryCursor (MonoTouch.Foundation.NSObjectFlag t);
  public CKQueryCursor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CloudKit.CKQueryNotification

public class CKQueryNotification : MonoTouch.CloudKit.CKNotification, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKQueryNotification (MonoTouch.Foundation.NSCoder coder);
  public CKQueryNotification (MonoTouch.Foundation.NSObjectFlag t);
  public CKQueryNotification (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool IsPublicDatabase { get; }
  public virtual CKQueryNotificationReason QueryNotificationReason { get; }
  public virtual MonoTouch.Foundation.NSDictionary RecordFields { get; }
  public virtual CKRecordID RecordId { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKQueryNotificationReason

[Serializable]
public enum CKQueryNotificationReason {
  RecordCreated = 1,
  RecordDeleted = 3,
  RecordUpdated = 2,
}

New Type MonoTouch.CloudKit.CKQueryOperation

public class CKQueryOperation : MonoTouch.CloudKit.CKDatabaseOperation, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKQueryOperation ();
  public CKQueryOperation (MonoTouch.Foundation.NSCoder coder);
  public CKQueryOperation (MonoTouch.Foundation.NSObjectFlag t);
  public CKQueryOperation (System.IntPtr handle);
  public CKQueryOperation (CKQuery query);
  public CKQueryOperation (CKQueryCursor cursor);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual System.Action<CKQueryCursor,MonoTouch.Foundation.NSError> Completed { set; }
  public virtual CKQueryCursor Cursor { get; set; }
  public virtual string[] DesiredKeys { get; set; }
  public virtual CKQuery Query { get; set; }
  public virtual System.Action<CKRecord> RecordFetched { set; }
  public virtual uint ResultsLimit { get; set; }
  public virtual CKRecordZoneID ZoneId { get; set; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKRecord

public class CKRecord : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecord (MonoTouch.Foundation.NSCoder coder);
  public CKRecord (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecord (System.IntPtr handle);
  public CKRecord (string recordType);
  public CKRecord (string recordType, CKRecordID recordId);
  public CKRecord (string recordType, CKRecordZoneID zoneId);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate CreationDate { get; }
  public virtual CKRecordID CreatorUserRecordId { get; }
  public MonoTouch.Foundation.NSObject Item { get; set; }
  public virtual CKRecordID LastModifiedUserRecordId { get; }
  public virtual MonoTouch.Foundation.NSDate ModificationDate { get; }
  public virtual string RecordChangeTag { get; }
  public virtual CKRecordID RecordId { get; }
  public virtual string RecordType { get; }
  public static MonoTouch.Foundation.NSString TypeUserRecord { get; }
  // methods
  public virtual string[] AllKeys ();
  public virtual string[] AllTokens ();
  public virtual string[] ChangedKeys ();
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public virtual void EncodeSystemFields (MonoTouch.Foundation.NSCoder coder);
}

New Type MonoTouch.CloudKit.CKRecordID

public class CKRecordID : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecordID ();
  public CKRecordID (MonoTouch.Foundation.NSCoder coder);
  public CKRecordID (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecordID (System.IntPtr handle);
  public CKRecordID (string recordName);
  public CKRecordID (string recordName, CKRecordZoneID zoneId);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string RecordName { get; }
  public virtual CKRecordZoneID ZoneId { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKRecordSavePolicy

[Serializable]
public enum CKRecordSavePolicy {
  SaveAllKeys = 2,
  SaveChangedKeys = 1,
  SaveIfServerRecordUnchanged = 0,
}

New Type MonoTouch.CloudKit.CKRecordValue

public class CKRecordValue : MonoTouch.Foundation.NSObject, ICKRecordValue, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecordValue ();
  public CKRecordValue (MonoTouch.Foundation.NSCoder coder);
  public CKRecordValue (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecordValue (System.IntPtr handle);
}

New Type MonoTouch.CloudKit.CKRecordValue_Extensions

public static class CKRecordValue_Extensions {
}

New Type MonoTouch.CloudKit.CKRecordZone

public class CKRecordZone : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecordZone ();
  public CKRecordZone (MonoTouch.Foundation.NSCoder coder);
  public CKRecordZone (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecordZone (System.IntPtr handle);
  public CKRecordZone (string zoneName);
  public CKRecordZone (CKRecordZoneID zoneId);
  // properties
  public virtual CKRecordZoneCapabilities Capabilities { get; }
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString DefaultName { get; }
  public virtual CKRecordZoneID ZoneId { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static CKRecordZone DefaultRecordZone ();
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKRecordZoneCapabilities

[Serializable]
[Flags]
public enum CKRecordZoneCapabilities {
  Atomic = 2,
  FetchChanges = 1,
}

New Type MonoTouch.CloudKit.CKRecordZoneCompleteHandler

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

New Type MonoTouch.CloudKit.CKRecordZoneID

public class CKRecordZoneID : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecordZoneID ();
  public CKRecordZoneID (MonoTouch.Foundation.NSCoder coder);
  public CKRecordZoneID (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecordZoneID (System.IntPtr handle);
  public CKRecordZoneID (string zoneName, string ownerName);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string OwnerName { get; }
  public virtual string ZoneName { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CloudKit.CKRecordZoneNotification

public class CKRecordZoneNotification : MonoTouch.CloudKit.CKNotification, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKRecordZoneNotification (MonoTouch.Foundation.NSCoder coder);
  public CKRecordZoneNotification (MonoTouch.Foundation.NSObjectFlag t);
  public CKRecordZoneNotification (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKRecordZoneID RecordZoneId { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKReference

public class CKReference : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKReference (MonoTouch.Foundation.NSCoder coder);
  public CKReference (MonoTouch.Foundation.NSObjectFlag t);
  public CKReference (System.IntPtr handle);
  public CKReference (CKRecordID recordId, CKReferenceAction action);
  public CKReference (CKRecord record, CKReferenceAction action);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKRecordID RecordId { get; }
  public virtual CKReferenceAction ReferenceAction { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKReferenceAction

[Serializable]
public enum CKReferenceAction {
  DeleteSelf = 1,
  None = 0,
}

New Type MonoTouch.CloudKit.CKServerChangeToken

public class CKServerChangeToken : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKServerChangeToken (MonoTouch.Foundation.NSCoder coder);
  public CKServerChangeToken (MonoTouch.Foundation.NSObjectFlag t);
  public CKServerChangeToken (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.CloudKit.CKSubscription

public class CKSubscription : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public CKSubscription (MonoTouch.Foundation.NSCoder coder);
  public CKSubscription (MonoTouch.Foundation.NSObjectFlag t);
  public CKSubscription (System.IntPtr handle);
  public CKSubscription (string recordType, MonoTouch.Foundation.NSPredicate predicate, CKSubscriptionOptions subscriptionOptions);
  public CKSubscription (string recordType, MonoTouch.Foundation.NSPredicate predicate, string subscriptionId, CKSubscriptionOptions subscriptionOptions);
  public CKSubscription (CKRecordZoneID zoneId, CKSubscriptionOptions subscriptionOptions);
  public CKSubscription (CKRecordZoneID zoneId, string subscriptionId, CKSubscriptionOptions subscriptionOptions);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual CKNotificationInfo NotificationInfo { get; set; }
  public virtual MonoTouch.Foundation.NSPredicate Predicate { get; }
  public virtual string RecordType { get; }
  public virtual string SubscriptionId { get; }
  public virtual CKSubscriptionOptions SubscriptionOptions { get; }
  public virtual CKSubscriptionType SubscriptionType { get; }
  public virtual CKRecordZoneID ZoneID { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.CloudKit.CKSubscriptionOptions

[Serializable]
[Flags]
public enum CKSubscriptionOptions {
  FiresOnce = 8,
  FiresOnRecordCreation = 1,
  FiresOnRecordDeletion = 4,
  FiresOnRecordUpdate = 2,
  ThisClientOnly = 16,
}

New Type MonoTouch.CloudKit.CKSubscriptionType

[Serializable]
public enum CKSubscriptionType {
  Query = 1,
  RecordZone = 2,
}

New Type MonoTouch.CloudKit.ICKRecordValue

public interface ICKRecordValue : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Namespace MonoTouch.HealthKit

New Type MonoTouch.HealthKit.HKAnchoredObjectQuery

public class HKAnchoredObjectQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKAnchoredObjectQuery (MonoTouch.Foundation.NSCoder coder);
  public HKAnchoredObjectQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKAnchoredObjectQuery (System.IntPtr handle);
  public HKAnchoredObjectQuery (HKSampleType type, MonoTouch.Foundation.NSPredicate predicate, uint anchor, uint limit, HKAnchoredObjectQueryCtorCompletionHandler handler);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKAnchoredObjectQueryCtorCompletionHandler

public sealed delegate HKAnchoredObjectQueryCtorCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public HKAnchoredObjectQueryCtorCompletionHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (HKAnchoredObjectQuery query, MonoTouch.Foundation.NSObject[] results, uint newAnchor, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (HKAnchoredObjectQuery query, MonoTouch.Foundation.NSObject[] results, uint newAnchor, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKAuthorizationStatus

[Serializable]
public enum HKAuthorizationStatus {
  NotDetermined = 0,
  SharingAuthorized = 2,
  SharingDenied = 1,
}

New Type MonoTouch.HealthKit.HKBiologicalSex

[Serializable]
public enum HKBiologicalSex {
  Female = 1,
  Male = 2,
  NotSet = 0,
}

New Type MonoTouch.HealthKit.HKBiologicalSexObject

public class HKBiologicalSexObject : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKBiologicalSexObject ();
  public HKBiologicalSexObject (MonoTouch.Foundation.NSCoder coder);
  public HKBiologicalSexObject (MonoTouch.Foundation.NSObjectFlag t);
  public HKBiologicalSexObject (System.IntPtr handle);
  // properties
  public virtual HKBiologicalSex BiologicalSex { get; }
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKBloodType

[Serializable]
public enum HKBloodType {
  ABNegative = 6,
  ABPositive = 5,
  ANegative = 2,
  APositive = 1,
  BNegative = 4,
  BPositive = 3,
  NotSet = 0,
  ONegative = 8,
  OPositive = 7,
}

New Type MonoTouch.HealthKit.HKBloodTypeObject

public class HKBloodTypeObject : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKBloodTypeObject ();
  public HKBloodTypeObject (MonoTouch.Foundation.NSCoder coder);
  public HKBloodTypeObject (MonoTouch.Foundation.NSObjectFlag t);
  public HKBloodTypeObject (System.IntPtr handle);
  // properties
  public virtual HKBloodType BloodType { get; }
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKBodyTemperatureSensorLocation

[Serializable]
public enum HKBodyTemperatureSensorLocation {
  Armpit = 1,
  Body = 2,
  Ear = 3,
  EarDrum = 9,
  Finger = 4,
  Forehead = 11,
  GastroIntestinal = 5,
  Mouth = 6,
  Other = 0,
  Rectum = 7,
  TemporalArtery = 10,
  Toe = 8,
}

New Type MonoTouch.HealthKit.HKCategorySample

public class HKCategorySample : MonoTouch.HealthKit.HKSample, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKCategorySample (MonoTouch.Foundation.NSCoder coder);
  public HKCategorySample (MonoTouch.Foundation.NSObjectFlag t);
  public HKCategorySample (System.IntPtr handle);
  // properties
  public virtual HKCategoryType CategoryType { get; }
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathCategoryValue { get; }
  public virtual int Value { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static HKCategorySample FromType (HKCategoryType type, int value, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, MonoTouch.Foundation.NSDictionary metadata);
  public static HKCategorySample FromType (HKCategoryType type, int value, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate);
}

New Type MonoTouch.HealthKit.HKCategoryType

public class HKCategoryType : MonoTouch.HealthKit.HKSampleType, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKCategoryType (MonoTouch.Foundation.NSCoder coder);
  public HKCategoryType (MonoTouch.Foundation.NSObjectFlag t);
  public HKCategoryType (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKCategoryTypeIdentifier

public static class HKCategoryTypeIdentifier {
  // properties
  public static MonoTouch.Foundation.NSString SleepAnalysis { get; }
}

New Type MonoTouch.HealthKit.HKCategoryValueSleepAnalysis

[Serializable]
public enum HKCategoryValueSleepAnalysis {
  Asleep = 1,
  InBed = 0,
}

New Type MonoTouch.HealthKit.HKCharacteristicType

public class HKCharacteristicType : MonoTouch.HealthKit.HKObjectType, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKCharacteristicType (MonoTouch.Foundation.NSCoder coder);
  public HKCharacteristicType (MonoTouch.Foundation.NSObjectFlag t);
  public HKCharacteristicType (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKCharacteristicTypeIdentifier

public static class HKCharacteristicTypeIdentifier {
  // properties
  public static MonoTouch.Foundation.NSString BiologicalSex { get; }
  public static MonoTouch.Foundation.NSString BloodType { get; }
  public static MonoTouch.Foundation.NSString DateOfBirth { get; }
}

New Type MonoTouch.HealthKit.HKCorrelation

public class HKCorrelation : MonoTouch.HealthKit.HKObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKCorrelation (MonoTouch.Foundation.NSCoder coder);
  public HKCorrelation (MonoTouch.Foundation.NSObjectFlag t);
  public HKCorrelation (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSSet Objects { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static HKCorrelation FromObjects (MonoTouch.Foundation.NSSet objects);
  public static HKCorrelation FromObjects (MonoTouch.Foundation.NSSet objects, MonoTouch.Foundation.NSDictionary metadata);
}

New Type MonoTouch.HealthKit.HKCorrelationQuery

public class HKCorrelationQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKCorrelationQuery (MonoTouch.Foundation.NSCoder coder);
  public HKCorrelationQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKCorrelationQuery (System.IntPtr handle);
  public HKCorrelationQuery (MonoTouch.Foundation.NSObject[] types, MonoTouch.Foundation.NSPredicate predicate, MonoTouch.Foundation.NSPredicate samplePredicate, HKCorrelationQueryCtorCompletionHandler handler);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSPredicate SamplePredicate { get; }
  public virtual MonoTouch.Foundation.NSObject[] Types { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKCorrelationQueryCtorCompletionHandler

public sealed delegate HKCorrelationQueryCtorCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public HKCorrelationQueryCtorCompletionHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (HKCorrelationQuery query, HKCorrelation[] correlations, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (HKCorrelationQuery query, HKCorrelation[] correlations, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKErrorCode

[Serializable]
public enum HKErrorCode {
  AuthorizationDenied = 3,
  AuthorizationNotDetermined = 4,
  DatabaseInaccessible = 5,
  HealthDataUnavailable = 1,
  InvalidArgument = 2,
  NoError = 0,
}

New Type MonoTouch.HealthKit.HKHealthStore

public class HKHealthStore : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKHealthStore ();
  public HKHealthStore (MonoTouch.Foundation.NSCoder coder);
  public HKHealthStore (MonoTouch.Foundation.NSObjectFlag t);
  public HKHealthStore (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static bool IsHealthDataAvailable { get; }
  // methods
  public virtual HKAuthorizationStatus AuthorizationStatus (HKObjectType type);
  public virtual void DeleteObject (HKObject obj, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> DeleteObjectAsync (HKObject obj);
  public virtual void DisableAllBackgroundDelivery (System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> DisableAllBackgroundDeliveryAsync ();
  public virtual void DisableBackgroundDelivery (HKObjectType type, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> DisableBackgroundDeliveryAsync (HKObjectType type);
  public virtual void EnableBackgroundDelivery (HKObjectType type, HKUpdateFrequency frequency, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> EnableBackgroundDeliveryAsync (HKObjectType type, HKUpdateFrequency frequency);
  public virtual void ExecuteQuery (HKQuery query);
  public virtual HKBiologicalSexObject GetBiologicalSex (out MonoTouch.Foundation.NSError error);
  public virtual HKBloodTypeObject GetBloodType (out MonoTouch.Foundation.NSError error);
  public virtual MonoTouch.Foundation.NSDate GetDateOfBirth (out MonoTouch.Foundation.NSError error);
  public virtual void RequestAuthorizationToShare (MonoTouch.Foundation.NSSet typesToShare, MonoTouch.Foundation.NSSet typesToRead, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> RequestAuthorizationToShareAsync (MonoTouch.Foundation.NSSet typesToShare, MonoTouch.Foundation.NSSet typesToRead);
  public virtual void SaveObject (HKObject obj, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> SaveObjectAsync (HKObject obj);
  public virtual void SaveObjects (HKObject[] objects, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task<bool> SaveObjectsAsync (HKObject[] objects);
  public virtual void StopQuery (HKQuery query);
}

New Type MonoTouch.HealthKit.HKHeartRateSensorLocation

[Serializable]
public enum HKHeartRateSensorLocation {
  Chest = 1,
  EarLobe = 5,
  Finger = 3,
  Foot = 6,
  Hand = 4,
  Other = 0,
  Wrist = 2,
}

New Type MonoTouch.HealthKit.HKMetadataKey

public static class HKMetadataKey {
  // properties
  public static MonoTouch.Foundation.NSString BodyTemperatureSensorLocation { get; }
  public static MonoTouch.Foundation.NSString DeviceSerialNumber { get; }
  public static MonoTouch.Foundation.NSString DigitalSignature { get; }
  public static MonoTouch.Foundation.NSString FoodType { get; }
  public static MonoTouch.Foundation.NSString HeartRateSensorLocation { get; }
  public static MonoTouch.Foundation.NSString UdiDeviceIdentifier { get; }
  public static MonoTouch.Foundation.NSString UdiProductionIdentifier { get; }
}

New Type MonoTouch.HealthKit.HKMetricPrefix

[Serializable]
public enum HKMetricPrefix {
  Centi = 5,
  Deca = 7,
  Deci = 6,
  Giga = 11,
  Hecto = 8,
  Kilo = 9,
  Mega = 10,
  Micro = 3,
  Milli = 4,
  Nano = 2,
  None = 0,
  Pico = 1,
  Tera = 12,
}

New Type MonoTouch.HealthKit.HKObject

public class HKObject : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKObject (MonoTouch.Foundation.NSCoder coder);
  public HKObject (MonoTouch.Foundation.NSObjectFlag t);
  public HKObject (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDictionary Metadata { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathMetadata { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathSource { get; }
  public virtual HKSource Source { get; }
  public virtual MonoTouch.Foundation.NSUuid Uuid { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKObjectType

public class HKObjectType : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKObjectType (MonoTouch.Foundation.NSCoder coder);
  public HKObjectType (MonoTouch.Foundation.NSObjectFlag t);
  public HKObjectType (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSString Identifier { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public static HKCategoryType GetCategoryType (string identifier);
  public static HKCharacteristicType GetCharacteristicType (string identifier);
  public static HKQuantityType GetQuantityType (string identifier);
}

New Type MonoTouch.HealthKit.HKObserverQuery

public class HKObserverQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKObserverQuery (MonoTouch.Foundation.NSCoder coder);
  public HKObserverQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKObserverQuery (System.IntPtr handle);
  public HKObserverQuery (HKSampleType sampleType, MonoTouch.Foundation.NSPredicate predicate, HKObserverQueryUpdateHandler updateHandler);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKObserverQueryCompletionHandler

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

New Type MonoTouch.HealthKit.HKObserverQueryUpdateHandler

public sealed delegate HKObserverQueryUpdateHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public HKObserverQueryUpdateHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (HKObserverQuery query, HKObserverQueryCompletionHandler completionHandler, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (HKObserverQuery query, HKObserverQueryCompletionHandler completionHandler, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKQuantity

public class HKQuantity : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKQuantity (MonoTouch.Foundation.NSCoder coder);
  public HKQuantity (MonoTouch.Foundation.NSObjectFlag t);
  public HKQuantity (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSComparisonResult Compare (HKQuantity quantity);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static HKQuantity FromQuantity (HKUnit unit, double value);
  public virtual double GetDoubleValue (HKUnit unit);
  public virtual bool IsCompatible (HKUnit unit);
}

New Type MonoTouch.HealthKit.HKQuantityAggregationStyle

[Serializable]
public enum HKQuantityAggregationStyle {
  Cumulative = 0,
  Discrete = 1,
}

New Type MonoTouch.HealthKit.HKQuantitySample

public class HKQuantitySample : MonoTouch.HealthKit.HKSample, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKQuantitySample (MonoTouch.Foundation.NSCoder coder);
  public HKQuantitySample (MonoTouch.Foundation.NSObjectFlag t);
  public HKQuantitySample (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathQuantity { get; }
  public virtual HKQuantity Quantity { get; }
  public virtual HKQuantityType QuantityType { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static HKQuantitySample FromType (HKQuantityType quantityType, HKQuantity quantity, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, MonoTouch.Foundation.NSDictionary metadata);
}

New Type MonoTouch.HealthKit.HKQuantityType

public class HKQuantityType : MonoTouch.HealthKit.HKSampleType, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKQuantityType (MonoTouch.Foundation.NSCoder coder);
  public HKQuantityType (MonoTouch.Foundation.NSObjectFlag t);
  public HKQuantityType (System.IntPtr handle);
  // properties
  public virtual HKQuantityAggregationStyle AggregationStyle { get; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual bool IsCompatibleWithUnit (HKUnit unit);
}

New Type MonoTouch.HealthKit.HKQuantityTypeIdentifier

public static class HKQuantityTypeIdentifier {
  // properties
  public static MonoTouch.Foundation.NSString ActiveEnergyBurned { get; }
  public static MonoTouch.Foundation.NSString ActivityCount { get; }
  public static MonoTouch.Foundation.NSString BasalEnergyBurned { get; }
  public static MonoTouch.Foundation.NSString BloodAlcoholContent { get; }
  public static MonoTouch.Foundation.NSString BloodGlucose { get; }
  public static MonoTouch.Foundation.NSString BloodPressureDiastolic { get; }
  public static MonoTouch.Foundation.NSString BloodPressureSystolic { get; }
  public static MonoTouch.Foundation.NSString BodyFatPercentage { get; }
  public static MonoTouch.Foundation.NSString BodyMass { get; }
  public static MonoTouch.Foundation.NSString BodyMassIndex { get; }
  public static MonoTouch.Foundation.NSString BodyTemperature { get; }
  public static MonoTouch.Foundation.NSString Distance { get; }
  public static MonoTouch.Foundation.NSString FlightsClimbed { get; }
  public static MonoTouch.Foundation.NSString GalvanicSkinResponse { get; }
  public static MonoTouch.Foundation.NSString HeartRate { get; }
  public static MonoTouch.Foundation.NSString HeatFlux { get; }
  public static MonoTouch.Foundation.NSString Height { get; }
  public static MonoTouch.Foundation.NSString InhalerUsage { get; }
  public static MonoTouch.Foundation.NSString LeanBodyMass { get; }
  public static MonoTouch.Foundation.NSString NikeFuel { get; }
  public static MonoTouch.Foundation.NSString NumberOfTimesFallen { get; }
  public static MonoTouch.Foundation.NSString OxygenSaturation { get; }
  public static MonoTouch.Foundation.NSString PerfusionIndex { get; }
  public static MonoTouch.Foundation.NSString RespiratoryRate { get; }
  public static MonoTouch.Foundation.NSString RRInterval { get; }
  public static MonoTouch.Foundation.NSString StepCount { get; }
}

New Type MonoTouch.HealthKit.HKQuantityTypeIdentifierDietary

public static class HKQuantityTypeIdentifierDietary {
  // properties
  public static MonoTouch.Foundation.NSString Biotin { get; }
  public static MonoTouch.Foundation.NSString Calcium { get; }
  public static MonoTouch.Foundation.NSString Calories { get; }
  public static MonoTouch.Foundation.NSString Carbohydrates { get; }
  public static MonoTouch.Foundation.NSString Chloride { get; }
  public static MonoTouch.Foundation.NSString Cholesterol { get; }
  public static MonoTouch.Foundation.NSString Chromium { get; }
  public static MonoTouch.Foundation.NSString Copper { get; }
  public static MonoTouch.Foundation.NSString FatMonounsaturated { get; }
  public static MonoTouch.Foundation.NSString FatPolyunsaturated { get; }
  public static MonoTouch.Foundation.NSString FatSaturated { get; }
  public static MonoTouch.Foundation.NSString FatTotal { get; }
  public static MonoTouch.Foundation.NSString Fiber { get; }
  public static MonoTouch.Foundation.NSString Folate { get; }
  public static MonoTouch.Foundation.NSString Iodine { get; }
  public static MonoTouch.Foundation.NSString Iron { get; }
  public static MonoTouch.Foundation.NSString Magnesium { get; }
  public static MonoTouch.Foundation.NSString Manganese { get; }
  public static MonoTouch.Foundation.NSString Molybdenum { get; }
  public static MonoTouch.Foundation.NSString Niacin { get; }
  public static MonoTouch.Foundation.NSString PantothenicAcid { get; }
  public static MonoTouch.Foundation.NSString Phosphorus { get; }
  public static MonoTouch.Foundation.NSString Potassium { get; }
  public static MonoTouch.Foundation.NSString Protein { get; }
  public static MonoTouch.Foundation.NSString Riboflavin { get; }
  public static MonoTouch.Foundation.NSString Selenium { get; }
  public static MonoTouch.Foundation.NSString Sodium { get; }
  public static MonoTouch.Foundation.NSString Sugar { get; }
  public static MonoTouch.Foundation.NSString Thiamin { get; }
  public static MonoTouch.Foundation.NSString VitaminA { get; }
  public static MonoTouch.Foundation.NSString VitaminB12 { get; }
  public static MonoTouch.Foundation.NSString VitaminB6 { get; }
  public static MonoTouch.Foundation.NSString VitaminC { get; }
  public static MonoTouch.Foundation.NSString VitaminD { get; }
  public static MonoTouch.Foundation.NSString VitaminE { get; }
  public static MonoTouch.Foundation.NSString VitaminK { get; }
  public static MonoTouch.Foundation.NSString Zinc { get; }
}

New Type MonoTouch.HealthKit.HKQuery

public class HKQuery : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKQuery (MonoTouch.Foundation.NSCoder coder);
  public HKQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKQuery (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSPredicate Predicate { get; }
  public virtual HKSampleType SampleType { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static MonoTouch.Foundation.NSPredicate GetPredicate (MonoTouch.Foundation.NSSet sources);
  public static MonoTouch.Foundation.NSPredicate GetPredicate (string key);
  public static MonoTouch.Foundation.NSPredicate GetPredicate (string key, MonoTouch.Foundation.NSPredicateOperatorType operatorType, MonoTouch.Foundation.NSObject value);
  public static MonoTouch.Foundation.NSPredicate GetPredicate (string key, MonoTouch.Foundation.NSObject[] allowedValues);
  public static MonoTouch.Foundation.NSPredicate GetPredicate (HKSource source);
  public static MonoTouch.Foundation.NSPredicate GetPredicateForCategorySamples (MonoTouch.Foundation.NSPredicateOperatorType operatorType, int value);
  public static MonoTouch.Foundation.NSPredicate GetPredicateForQuantitySamples (MonoTouch.Foundation.NSPredicateOperatorType operatorType, HKQuantity quantity);
}

New Type MonoTouch.HealthKit.HKQueryOptions

[Serializable]
public enum HKQueryOptions {
  None = 0,
  StrictEndDate = 2,
  StrictStartDate = 1,
}

New Type MonoTouch.HealthKit.HKSample

public class HKSample : MonoTouch.HealthKit.HKObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKSample (MonoTouch.Foundation.NSCoder coder);
  public HKSample (MonoTouch.Foundation.NSObjectFlag t);
  public HKSample (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate EndDate { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathEndDate { get; }
  public static MonoTouch.Foundation.NSString PredicateKeyPathStartDate { get; }
  public static MonoTouch.Foundation.NSString SampleSortIdentifierEndDate { get; }
  public static MonoTouch.Foundation.NSString SampleSortIdentifierStartDate { get; }
  public virtual HKSampleType SampleType { get; }
  public virtual MonoTouch.Foundation.NSDate StartDate { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKSampleQuery

public class HKSampleQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKSampleQuery (MonoTouch.Foundation.NSCoder coder);
  public HKSampleQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKSampleQuery (System.IntPtr handle);
  public HKSampleQuery (HKSampleType sampleType, MonoTouch.Foundation.NSPredicate predicate, uint limit, MonoTouch.Foundation.NSSortDescriptor[] sortDescriptors, HKSampleQueryResultsHandler resultsHandler);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual uint Limit { get; }
  public virtual MonoTouch.Foundation.NSSortDescriptor[] SortDescriptors { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKSampleQueryResultsHandler

public sealed delegate HKSampleQueryResultsHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public HKSampleQueryResultsHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (HKSampleQuery query, MonoTouch.Foundation.NSObject[] results, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (HKSampleQuery query, MonoTouch.Foundation.NSObject[] results, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKSampleType

public class HKSampleType : MonoTouch.HealthKit.HKObjectType, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKSampleType (MonoTouch.Foundation.NSCoder coder);
  public HKSampleType (MonoTouch.Foundation.NSObjectFlag t);
  public HKSampleType (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKSource

public class HKSource : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKSource (MonoTouch.Foundation.NSCoder coder);
  public HKSource (MonoTouch.Foundation.NSObjectFlag t);
  public HKSource (System.IntPtr handle);
  // properties
  public virtual string BundleIdentifier { get; }
  public override System.IntPtr ClassHandle { get; }
  public static HKSource GetDefaultSource { get; }
  public virtual string Name { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.HealthKit.HKSourceQuery

public class HKSourceQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKSourceQuery (MonoTouch.Foundation.NSCoder coder);
  public HKSourceQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKSourceQuery (System.IntPtr handle);
  public HKSourceQuery (HKSampleType sampleType, MonoTouch.Foundation.NSPredicate objectPredicate, HKSourceQueryCompletionHandler completionHandler);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKSourceQueryCompletionHandler

public sealed delegate HKSourceQueryCompletionHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public HKSourceQueryCompletionHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (HKSourceQuery query, MonoTouch.Foundation.NSSet sources, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (HKSourceQuery query, MonoTouch.Foundation.NSSet sources, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKStatistics

public class HKStatistics : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKStatistics (MonoTouch.Foundation.NSCoder coder);
  public HKStatistics (MonoTouch.Foundation.NSObjectFlag t);
  public HKStatistics (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate EndDate { get; }
  public virtual HKQuantityType QuantityType { get; }
  public virtual MonoTouch.Foundation.NSObject[] Sources { get; }
  public virtual MonoTouch.Foundation.NSDate StartDate { get; }
  // methods
  public virtual HKQuantity AverageQuantity (HKSource source);
  public virtual HKQuantity AverageQuantity ();
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public virtual HKQuantity MaximumQuantity (HKSource source);
  public virtual HKQuantity MaximumQuantity ();
  public virtual HKQuantity MinimumQuantity (HKSource source);
  public virtual HKQuantity MinimumQuantity ();
  public virtual HKQuantity SumQuantity (HKSource source);
  public virtual HKQuantity SumQuantity ();
}

New Type MonoTouch.HealthKit.HKStatisticsCollection

public class HKStatisticsCollection : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKStatisticsCollection (MonoTouch.Foundation.NSCoder coder);
  public HKStatisticsCollection (MonoTouch.Foundation.NSObjectFlag t);
  public HKStatisticsCollection (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSSet Sources { get; }
  public virtual HKStatistics[] Statistics { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void EnumerateStatistics (MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, HKStatisticsCollectionEnumerateStaticsHandler handler);
  public virtual HKStatistics GetStatistics (MonoTouch.Foundation.NSDate date);
}

New Type MonoTouch.HealthKit.HKStatisticsCollectionEnumerateStaticsHandler

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

New Type MonoTouch.HealthKit.HKStatisticsCollectionQuery

public class HKStatisticsCollectionQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKStatisticsCollectionQuery (MonoTouch.Foundation.NSCoder coder);
  public HKStatisticsCollectionQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKStatisticsCollectionQuery (System.IntPtr handle);
  public HKStatisticsCollectionQuery (HKQuantityType quantityType, MonoTouch.Foundation.NSPredicate quantitySamplePredicate, HKStatisticsOptions options, MonoTouch.Foundation.NSDate anchorDate, MonoTouch.Foundation.NSDateComponents intervalComponents);
  // properties
  public virtual MonoTouch.Foundation.NSDate AnchorDate { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDateComponents IntervalComponents { get; }
  public virtual HKStatisticsOptions Options { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void SetInitialResultsHandler (HKStatisticsCollectionQueryInitialResultsHandler handler);
  public virtual void SetStatisticsUpdateHandler (HKStatisticsCollectionQueryInitialResultsHandler handler);
}

New Type MonoTouch.HealthKit.HKStatisticsCollectionQueryInitialResultsHandler

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

New Type MonoTouch.HealthKit.HKStatisticsOptions

[Serializable]
public enum HKStatisticsOptions {
  CumulativeSum = 16,
  DiscreteAverage = 2,
  DiscreteMax = 8,
  DiscreteMin = 4,
  None = 0,
  SeparateBySource = 1,
}

New Type MonoTouch.HealthKit.HKStatisticsQuery

public class HKStatisticsQuery : MonoTouch.HealthKit.HKQuery, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKStatisticsQuery (MonoTouch.Foundation.NSCoder coder);
  public HKStatisticsQuery (MonoTouch.Foundation.NSObjectFlag t);
  public HKStatisticsQuery (System.IntPtr handle);
  public HKStatisticsQuery (HKQuantityType quantityType, MonoTouch.Foundation.NSPredicate quantitySamplePredicate, HKStatisticsOptions options, HKStatisticsQueryCompletionHandler completionHandler);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKStatisticsQueryCompletionHandler

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

New Type MonoTouch.HealthKit.HKUnit

public class HKUnit : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HKUnit (MonoTouch.Foundation.NSCoder coder);
  public HKUnit (MonoTouch.Foundation.NSObjectFlag t);
  public HKUnit (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool IsNull { get; }
  public virtual string UnitString { get; }
  // methods
  public static HKUnit FromAtmosphereUnit ();
  public static HKUnit FromCalorieUnit ();
  public static HKUnit FromCentimeterOfWaterUnit ();
  public static HKUnit FromCountUnit ();
  public static HKUnit FromDayUnit ();
  public static HKUnit FromDegreeCelsiusUnit ();
  public static HKUnit FromDegreeFahrenheitUnit ();
  public static HKUnit FromFootUnit ();
  public static HKUnit FromGramUnit ();
  public static HKUnit FromGramUnit (HKMetricPrefix prefix);
  public static HKUnit FromHourUnit ();
  public static HKUnit FromInchUnit ();
  public static HKUnit FromJouleUnit ();
  public static HKUnit FromJouleUnit (HKMetricPrefix prefix);
  public static HKUnit FromKelvinUnit ();
  public static HKUnit FromKilocalorieUnit ();
  public static HKUnit FromLiterUnit (HKMetricPrefix prefix);
  public static HKUnit FromLiterUnit ();
  public static HKUnit FromMeterUnit ();
  public static HKUnit FromMeterUnit (HKMetricPrefix prefix);
  public static HKUnit FromMileUnit ();
  public static HKUnit FromMillimeterOfMercuryUnit ();
  public static HKUnit FromMinuteUnit ();
  public static HKUnit FromMoleUnit (double gramsPerMole);
  public static HKUnit FromMoleUnit (HKMetricPrefix prefix, double gramsPerMole);
  public static HKUnit FromOunceUnit ();
  public static HKUnit FromPascalUnit (HKMetricPrefix prefix);
  public static HKUnit FromPascalUnit ();
  public static HKUnit FromPercentUnit ();
  public static HKUnit FromPoundUnit ();
  public static HKUnit FromSecondUnit (HKMetricPrefix prefix);
  public static HKUnit FromSecondUnit ();
  public static HKUnit FromSiemenUnit ();
  public static HKUnit FromSiemenUnit (HKMetricPrefix prefix);
  public static HKUnit FromStoneUnit ();
  public static HKUnit FromString (string aString);
  public virtual HKUnit ReciprocalUnit ();
  public virtual HKUnit UnitDividedBy (HKUnit unit);
  public virtual HKUnit UnitMultipliedBy (HKUnit unit);
  public virtual HKUnit UnitRaisedToPower (int power);
}

New Type MonoTouch.HealthKit.HKUpdateFrequency

[Serializable]
public enum HKUpdateFrequency {
  Daily = 3,
  Hourly = 2,
  Immediate = 1,
  Weekly = 4,
}

New Namespace MonoTouch.HomeKit

New Type MonoTouch.HomeKit.HMAccessory

public class HMAccessory : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMAccessory ();
  public HMAccessory (MonoTouch.Foundation.NSCoder coder);
  public HMAccessory (MonoTouch.Foundation.NSObjectFlag t);
  public HMAccessory (System.IntPtr handle);
  // properties
  public virtual bool Bridged { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Configured { get; }
  public HMAccessoryDelegate Delegate { get; set; }
  public virtual MonoTouch.Foundation.NSUuid identifier { get; }
  public virtual MonoTouch.Foundation.NSUuid[] IdentifiersForBridgedAccessories { get; }
  public virtual string Name { get; }
  public virtual bool Reachable { get; }
  public virtual HMRoom Room { get; }
  public virtual HMService[] Services { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler DidUpdateName;
  public event System.EventHandler<HMAccessoryUpdateForServiceEventArgs> DidUpdateNameForService;
  public event System.EventHandler DidUpdateReachability;
  public event System.EventHandler DidUpdateServices;
  public event System.EventHandler<HMAccessoryServiceUpdateCharacteristicEventArgs> DidUpdateValueForCharacteristic;
  // methods
  protected override void Dispose (bool disposing);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMAccessoryBrowser

public class HMAccessoryBrowser : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMAccessoryBrowser ();
  public HMAccessoryBrowser (MonoTouch.Foundation.NSCoder coder);
  public HMAccessoryBrowser (MonoTouch.Foundation.NSObjectFlag t);
  public HMAccessoryBrowser (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public HMAccessoryBrowserDelegate Delegate { get; set; }
  public virtual HMAccessory[] DiscoveredAccessories { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler<HMAccessoryBrowserEventArgs> DidFindNewAccessory;
  public event System.EventHandler<HMAccessoryBrowserEventArgs> DidRemoveNewAccessory;
  // methods
  protected override void Dispose (bool disposing);
  public virtual void StartSearchingForNewAccessories ();
  public virtual void StopSearchingForNewAccessories ();
}

New Type MonoTouch.HomeKit.HMAccessoryBrowserDelegate

public class HMAccessoryBrowserDelegate : MonoTouch.Foundation.NSObject, IHMAccessoryBrowserDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMAccessoryBrowserDelegate ();
  public HMAccessoryBrowserDelegate (MonoTouch.Foundation.NSCoder coder);
  public HMAccessoryBrowserDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public HMAccessoryBrowserDelegate (System.IntPtr handle);
  // methods
  public virtual void DidFindNewAccessory (HMAccessoryBrowser browser, HMAccessory accessory);
  public virtual void DidRemoveNewAccessory (HMAccessoryBrowser browser, HMAccessory accessory);
}

New Type MonoTouch.HomeKit.HMAccessoryBrowserDelegate_Extensions

public static class HMAccessoryBrowserDelegate_Extensions {
  // methods
  public static void DidFindNewAccessory (IHMAccessoryBrowserDelegate This, HMAccessoryBrowser browser, HMAccessory accessory);
  public static void DidRemoveNewAccessory (IHMAccessoryBrowserDelegate This, HMAccessoryBrowser browser, HMAccessory accessory);
}

New Type MonoTouch.HomeKit.HMAccessoryBrowserEventArgs

public class HMAccessoryBrowserEventArgs : System.EventArgs {
  // constructors
  public HMAccessoryBrowserEventArgs (HMAccessory accessory);
  // properties
  public HMAccessory Accessory { get; set; }
}

New Type MonoTouch.HomeKit.HMAccessoryDelegate

public class HMAccessoryDelegate : MonoTouch.Foundation.NSObject, IHMAccessoryDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMAccessoryDelegate ();
  public HMAccessoryDelegate (MonoTouch.Foundation.NSCoder coder);
  public HMAccessoryDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public HMAccessoryDelegate (System.IntPtr handle);
  // methods
  public virtual void DidUpdateName (HMAccessory accessory);
  public virtual void DidUpdateNameForService (HMAccessory accesssory, HMService service);
  public virtual void DidUpdateReachability (HMAccessory accessory);
  public virtual void DidUpdateServices (HMAccessory accessory);
  public virtual void DidUpdateValueForCharacteristic (HMAccessory accessory, HMService service, HMCharacteristic characteristic);
}

New Type MonoTouch.HomeKit.HMAccessoryDelegate_Extensions

public static class HMAccessoryDelegate_Extensions {
  // methods
  public static void DidUpdateName (IHMAccessoryDelegate This, HMAccessory accessory);
  public static void DidUpdateNameForService (IHMAccessoryDelegate This, HMAccessory accesssory, HMService service);
  public static void DidUpdateReachability (IHMAccessoryDelegate This, HMAccessory accessory);
  public static void DidUpdateServices (IHMAccessoryDelegate This, HMAccessory accessory);
  public static void DidUpdateValueForCharacteristic (IHMAccessoryDelegate This, HMAccessory accessory, HMService service, HMCharacteristic characteristic);
}

New Type MonoTouch.HomeKit.HMAccessoryServiceUpdateCharacteristicEventArgs

public class HMAccessoryServiceUpdateCharacteristicEventArgs : System.EventArgs {
  // constructors
  public HMAccessoryServiceUpdateCharacteristicEventArgs (HMService service, HMCharacteristic characteristic);
  // properties
  public HMCharacteristic Characteristic { get; set; }
  public HMService Service { get; set; }
}

New Type MonoTouch.HomeKit.HMAccessoryUpdateForServiceEventArgs

public class HMAccessoryUpdateForServiceEventArgs : System.EventArgs {
  // constructors
  public HMAccessoryUpdateForServiceEventArgs (HMService service);
  // properties
  public HMService Service { get; set; }
}

New Type MonoTouch.HomeKit.HMAction

public class HMAction : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMAction ();
  public HMAction (MonoTouch.Foundation.NSCoder coder);
  public HMAction (MonoTouch.Foundation.NSObjectFlag t);
  public HMAction (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HomeKit.HMActionSet

public class HMActionSet : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMActionSet (MonoTouch.Foundation.NSCoder coder);
  public HMActionSet (MonoTouch.Foundation.NSObjectFlag t);
  public HMActionSet (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSSet Actions { get; }
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString ExecutionFailedActionKey { get; }
  public virtual bool IsExecuting { get; }
  public virtual string Name { get; }
  // methods
  public virtual void AddAction (HMAction action, System.Action<MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task AddActionAsync (HMAction action);
  protected override void Dispose (bool disposing);
  public virtual void RemoveAction (HMAction action, System.Action<MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task RemoveActionAsync (HMAction action);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completion);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMCharacteristic

public class HMCharacteristic : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMCharacteristic ();
  public HMCharacteristic (MonoTouch.Foundation.NSCoder coder);
  public HMCharacteristic (MonoTouch.Foundation.NSObjectFlag t);
  public HMCharacteristic (System.IntPtr handle);
  // properties
  public HMCharacteristicType CharacteristicType { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual HMCharacteristicMetadata Metadata { get; }
  public virtual bool NotificationEnabled { get; }
  public HMCharacteristicProperties Properties { get; }
  public virtual HMService Service { get; }
  public virtual MonoTouch.Foundation.NSObject Value { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void EnableNotification (bool enable, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task EnableNotificationAsync (bool enable);
  public virtual void ReadValue (System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task ReadValueAsync ();
  public virtual void WriteValue (MonoTouch.Foundation.NSObject value, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task WriteValueAsync (MonoTouch.Foundation.NSObject value);
}

New Type MonoTouch.HomeKit.HMCharacteristicMetadata

public class HMCharacteristicMetadata : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMCharacteristicMetadata ();
  public HMCharacteristicMetadata (MonoTouch.Foundation.NSCoder coder);
  public HMCharacteristicMetadata (MonoTouch.Foundation.NSObjectFlag t);
  public HMCharacteristicMetadata (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string ManufacturerDescription { get; }
  public virtual MonoTouch.Foundation.NSNumber MaximumValue { get; }
  public virtual MonoTouch.Foundation.NSNumber MinimumValue { get; }
  public virtual MonoTouch.Foundation.NSNumber StepValue { get; }
  public HMCharacteristicMetadataUnits Units { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.HomeKit.HMCharacteristicMetadataUnits

[Serializable]
public enum HMCharacteristicMetadataUnits {
  ArcDegree = 4,
  Celsius = 1,
  Fahrenheit = 2,
  None = 0,
  Percentage = 3,
}

New Type MonoTouch.HomeKit.HMCharacteristicProperties

public class HMCharacteristicProperties {
  // constructors
  public HMCharacteristicProperties ();
  // properties
  public bool Readable { get; set; }
  public bool SupportsBonjourNotification { get; set; }
  public bool SupportsChangeNumber { get; set; }
  public bool SupportsEventNotification { get; set; }
  public bool Writable { get; set; }
}

New Type MonoTouch.HomeKit.HMCharacteristicType

[Serializable]
public enum HMCharacteristicType {
  Brightness = 4,
  CurrentDoorState = 11,
  CurrentRelativeHumidity = 9,
  CurrentTemperature = 6,
  HeatingCoolingStatus = 8,
  Hue = 2,
  Locked = 14,
  None = 0,
  ObstructionDetected = 13,
  PowerState = 1,
  Saturation = 3,
  TargetDoorState = 12,
  TargetRelativeHumidity = 10,
  TargetTemperature = 7,
  TemperatureUnits = 5,
}

New Type MonoTouch.HomeKit.HMCharacteristicWriteAction

public class HMCharacteristicWriteAction : MonoTouch.HomeKit.HMAction, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMCharacteristicWriteAction (MonoTouch.Foundation.NSCoder coder);
  public HMCharacteristicWriteAction (MonoTouch.Foundation.NSObjectFlag t);
  public HMCharacteristicWriteAction (System.IntPtr handle);
  public HMCharacteristicWriteAction (HMCharacteristic characteristic, MonoTouch.Foundation.NSObject targetValue);
  // properties
  public virtual HMCharacteristic Characteristic { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSObject TargetValue { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void UpdateTargetValue (MonoTouch.Foundation.NSObject targetValue, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateTargetValueAsync (MonoTouch.Foundation.NSObject targetValue);
}

New Type MonoTouch.HomeKit.HMError

[Serializable]
public enum HMError {
  AccessDenied = -70903,
  AccessoryIsBusy = -70899,
  AccessoryNotReachable = -70909,
  AccessoryOutOfResources = -70897,
  AccessoryPairingFailed = -70895,
  AccessoryPoweredOff = -70904,
  ActionInAnotherActionSet = -70883,
  AlreadyExists = -70912,
  CannotRemoveNonBridgeAccessory = -70779,
  FireDateInPast = -70885,
  HomeWithSameNameExists = -70881,
  InsufficientPrivileges = -70896,
  InvalidClass = -70891,
  InvalidDataFormatSpecified = -70894,
  InvalidParameter = -70910,
  MissingParameter = -70886,
  NameContainsProhibitedCharacters = -70778,
  NameDoesNotStartWithValidCharacters = -70777,
  NilParameter = -70893,
  NoActionsInActionSet = -70888,
  NoRegisteredActionSets = -70887,
  NotFound = -70911,
  NotificationNotSupported = -70906,
  ObjectAlreadyAssociatedToHome = -70900,
  ObjectAssociatedToAnotherHome = -70902,
  ObjectNotAssociatedToAnyHome = -70901,
  ObjectWithSameNameExistsInHome = -70882,
  OperationCancelled = -70890,
  OperationInProgress = -70898,
  OperationTimedOut = -70905,
  ReadonlyCharacterisitic = -70908,
  RenameWithSameName = -70880,
  RoomForHomeCannotBeInZone = -70889,
  RoomForHomeCannotBeUpdated = -70884,
  UnconfiguredParameter = -70892,
  WriteOnlyCharacterisitic = -70907,
}

New Type MonoTouch.HomeKit.HMErrors

public static class HMErrors {
  // properties
  public static MonoTouch.Foundation.NSString HMErrorDomain { get; }
}

New Type MonoTouch.HomeKit.HMHome

public class HMHome : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMHome (MonoTouch.Foundation.NSCoder coder);
  public HMHome (MonoTouch.Foundation.NSObjectFlag t);
  public HMHome (System.IntPtr handle);
  // properties
  public virtual HMAccessory[] Accessories { get; }
  public virtual HMActionSet[] ActionSets { get; }
  public override System.IntPtr ClassHandle { get; }
  public HMHomeDelegate Delegate { get; set; }
  public virtual string Name { get; }
  public virtual bool Primary { get; }
  public virtual HMRoom[] Rooms { get; }
  public virtual HMServiceGroup[] ServiceGroups { get; }
  public virtual HMTrigger[] Triggers { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  public virtual HMZone[] Zones { get; }
  // events
  public event System.EventHandler<HMHomeAccessoryEventArgs> DidAddAccessory;
  public event System.EventHandler<HMHomeActionSetEventArgs> DidAddActionSet;
  public event System.EventHandler<HMHomeRoomEventArgs> DidAddRoom;
  public event System.EventHandler<HMHomeRoomZoneEventArgs> DidAddRoomToZone;
  public event System.EventHandler<HMHomeServiceGroupEventArgs> DidAddServiceGroup;
  public event System.EventHandler<HMHomeServiceServiceGroupEventArgs> DidAddServiceToServiceGroup;
  public event System.EventHandler<HMHomeTriggerEventArgs> DidAddTrigger;
  public event System.EventHandler<HMHomeZoneEventArgs> DidAddZone;
  public event System.EventHandler<HMHomeAccessoryEventArgs> DidRemoveAccessory;
  public event System.EventHandler<HMHomeActionSetEventArgs> DidRemoveActionSet;
  public event System.EventHandler<HMHomeRoomEventArgs> DidRemoveRoom;
  public event System.EventHandler<HMHomeRoomZoneEventArgs> DidRemoveRoomFromZone;
  public event System.EventHandler<HMHomeServiceServiceGroupEventArgs> DidRemoveServiceFromServiceGroup;
  public event System.EventHandler<HMHomeServiceGroupEventArgs> DidRemoveServiceGroup;
  public event System.EventHandler<HMHomeTriggerEventArgs> DidRemoveTrigger;
  public event System.EventHandler<HMHomeZoneEventArgs> DidRemoveZone;
  public event System.EventHandler<HMHomeActionSetTriggerEventArgs> DidStartExecutingActionSet;
  public event System.EventHandler<HMHomeActionSetErrorEventArgs> DidStopExecutingActionSet;
  public event System.EventHandler<HMHomeActionSetEventArgs> DidUpdateActionsForActionSet;
  public event System.EventHandler DidUpdateName;
  public event System.EventHandler<HMHomeActionSetEventArgs> DidUpdateNameForActionSet;
  public event System.EventHandler<HMHomeRoomEventArgs> DidUpdateNameForRoom;
  public event System.EventHandler<HMHomeServiceGroupEventArgs> DidUpdateNameForServiceGroup;
  public event System.EventHandler<HMHomeTriggerEventArgs> DidUpdateNameForTrigger;
  public event System.EventHandler<HMHomeZoneEventArgs> DidUpdateNameForZone;
  public event System.EventHandler<HMomeRoomAccessoryEventArgs> DidUpdateRoom;
  public event System.EventHandler<HMHomeTriggerEventArgs> DidUpdateTrigger;
  // methods
  public virtual void AddAccessory (HMAccessory accessory, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AddAccessoryAsync (HMAccessory accessory);
  public virtual void AddActionSet (string actionSetName, System.Action<HMActionSet,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<HMActionSet> AddActionSetAsync (string actionSetName);
  public virtual void AddRoom (string roomName, System.Action<HMRoom,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<HMRoom> AddRoomAsync (string roomName);
  public virtual void AddServiceGroup (string serviceGroupName, System.Action<HMServiceGroup,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<HMServiceGroup> AddServiceGroupAsync (string serviceGroupName);
  public virtual void AddTrigger (HMTrigger trigger, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AddTriggerAsync (HMTrigger trigger);
  public virtual void AddZone (string zoneName, System.Action<HMZone,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<HMZone> AddZoneAsync (string zoneName);
  public virtual void AssignAccessory (HMAccessory accessory, HMRoom room, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AssignAccessoryAsync (HMAccessory accessory, HMRoom room);
  protected override void Dispose (bool disposing);
  public virtual void RemoveAccessory (HMAccessory accessory, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveAccessoryAsync (HMAccessory accessory);
  public virtual void RemoveActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveActionSetAsync (HMActionSet actionSet);
  public virtual void RemoveRoom (HMRoom room, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveRoomAsync (HMRoom room);
  public virtual void RemoveServiceGroup (HMServiceGroup serviceGroup, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveServiceGroupAsync (HMServiceGroup serviceGroup);
  public virtual void RemoveTrigger (HMTrigger trigger, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveTriggerAsync (HMTrigger trigger);
  public virtual void RemoveZone (HMZone zone, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveZoneAsync (HMZone zone);
  public virtual HMRoom RoomForEntireHome ();
  public HMService[] ServicesWithTypes (HMServiceType serviceTypes);
  public virtual void StartExecutingActionSet (HMActionSet actionSet);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMHomeAccessoryEventArgs

public class HMHomeAccessoryEventArgs : System.EventArgs {
  // constructors
  public HMHomeAccessoryEventArgs (HMAccessory accessory);
  // properties
  public HMAccessory Accessory { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeActionSetErrorEventArgs

public class HMHomeActionSetErrorEventArgs : System.EventArgs {
  // constructors
  public HMHomeActionSetErrorEventArgs (HMActionSet actionSet, MonoTouch.Foundation.NSError error);
  // properties
  public HMActionSet ActionSet { get; set; }
  public MonoTouch.Foundation.NSError Error { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeActionSetEventArgs

public class HMHomeActionSetEventArgs : System.EventArgs {
  // constructors
  public HMHomeActionSetEventArgs (HMActionSet actionSet);
  // properties
  public HMActionSet ActionSet { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeActionSetTriggerEventArgs

public class HMHomeActionSetTriggerEventArgs : System.EventArgs {
  // constructors
  public HMHomeActionSetTriggerEventArgs (HMActionSet actionSet, HMTrigger trigger);
  // properties
  public HMActionSet ActionSet { get; set; }
  public HMTrigger Trigger { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeDelegate

public class HMHomeDelegate : MonoTouch.Foundation.NSObject, IHMHomeDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMHomeDelegate ();
  public HMHomeDelegate (MonoTouch.Foundation.NSCoder coder);
  public HMHomeDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public HMHomeDelegate (System.IntPtr handle);
  // methods
  public virtual void DidAddAccessory (HMHome home, HMAccessory accessory);
  public virtual void DidAddActionSet (HMHome home, HMActionSet actionSet);
  public virtual void DidAddRoom (HMHome home, HMRoom room);
  public virtual void DidAddRoomToZone (HMHome home, HMRoom room, HMZone zone);
  public virtual void DidAddServiceGroup (HMHome home, HMServiceGroup serviceGroup);
  public virtual void DidAddServiceToServiceGroup (HMHome home, HMService service, HMServiceGroup serviceGroup);
  public virtual void DidAddTrigger (HMHome home, HMTrigger trigger);
  public virtual void DidAddZone (HMHome home, HMZone zone);
  public virtual void DidRemoveAccessory (HMHome home, HMAccessory accessory);
  public virtual void DidRemoveActionSet (HMHome home, HMActionSet actionSet);
  public virtual void DidRemoveRoom (HMHome home, HMRoom room);
  public virtual void DidRemoveRoomFromZone (HMHome home, HMRoom room, HMZone zone);
  public virtual void DidRemoveServiceFromServiceGroup (HMHome home, HMService service, HMServiceGroup serviceGroup);
  public virtual void DidRemoveServiceGroup (HMHome home, HMServiceGroup serviceGroup);
  public virtual void DidRemoveTrigger (HMHome home, HMTrigger trigger);
  public virtual void DidRemoveZone (HMHome home, HMZone zone);
  public virtual void DidStartExecutingActionSet (HMHome home, HMActionSet actionSet, HMTrigger trigger);
  public virtual void DidStopExecutingActionSet (HMHome home, HMActionSet actionSet, MonoTouch.Foundation.NSError error);
  public virtual void DidUpdateActionsForActionSet (HMHome home, HMActionSet actionSet);
  public virtual void DidUpdateName (HMHome home);
  public virtual void DidUpdateNameForActionSet (HMHome home, HMActionSet actionSet);
  public virtual void DidUpdateNameForRoom (HMHome home, HMRoom room);
  public virtual void DidUpdateNameForServiceGroup (HMHome home, HMServiceGroup serviceGroup);
  public virtual void DidUpdateNameForTrigger (HMHome home, HMTrigger trigger);
  public virtual void DidUpdateNameForZone (HMHome home, HMZone zone);
  public virtual void DidUpdateRoom (HMHome home, HMRoom room, HMAccessory accessory);
  public virtual void DidUpdateTrigger (HMHome home, HMTrigger trigger);
}

New Type MonoTouch.HomeKit.HMHomeDelegate_Extensions

public static class HMHomeDelegate_Extensions {
  // methods
  public static void DidAddAccessory (IHMHomeDelegate This, HMHome home, HMAccessory accessory);
  public static void DidAddActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
  public static void DidAddRoom (IHMHomeDelegate This, HMHome home, HMRoom room);
  public static void DidAddRoomToZone (IHMHomeDelegate This, HMHome home, HMRoom room, HMZone zone);
  public static void DidAddServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup serviceGroup);
  public static void DidAddServiceToServiceGroup (IHMHomeDelegate This, HMHome home, HMService service, HMServiceGroup serviceGroup);
  public static void DidAddTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
  public static void DidAddZone (IHMHomeDelegate This, HMHome home, HMZone zone);
  public static void DidRemoveAccessory (IHMHomeDelegate This, HMHome home, HMAccessory accessory);
  public static void DidRemoveActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
  public static void DidRemoveRoom (IHMHomeDelegate This, HMHome home, HMRoom room);
  public static void DidRemoveRoomFromZone (IHMHomeDelegate This, HMHome home, HMRoom room, HMZone zone);
  public static void DidRemoveServiceFromServiceGroup (IHMHomeDelegate This, HMHome home, HMService service, HMServiceGroup serviceGroup);
  public static void DidRemoveServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup serviceGroup);
  public static void DidRemoveTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
  public static void DidRemoveZone (IHMHomeDelegate This, HMHome home, HMZone zone);
  public static void DidStartExecutingActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet, HMTrigger trigger);
  public static void DidStopExecutingActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet, MonoTouch.Foundation.NSError error);
  public static void DidUpdateActionsForActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
  public static void DidUpdateName (IHMHomeDelegate This, HMHome home);
  public static void DidUpdateNameForActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
  public static void DidUpdateNameForRoom (IHMHomeDelegate This, HMHome home, HMRoom room);
  public static void DidUpdateNameForServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup serviceGroup);
  public static void DidUpdateNameForTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
  public static void DidUpdateNameForZone (IHMHomeDelegate This, HMHome home, HMZone zone);
  public static void DidUpdateRoom (IHMHomeDelegate This, HMHome home, HMRoom room, HMAccessory accessory);
  public static void DidUpdateTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
}

New Type MonoTouch.HomeKit.HMHomeManager

public class HMHomeManager : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMHomeManager ();
  public HMHomeManager (MonoTouch.Foundation.NSCoder coder);
  public HMHomeManager (MonoTouch.Foundation.NSObjectFlag t);
  public HMHomeManager (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public HMHomeManagerDelegate Delegate { get; set; }
  public virtual HMHome[] Homes { get; }
  public virtual HMHome PrimaryHome { get; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // events
  public event System.EventHandler<HMHomeManagerEventArgs> DidAddHome;
  public event System.EventHandler<HMHomeManagerEventArgs> DidRemoveHome;
  public event System.EventHandler DidUpdateHomes;
  public event System.EventHandler DidUpdatePrimaryHome;
  // methods
  public virtual void AddHome (string homeName, System.Action<HMHome,MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task<HMHome> AddHomeAsync (string homeName);
  protected override void Dispose (bool disposing);
  public virtual void RemoveHome (HMHome home, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveHomeAsync (HMHome home);
  public virtual void UpdatePrimaryHome (HMHome home, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdatePrimaryHomeAsync (HMHome home);
}

New Type MonoTouch.HomeKit.HMHomeManagerDelegate

public class HMHomeManagerDelegate : MonoTouch.Foundation.NSObject, IHMHomeManagerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMHomeManagerDelegate ();
  public HMHomeManagerDelegate (MonoTouch.Foundation.NSCoder coder);
  public HMHomeManagerDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public HMHomeManagerDelegate (System.IntPtr handle);
  // methods
  public virtual void DidAddHome (HMHomeManager manager, HMHome home);
  public virtual void DidRemoveHome (HMHomeManager manager, HMHome home);
  public virtual void DidUpdateHomes (HMHomeManager manager);
  public virtual void DidUpdatePrimaryHome (HMHomeManager manager);
}

New Type MonoTouch.HomeKit.HMHomeManagerDelegate_Extensions

public static class HMHomeManagerDelegate_Extensions {
  // methods
  public static void DidAddHome (IHMHomeManagerDelegate This, HMHomeManager manager, HMHome home);
  public static void DidRemoveHome (IHMHomeManagerDelegate This, HMHomeManager manager, HMHome home);
  public static void DidUpdateHomes (IHMHomeManagerDelegate This, HMHomeManager manager);
  public static void DidUpdatePrimaryHome (IHMHomeManagerDelegate This, HMHomeManager manager);
}

New Type MonoTouch.HomeKit.HMHomeManagerEventArgs

public class HMHomeManagerEventArgs : System.EventArgs {
  // constructors
  public HMHomeManagerEventArgs (HMHome home);
  // properties
  public HMHome Home { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeRoomEventArgs

public class HMHomeRoomEventArgs : System.EventArgs {
  // constructors
  public HMHomeRoomEventArgs (HMRoom room);
  // properties
  public HMRoom Room { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeRoomZoneEventArgs

public class HMHomeRoomZoneEventArgs : System.EventArgs {
  // constructors
  public HMHomeRoomZoneEventArgs (HMRoom room, HMZone zone);
  // properties
  public HMRoom Room { get; set; }
  public HMZone Zone { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeServiceGroupEventArgs

public class HMHomeServiceGroupEventArgs : System.EventArgs {
  // constructors
  public HMHomeServiceGroupEventArgs (HMServiceGroup serviceGroup);
  // properties
  public HMServiceGroup ServiceGroup { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeServiceServiceGroupEventArgs

public class HMHomeServiceServiceGroupEventArgs : System.EventArgs {
  // constructors
  public HMHomeServiceServiceGroupEventArgs (HMService service, HMServiceGroup serviceGroup);
  // properties
  public HMService Service { get; set; }
  public HMServiceGroup ServiceGroup { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeTriggerEventArgs

public class HMHomeTriggerEventArgs : System.EventArgs {
  // constructors
  public HMHomeTriggerEventArgs (HMTrigger trigger);
  // properties
  public HMTrigger Trigger { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeZoneEventArgs

public class HMHomeZoneEventArgs : System.EventArgs {
  // constructors
  public HMHomeZoneEventArgs (HMZone zone);
  // properties
  public HMZone Zone { get; set; }
}

New Type MonoTouch.HomeKit.HMomeRoomAccessoryEventArgs

public class HMomeRoomAccessoryEventArgs : System.EventArgs {
  // constructors
  public HMomeRoomAccessoryEventArgs (HMRoom room, HMAccessory accessory);
  // properties
  public HMAccessory Accessory { get; set; }
  public HMRoom Room { get; set; }
}

New Type MonoTouch.HomeKit.HMRoom

public class HMRoom : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMRoom (MonoTouch.Foundation.NSCoder coder);
  public HMRoom (MonoTouch.Foundation.NSObjectFlag t);
  public HMRoom (System.IntPtr handle);
  // properties
  public virtual HMAccessory[] Accessories { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMService

public class HMService : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMService ();
  public HMService (MonoTouch.Foundation.NSCoder coder);
  public HMService (MonoTouch.Foundation.NSObjectFlag t);
  public HMService (System.IntPtr handle);
  // properties
  public virtual HMAccessory Accessory { get; }
  public virtual HMCharacteristic[] Characteristics { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; }
  public HMServiceType ServiceType { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMServiceGroup

public class HMServiceGroup : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMServiceGroup (MonoTouch.Foundation.NSCoder coder);
  public HMServiceGroup (MonoTouch.Foundation.NSObjectFlag t);
  public HMServiceGroup (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; }
  public virtual HMService[] Services { get; }
  // methods
  public virtual void AddService (HMService service, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AddServiceAsync (HMService service);
  protected override void Dispose (bool disposing);
  public virtual void RemoveService (HMService service, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveServiceAsync (HMService service);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMServiceType

[Serializable]
[Flags]
public enum HMServiceType {
  GarageDoorOpener = 5,
  LightBulb = 1,
  Lock = 4,
  None = 0,
  Switch = 2,
  Thermostat = 3,
}

New Type MonoTouch.HomeKit.HMTimerTrigger

public class HMTimerTrigger : MonoTouch.HomeKit.HMTrigger, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMTimerTrigger (MonoTouch.Foundation.NSCoder coder);
  public HMTimerTrigger (MonoTouch.Foundation.NSObjectFlag t);
  public HMTimerTrigger (System.IntPtr handle);
  public HMTimerTrigger (string name, MonoTouch.Foundation.NSDate fireDate, MonoTouch.Foundation.NSTimeZone timeZone, MonoTouch.Foundation.NSDateComponents recurrence, MonoTouch.Foundation.NSCalendar recurrenceCalendar);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate FireDate { get; }
  public virtual MonoTouch.Foundation.NSDate LastFireDate { get; }
  public virtual MonoTouch.Foundation.NSDateComponents Recurrence { get; }
  public virtual MonoTouch.Foundation.NSCalendar RecurrenceCalendar { get; }
  public virtual MonoTouch.Foundation.NSTimeZone TimeZone { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual void UpdateFireDate (MonoTouch.Foundation.NSDate fireDate, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateFireDateAsync (MonoTouch.Foundation.NSDate fireDate);
  public virtual void UpdateRecurrence (MonoTouch.Foundation.NSDateComponents recurrence, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateRecurrenceAsync (MonoTouch.Foundation.NSDateComponents recurrence);
  public virtual void UpdateRecurrenceCalendar (MonoTouch.Foundation.NSCalendar recurrenceCalendar, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateRecurrenceCalendarAsync (MonoTouch.Foundation.NSCalendar recurrenceCalendar);
  public virtual void UpdateTimeZone (MonoTouch.Foundation.NSTimeZone timeZone, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateTimeZoneAsync (MonoTouch.Foundation.NSTimeZone timeZone);
}

New Type MonoTouch.HomeKit.HMTrigger

public class HMTrigger : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMTrigger (MonoTouch.Foundation.NSCoder coder);
  public HMTrigger (MonoTouch.Foundation.NSObjectFlag t);
  public HMTrigger (System.IntPtr handle);
  public HMTrigger (string name);
  // properties
  public virtual HMActionSet[] ActionSets { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Enabled { get; }
  public virtual string Name { get; }
  // methods
  public virtual void AddActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AddActionSetAsync (HMActionSet actionSet);
  protected override void Dispose (bool disposing);
  public virtual void Enable (bool enable, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task EnableAsync (bool enable);
  public virtual void RemoveActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveActionSetAsync (HMActionSet actionSet);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMZone

public class HMZone : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public HMZone (MonoTouch.Foundation.NSCoder coder);
  public HMZone (MonoTouch.Foundation.NSObjectFlag t);
  public HMZone (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; }
  public virtual HMRoom[] Rooms { get; }
  // methods
  public virtual void AddRoom (HMRoom room, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task AddRoomAsync (HMRoom room);
  protected override void Dispose (bool disposing);
  public virtual void RemoveRoom (HMRoom room, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task RemoveRoomAsync (HMRoom room);
  public virtual void UpdateName (string name, System.Action<MonoTouch.Foundation.NSError> completionHandler);
  public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.IHMAccessoryBrowserDelegate

public interface IHMAccessoryBrowserDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.HomeKit.IHMAccessoryDelegate

public interface IHMAccessoryDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.HomeKit.IHMHomeDelegate

public interface IHMHomeDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.HomeKit.IHMHomeManagerDelegate

public interface IHMHomeManagerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Namespace MonoTouch.LocalAuthentication

New Type MonoTouch.LocalAuthentication.LAContext

public class LAContext : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public LAContext ();
  public LAContext (MonoTouch.Foundation.NSCoder coder);
  public LAContext (MonoTouch.Foundation.NSObjectFlag t);
  public LAContext (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString ErrorDomain { get; }
  // methods
  public virtual bool CanEvaluatePolicy (LAPolicy policy, MonoTouch.Foundation.NSError error);
  public virtual void EvaluatePolicy (LAPolicy policy, string localizedReason, LAContextReplyHandler reply);
  public virtual System.Threading.Tasks.Task<bool> EvaluatePolicyAsync (LAPolicy policy, string localizedReason);
}

New Type MonoTouch.LocalAuthentication.LAContextReplyHandler

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

New Type MonoTouch.LocalAuthentication.LAOptions

[Serializable]
public enum LAOptions {
  AuthenticationReason = 2,
  UserFallback = 1,
}

New Type MonoTouch.LocalAuthentication.LAPolicy

[Serializable]
public enum LAPolicy {
  DeviceOwnerAuthenticationWithBiometrics = 1,
}

New Type MonoTouch.LocalAuthentication.LAStatus

[Serializable]
public enum LAStatus {
  AuthenticationFailed = -1,
  PasscodeNotSet = -5,
  Success = 0,
  SystemCancel = -4,
  TouchIDNotAvailable = -6,
  TouchIDNotEnrolled = -7,
  UserCancel = -2,
  UserFallback = -3,
}

New Namespace MonoTouch.Metal

New Type MonoTouch.Metal.IMTLBlitCommandEncoder

public interface IMTLBlitCommandEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLCommandEncoder {
  // methods
  public virtual void CopyFromBuffer (IMTLBuffer sourceBuffer, uint sourceOffset, uint sourceRowBytes, uint sourceImageBytes, MTLSize sourceSize, IMTLTexture destinationTexture, uint destinationSlice, uint destinationLevel, MTLOrigin destinationOrigin);
  public virtual void CopyFromBuffer (IMTLBuffer sourceBuffer, uint sourceOffset, IMTLBuffer destinationBuffer, uint destinationOffset, uint size);
  public virtual void CopyFromTexture (IMTLTexture sourceTexture, uint sourceSlice, uint sourceLevel, MTLOrigin sourceOrigin, MTLSize sourceSize, IMTLTexture destinationTexture, uint destinationSlice, uint destinationLevel, MTLOrigin destinationOrigin);
  public virtual void CopyFromTexture (IMTLTexture sourceTexture, uint sourceSlice, uint sourceLevel, MTLOrigin sourceOrigin, MTLSize sourceSize, IMTLBuffer destinationBuffer, uint destinationOffset, uint destinationRowBytes, uint destinationImageBytes);
  public virtual void FillBuffer (IMTLBuffer buffer, MonoTouch.Foundation.NSRange range, byte value);
  public virtual void GenerateMipmapsForTexture (IMTLTexture texture);
}

New Type MonoTouch.Metal.IMTLBuffer

public interface IMTLBuffer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLResource {
  // properties
  public virtual System.IntPtr Contents { get; }
  public virtual uint Length { get; }
  // methods
  public virtual IMTLTexture CreateTexture (MTLTextureDescriptor descriptor, uint offset, uint bytesPerRow);
}

New Type MonoTouch.Metal.IMTLCommandBuffer

public interface IMTLCommandBuffer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLBlitCommandEncoder BlitCommandEncoder { get; }
  public virtual IMTLCommandQueue CommandQueue { get; }
  public virtual IMTLComputeCommandEncoder ComputeCommandEncoder { get; }
  public virtual IMTLDevice Device { get; }
  public virtual MonoTouch.Foundation.NSError Error { get; }
  public virtual string Label { get; set; }
  public virtual bool RetainedReferences { get; }
  public virtual MTLCommandBufferStatus Status { get; }
  // methods
  public virtual void AddCompletedHandler (System.Action<IMTLCommandBuffer> block);
  public virtual void AddScheduledHandler (System.Action<IMTLCommandBuffer> block);
  public virtual void AddScheduledPresent (IMTLDrawable drawable);
  public virtual void Commit ();
  public virtual void Enqueue ();
  public virtual IMTLParallelRenderPassEncoder ParallelRenderPassEncoder (IMTLFramebuffer framebuffer);
  public virtual IMTLRenderCommandEncoder RenderCommandEncoder (IMTLFramebuffer framebuffer);
  public virtual void WaitUntilCompleted ();
  public virtual void WaitUntilScheduled ();
}

New Type MonoTouch.Metal.IMTLCommandEncoder

public interface IMTLCommandEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; set; }
  // methods
  public virtual void EndEncoding ();
  public virtual void InsertDebugSignpost (string signpost);
  public virtual void PopDebugGroup ();
  public virtual void PushDebugGroup (string debugGroup);
}

New Type MonoTouch.Metal.IMTLCommandQueue

public interface IMTLCommandQueue : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; set; }
  // methods
  public virtual IMTLCommandBuffer CommandBuffer ();
  public virtual IMTLCommandBuffer CommandBufferWithUnretainedReferences ();
  public virtual void InsertDebugCaptureBoundary ();
}

New Type MonoTouch.Metal.IMTLComputeCommandEncoder

public interface IMTLComputeCommandEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLCommandEncoder {
  // methods
  public virtual void ExecuteBarrier ();
  public virtual void ExecuteKernelWithWorkGroupSize (MTLSize workGroupSize, MTLSize workGroupCount);
  public virtual void SetBuffer (IMTLBuffer buffer, uint offset, uint index);
  public virtual void SetComputePipelineState (IMTLComputePipelineState state);
  public virtual void SetLocalMemorySize (uint localMemorySize, uint index);
  public virtual void SetSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
  public virtual void SetSamplerState (IMTLSamplerState sampler, uint index);
  public virtual void SetTexture (IMTLTexture texture, uint index);
}

New Type MonoTouch.Metal.IMTLComputePipelineState

public interface IMTLComputePipelineState : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual uint MaxWorkGroupSize { get; }
  public virtual uint PreferredWorkGroupFactor { get; }
}

New Type MonoTouch.Metal.IMTLDepthStencilState

public interface IMTLDepthStencilState : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.Metal.IMTLDevice

public interface IMTLDevice : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual string Name { get; }
  // methods
  public virtual IMTLBuffer CreateBuffer (System.IntPtr pointer, uint length, MTLResourceOptions options);
  public virtual IMTLBuffer CreateBuffer (uint length, MTLResourceOptions options);
  public virtual IMTLBuffer CreateBufferNoCopy (System.IntPtr pointer, uint length, MTLResourceOptions options, MTLDeallocator deallocator);
  public virtual IMTLCommandQueue CreateCommandQueue ();
  public virtual IMTLCommandQueue CreateCommandQueue (uint maxCommandBufferCount);
  public virtual void CreateComputePipelineState (IMTLFunction computeFunction, System.Action<IMTLComputePipelineState,MonoTouch.Foundation.NSError> completionHandler);
  public virtual IMTLLibrary CreateDefaultLibrary ();
  public virtual IMTLDepthStencilState CreateDepthStencilState (MTLDepthStencilDescriptor descriptor);
  public virtual IMTLFramebuffer CreateFramebuffer (MTLFramebufferDescriptor descriptor);
  public virtual void CreateLibrary (string source, MTLCompileOptions options, System.Action<IMTLLibrary,MonoTouch.Foundation.NSError> completionHandler);
  public virtual IMTLLibrary CreateLibrary (string source, MTLCompileOptions options, out MonoTouch.Foundation.NSError error);
  public virtual IMTLLibrary CreateLibrary (MonoTouch.Foundation.NSObject data, out MonoTouch.Foundation.NSError error);
  public virtual IMTLLibrary CreateLibrary (string filepath, out MonoTouch.Foundation.NSError error);
  public virtual void CreateRenderPipelineState (MTLRenderPipelineDescriptor descriptor, System.Action<IMTLRenderPipelineState,MonoTouch.Foundation.NSError> completionHandler);
  public virtual IMTLRenderPipelineState CreateRenderPipelineState (MTLRenderPipelineDescriptor descriptor, out MonoTouch.Foundation.NSError error);
  public virtual IMTLSamplerState CreateSamplerState (MTLSamplerDescriptor descriptor);
  public virtual IMTLTexture CreateTexture (MTLTextureDescriptor descriptor);
  public virtual IMTLComputePipelineState NewComputePipelineStateWithFunction (IMTLFunction computeFunction, out MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.Metal.IMTLDrawable

public interface IMTLDrawable : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void Present ();
}

New Type MonoTouch.Metal.IMTLFramebuffer

public interface IMTLFramebuffer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual uint Height { get; }
  public virtual string Label { get; set; }
  public virtual uint Width { get; }
}

New Type MonoTouch.Metal.IMTLFunction

public interface IMTLFunction : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual IMTLFunctionArgument[] FunctionArguments { get; }
  public virtual MTLFunctionType FunctionType { get; }
  public virtual string Name { get; }
}

New Type MonoTouch.Metal.IMTLFunctionArgument

public interface IMTLFunctionArgument : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual uint BindingIndex { get; }
  public virtual string Name { get; }
  public virtual MTLArgumentType ResourceType { get; }
}

New Type MonoTouch.Metal.IMTLLibrary

public interface IMTLLibrary : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string[] FunctionNames { get; }
  public virtual string Label { get; set; }
  // methods
  public virtual IMTLFunction CreateFunction (string functionName);
}

New Type MonoTouch.Metal.IMTLParallelRenderPassEncoder

public interface IMTLParallelRenderPassEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; set; }
  // methods
  public virtual void EndEncoding ();
  public virtual IMTLRenderCommandEncoder RenderCommandEncoder ();
}

New Type MonoTouch.Metal.IMTLRenderCommandEncoder

public interface IMTLRenderCommandEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLCommandEncoder {
  // methods
  public virtual void DrawIndexedPrimitives (MTLPrimitiveType primitiveType, uint indexCount, MTLIndexType indexType, IMTLBuffer indexBuffer, uint indexBufferOffset);
  public virtual void DrawIndexedPrimitives (MTLPrimitiveType primitiveType, uint indexCount, MTLIndexType indexType, IMTLBuffer indexBuffer, uint indexBufferOffset, uint instanceCount);
  public virtual void DrawPrimitives (MTLPrimitiveType primitiveType, uint vertexStart, uint vertexCount);
  public virtual void DrawPrimitives (MTLPrimitiveType primitiveType, uint vertexStart, uint vertexCount, uint instanceCount);
  public virtual void SetBlendColor (float red, float green, float blue, float alpha);
  public virtual void SetCullMode (MTLCullMode cullMode);
  public virtual void SetDepthBias (float depthBias, float slopeScale, float clamp);
  public virtual void SetDepthClipMode (MTLDepthClipMode depthClipMode);
  public virtual void SetDepthStencilState (IMTLDepthStencilState depthStencilState);
  public virtual void SetFragmentBuffer (IMTLBuffer buffer, uint offset, uint index);
  public virtual void SetFragmentSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
  public virtual void SetFragmentSamplerState (IMTLSamplerState sampler, uint index);
  public virtual void SetFragmentTexture (IMTLTexture texture, uint index);
  public virtual void SetFrontFacingWinding (MTLWinding frontFacingWinding);
  public virtual void SetRenderPipelineState (IMTLRenderPipelineState pipelineState);
  public virtual void SetScissorRect (MTLScissorRect rect);
  public virtual void SetStencilReferenceValue (uint referenceValue);
  public virtual void SetTriangleFillMode (MTLTriangleFillMode fillMode);
  public virtual void SetVertexBuffer (IMTLBuffer buffer, uint offset, uint index);
  public virtual void SetVertexSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
  public virtual void SetVertexSamplerState (IMTLSamplerState sampler, uint index);
  public virtual void SetVertexTexture (IMTLTexture texture, uint index);
  public virtual void SetViewport (MTLViewport viewport);
  public virtual void SetVisibilityResultMode (MTLVisibilityResultMode mode, uint offset);
}

New Type MonoTouch.Metal.IMTLRenderPipelineState

public interface IMTLRenderPipelineState : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; }
}

New Type MonoTouch.Metal.IMTLResource

public interface IMTLResource : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual MTLCpuCacheMode CpuCacheMode { get; }
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; set; }
  // methods
  public virtual MTLPurgeableState SetPurgeableState (MTLPurgeableState state);
}

New Type MonoTouch.Metal.IMTLSamplerState

public interface IMTLSamplerState : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // properties
  public virtual IMTLDevice Device { get; }
  public virtual string Label { get; }
}

New Type MonoTouch.Metal.IMTLTexture

public interface IMTLTexture : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLResource {
  // properties
  public virtual uint ArrayLength { get; }
  public virtual uint Depth { get; }
  public virtual bool FramebufferOnly { get; }
  public virtual uint Height { get; }
  public virtual uint MipmapLevelCount { get; }
  public virtual MTLPixelFormat PixelFormat { get; }
  public virtual IMTLResource RootResource { get; }
  public virtual uint SampleCount { get; }
  public virtual MTLTextureType TextureType { get; }
  public virtual uint Width { get; }
  // methods
  public virtual void CopyFromPixels (System.IntPtr pixels, uint rowBytes, uint imageBytes, uint slice, uint mipmapLevel, MTLOrigin origin, MTLSize size);
  public virtual void CopyFromSlice (uint slice, uint mipmapLevel, MTLOrigin origin, MTLSize size, System.IntPtr destination, uint rowBytes, uint imageBytes);
  public virtual IMTLTexture CreateTextureView (MTLPixelFormat pixelFormat);
}

New Type MonoTouch.Metal.MTLArgumentType

[Serializable]
public enum MTLArgumentType {
  Buffer = 0,
  LocalMemory = 2,
  ReadWriteBuffer = 1,
  ReadWriteTexture = 4,
  Sampler = 5,
  Texture = 3,
}

New Type MonoTouch.Metal.MTLAttachmentDescriptor

public class MTLAttachmentDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLAttachmentDescriptor ();
  public MTLAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLAttachmentDescriptor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MTLClearValue ClearValue { get; set; }
  public virtual uint DepthPlane { get; set; }
  public virtual uint Level { get; set; }
  public virtual MTLLoadAction LoadAction { get; set; }
  public virtual uint ResolveDepthPlane { get; set; }
  public virtual uint ResolveLevel { get; set; }
  public virtual uint ResolveSlice { get; set; }
  public virtual IMTLTexture ResolveTexture { get; set; }
  public virtual uint Slice { get; set; }
  public virtual MTLStoreAction StoreAction { get; set; }
  public virtual IMTLTexture Texture { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static MTLAttachmentDescriptor CreateAttachmentDescriptor ();
  public static MTLAttachmentDescriptor CreateAttachmentDescriptor (IMTLTexture texture);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLBlendDescriptor

public class MTLBlendDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLBlendDescriptor ();
  public MTLBlendDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLBlendDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLBlendDescriptor (System.IntPtr handle);
  // properties
  public virtual MTLBlendOperation AlphaBlendOperation { get; set; }
  public virtual bool BlendingEnabled { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MTLBlendFactor DestinationAlphaBlendFactor { get; set; }
  public virtual MTLBlendFactor DestinationRgbBlendFactor { get; set; }
  public virtual MTLBlendOperation RgbBlendOperation { get; set; }
  public virtual MTLBlendFactor SourceAlphaBlendFactor { get; set; }
  public virtual MTLBlendFactor SourceRgbBlendFactor { get; set; }
  public virtual MTLColorWriteMask WriteMask { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static MTLBlendDescriptor Create ();
  public static MTLBlendDescriptor Create (MTLBlendFactor sourceFactor, MTLBlendFactor destinationFactor);
}

New Type MonoTouch.Metal.MTLBlendFactor

[Serializable]
public enum MTLBlendFactor {
  BlendAlpha = 13,
  BlendColor = 11,
  DestinationAlpha = 8,
  DestinationColor = 6,
  One = 1,
  OneMinusBlendAlpha = 14,
  OneMinusBlendColor = 12,
  OneMinusDestinationAlpha = 9,
  OneMinusDestinationColor = 7,
  OneMinusSourceAlpha = 5,
  OneMinusSourceColor = 3,
  SourceAlpha = 4,
  SourceAlphaSaturated = 10,
  SourceColor = 2,
  Zero = 0,
}

New Type MonoTouch.Metal.MTLBlendOperation

[Serializable]
public enum MTLBlendOperation {
  Add = 0,
  Max = 4,
  Min = 3,
  ReverseSubtract = 2,
  Subtract = 1,
}

New Type MonoTouch.Metal.MTLBlitCommandEncoder_Extensions

public static class MTLBlitCommandEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLBuffer_Extensions

public static class MTLBuffer_Extensions {
}

New Type MonoTouch.Metal.MTLClearColor

public struct MTLClearColor {
  // constructors
  public MTLClearColor (double red, double green, double blue, double alpha);
  // fields
  public double Alpha;
  public double Blue;
  public double Green;
  public double Red;
}

New Type MonoTouch.Metal.MTLClearValue

public struct MTLClearValue {
  // constructors
  public MTLClearValue (MTLClearColor color);
  public MTLClearValue (double depth);
  public MTLClearValue (ulong stencil);
  // fields
  public MTLClearColor Color;
  public double Depth;
  public ulong Stencil;
}

New Type MonoTouch.Metal.MTLColorWriteMask

[Serializable]
[Flags]
public enum MTLColorWriteMask {
  All = 15,
  Alpha = 1,
  Blue = 2,
  Green = 4,
  None = 0,
  Red = 8,
}

New Type MonoTouch.Metal.MTLCommandBuffer_Extensions

public static class MTLCommandBuffer_Extensions {
}

New Type MonoTouch.Metal.MTLCommandBufferError

[Serializable]
public enum MTLCommandBufferError {
  Blacklisted = 4,
  Internal = 1,
  InvalidResource = 9,
  None = 0,
  NotPermitted = 7,
  OutOfMemory = 8,
  PageFault = 3,
  Timeout = 2,
}

New Type MonoTouch.Metal.MTLCommandBufferStatus

[Serializable]
public enum MTLCommandBufferStatus {
  Committed = 2,
  Completed = 4,
  Enqueued = 1,
  Error = 5,
  NotEnqueued = 0,
  Scheduled = 3,
}

New Type MonoTouch.Metal.MTLCommandEncoder_Extensions

public static class MTLCommandEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLCommandQueue_Extensions

public static class MTLCommandQueue_Extensions {
}

New Type MonoTouch.Metal.MTLCompareFunction

[Serializable]
public enum MTLCompareFunction {
  Always = 7,
  Equal = 2,
  Greater = 4,
  GreaterEqual = 6,
  Less = 1,
  LessEqual = 3,
  Never = 0,
  NotEqual = 5,
}

New Type MonoTouch.Metal.MTLCompileOptions

public class MTLCompileOptions : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLCompileOptions ();
  public MTLCompileOptions (MonoTouch.Foundation.NSCoder coder);
  public MTLCompileOptions (MonoTouch.Foundation.NSObjectFlag t);
  public MTLCompileOptions (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool FastMathEnabled { get; set; }
  public virtual MonoTouch.Foundation.NSDictionary PreprocessorMacros { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLComputeCommandEncoder_Extensions

public static class MTLComputeCommandEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLComputePipelineState_Extensions

public static class MTLComputePipelineState_Extensions {
}

New Type MonoTouch.Metal.MTLCpuCacheMode

[Serializable]
public enum MTLCpuCacheMode {
  DefaultCache = 0,
  WriteCombined = 1,
}

New Type MonoTouch.Metal.MTLCullMode

[Serializable]
public enum MTLCullMode {
  Back = 2,
  Front = 1,
  None = 0,
}

New Type MonoTouch.Metal.MTLDeallocator

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

New Type MonoTouch.Metal.MTLDepthClipMode

[Serializable]
public enum MTLDepthClipMode {
  Clamp = 1,
  Clip = 0,
}

New Type MonoTouch.Metal.MTLDepthStencilDescriptor

public class MTLDepthStencilDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLDepthStencilDescriptor ();
  public MTLDepthStencilDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLDepthStencilDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLDepthStencilDescriptor (System.IntPtr handle);
  // properties
  public virtual MTLStencilDescriptor BackFaceStencilDescriptor { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MTLCompareFunction DepthCompareFunction { get; set; }
  public virtual bool DepthWriteEnabled { get; set; }
  public virtual MTLStencilDescriptor FrontFaceStencilDescriptor { get; set; }
  public virtual string Label { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLDepthStencilState_Extensions

public static class MTLDepthStencilState_Extensions {
}

New Type MonoTouch.Metal.MTLDevice

public class MTLDevice {
  // constructors
  public MTLDevice ();
  // properties
  public static IMTLDevice SystemDefault { get; }
}

New Type MonoTouch.Metal.MTLDevice_Extensions

public static class MTLDevice_Extensions {
}

New Type MonoTouch.Metal.MTLDrawable_Extensions

public static class MTLDrawable_Extensions {
}

New Type MonoTouch.Metal.MTLFramebuffer_Extensions

public static class MTLFramebuffer_Extensions {
}

New Type MonoTouch.Metal.MTLFramebufferAttachmentIndex

[Serializable]
public enum MTLFramebufferAttachmentIndex {
  Color0 = 0,
  Color1 = 1,
  Color2 = 2,
  Color3 = 3,
  Depth = 512,
  Stencil = 1024,
}

New Type MonoTouch.Metal.MTLFramebufferDescriptor

public class MTLFramebufferDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLFramebufferDescriptor ();
  public MTLFramebufferDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLFramebufferDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLFramebufferDescriptor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual IMTLBuffer VisibilityResultBuffer { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual MTLAttachmentDescriptor CopyAttachment (MTLFramebufferAttachmentIndex index);
  public static MTLFramebufferDescriptor Create ();
  public static MTLFramebufferDescriptor Create (MTLAttachmentDescriptor colorAttachment);
  public static MTLFramebufferDescriptor Create (MTLAttachmentDescriptor colorAttachment, MTLAttachmentDescriptor depthAttachment, MTLAttachmentDescriptor stencilAttachment);
  protected override void Dispose (bool disposing);
  public virtual void SetAttachment (MTLAttachmentDescriptor attachmentDescriptor, MTLFramebufferAttachmentIndex index);
}

New Type MonoTouch.Metal.MTLFunction_Extensions

public static class MTLFunction_Extensions {
}

New Type MonoTouch.Metal.MTLFunctionArgument_Extensions

public static class MTLFunctionArgument_Extensions {
}

New Type MonoTouch.Metal.MTLFunctionType

[Serializable]
public enum MTLFunctionType {
  Fragment = 2,
  Kernel = 3,
  Vertex = 1,
}

New Type MonoTouch.Metal.MTLIndexType

[Serializable]
public enum MTLIndexType {
  UInt16 = 0,
  UInt32 = 1,
}

New Type MonoTouch.Metal.MTLLibrary_Extensions

public static class MTLLibrary_Extensions {
}

New Type MonoTouch.Metal.MTLLibraryError

[Serializable]
public enum MTLLibraryError {
  CompileFailure = 3,
  CompileWarning = 4,
  Internal = 2,
  Unsupported = 1,
}

New Type MonoTouch.Metal.MTLLoadAction

[Serializable]
public enum MTLLoadAction {
  Clear = 2,
  DontCare = 0,
  Load = 1,
}

New Type MonoTouch.Metal.MTLOrigin

public struct MTLOrigin {
  // constructors
  public MTLOrigin (int x, int y, int z);
  // fields
  public int X;
  public int Y;
  public int Z;
  // methods
  public override string ToString ();
}

New Type MonoTouch.Metal.MTLParallelRenderPassEncoder_Extensions

public static class MTLParallelRenderPassEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLPixelFormat

[Serializable]
public enum MTLPixelFormat {
  A2BGR10Uint = 91,
  A2BGR10Unorm = 90,
  B10GR11Float = 92,
  BGRA8Unorm = 80,
  BGRA8Unorm_sRGB = 81,
  Depth32Float = 252,
  EAC_R11Snorm = 172,
  EAC_R11Unorm = 170,
  EAC_RG11Snorm = 176,
  EAC_RG11Unorm = 174,
  EAC_RGBA8 = 178,
  EAC_RGBA8_sRGB = 179,
  ETC2_RGB8 = 180,
  ETC2_RGB8_sRGB = 181,
  ETC2_RGB8A1 = 182,
  ETC2_RGB8A1_sRGB = 183,
  Invalid = 0,
  k422_BGRG = 241,
  k422_GBGR = 240,
  PVRTC_RGB_2BPP = 160,
  PVRTC_RGB_2BPP_sRGB = 161,
  PVRTC_RGB_4BPP = 162,
  PVRTC_RGB_4BPP_sRGB = 163,
  PVRTC_RGBA_2BPP = 164,
  PVRTC_RGBA_2BPP_sRGB = 165,
  PVRTC_RGBA_4BPP = 166,
  PVRTC_RGBA_4BPP_sRGB = 167,
  R16Float = 25,
  R16Sint = 24,
  R16Snorm = 22,
  R16Uint = 23,
  R16Unorm = 20,
  R32Float = 55,
  R32Sint = 54,
  R32Uint = 53,
  R8Sint = 14,
  R8Snorm = 12,
  R8Uint = 13,
  R8Unorm = 10,
  R8Unorm_sRGB = 11,
  RG16Float = 65,
  RG16Sint = 64,
  RG16Snorm = 62,
  RG16Uint = 63,
  RG16Unorm = 60,
  RG32Float = 105,
  RG32Sint = 104,
  RG32Uint = 103,
  RG8Sint = 34,
  RG8Snorm = 32,
  RG8Uint = 33,
  RG8Unorm = 30,
  RG8Unorm_sRGB = 31,
  RGB565Unorm = 40,
  RGB5A1Unorm = 41,
  RGBA16Float = 115,
  RGBA16Sint = 114,
  RGBA16Snorm = 112,
  RGBA16Uint = 113,
  RGBA16Unorm = 110,
  RGBA32Float = 125,
  RGBA32Sint = 124,
  RGBA32Uint = 123,
  RGBA4Unorm = 42,
  RGBA8Sint = 74,
  RGBA8Snorm = 72,
  RGBA8Uint = 73,
  RGBA8Unorm = 70,
  RGBA8Unorm_sRGB = 71,
  SE5BGR9Float = 93,
  Stencil8 = 253,
}

New Type MonoTouch.Metal.MTLPrimitiveType

[Serializable]
public enum MTLPrimitiveType {
  Line = 1,
  LineStrip = 2,
  Point = 0,
  Triangle = 3,
  TriangleStrip = 4,
}

New Type MonoTouch.Metal.MTLPurgeableState

[Serializable]
public enum MTLPurgeableState {
  Empty = 4,
  KeepCurrent = 1,
  NonVolatile = 2,
  Volatile = 3,
}

New Type MonoTouch.Metal.MTLRenderCommandEncoder_Extensions

public static class MTLRenderCommandEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLRenderPipelineDescriptor

public class MTLRenderPipelineDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLRenderPipelineDescriptor ();
  public MTLRenderPipelineDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLRenderPipelineDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLRenderPipelineDescriptor (System.IntPtr handle);
  // properties
  public virtual bool AlphaToCoverageEnabled { get; set; }
  public virtual bool AlphaToOneEnabled { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool DepthWriteEnabled { get; set; }
  public virtual IMTLFunction FragmentFunction { get; set; }
  public virtual string Label { get; set; }
  public virtual uint SampleCount { get; set; }
  public virtual float SampleCoverage { get; set; }
  public virtual uint SampleMask { get; set; }
  public virtual bool StencilWriteEnabled { get; set; }
  public virtual MTLVertexDescriptor VertexDescriptor { get; set; }
  public virtual IMTLFunction VertexFunction { get; set; }
  public virtual bool VisibilityResultEnabled { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual MTLBlendDescriptor CopyBlendDescriptor (MTLFramebufferAttachmentIndex index);
  protected override void Dispose (bool disposing);
  public virtual MTLPixelFormat GetPixelFormat (MTLFramebufferAttachmentIndex index);
  public virtual void Reset ();
  public virtual void SetBlendDescriptor (MTLBlendDescriptor blendDescriptor, MTLFramebufferAttachmentIndex index);
  public virtual void SetPixelFormat (MTLPixelFormat pixelFormat, MTLFramebufferAttachmentIndex index);
}

New Type MonoTouch.Metal.MTLRenderPipelineError

[Serializable]
public enum MTLRenderPipelineError {
  Internal = 1,
  InvalidInput = 3,
  Unsupported = 2,
}

New Type MonoTouch.Metal.MTLRenderPipelineState_Extensions

public static class MTLRenderPipelineState_Extensions {
}

New Type MonoTouch.Metal.MTLResource_Extensions

public static class MTLResource_Extensions {
}

New Type MonoTouch.Metal.MTLResourceOptions

[Serializable]
[Flags]
public enum MTLResourceOptions {
  CpuCacheModeDefault = 0,
  CpuCacheModeWriteCombined = 1,
}

New Type MonoTouch.Metal.MTLSamplerAddressMode

[Serializable]
public enum MTLSamplerAddressMode {
  ClampToEdge = 0,
  ClampToZero = 4,
  MirrorRepeat = 3,
  Repeat = 2,
}

New Type MonoTouch.Metal.MTLSamplerDescriptor

public class MTLSamplerDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLSamplerDescriptor ();
  public MTLSamplerDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLSamplerDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLSamplerDescriptor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Label { get; set; }
  public virtual float LodMaxClamp { get; set; }
  public virtual float LodMinClamp { get; set; }
  public virtual MTLSamplerMinMagFilter MagFilter { get; set; }
  public virtual uint MaxAnisotropy { get; set; }
  public virtual MTLSamplerMinMagFilter MinFilter { get; set; }
  public virtual MTLSamplerMipFilter MipFilter { get; set; }
  public virtual bool NormalizedCoordinates { get; set; }
  public virtual MTLSamplerAddressMode RAddressMode { get; set; }
  public virtual MTLSamplerAddressMode SAddressMode { get; set; }
  public virtual MTLSamplerAddressMode TAddressMode { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Metal.MTLSamplerMinMagFilter

[Serializable]
public enum MTLSamplerMinMagFilter {
  Linear = 1,
  Nearest = 0,
}

New Type MonoTouch.Metal.MTLSamplerMipFilter

[Serializable]
public enum MTLSamplerMipFilter {
  Linear = 2,
  Nearest = 1,
  NotMipmapped = 0,
}

New Type MonoTouch.Metal.MTLSamplerState_Extensions

public static class MTLSamplerState_Extensions {
}

New Type MonoTouch.Metal.MTLScissorRect

public struct MTLScissorRect {
  // constructors
  public MTLScissorRect (uint x, uint y, uint width, uint height);
  // fields
  public uint Height;
  public uint Width;
  public uint X;
  public uint Y;
  // methods
  public override string ToString ();
}

New Type MonoTouch.Metal.MTLSize

public struct MTLSize {
  // constructors
  public MTLSize (int width, int height, int depth);
  // fields
  public int Depth;
  public int Height;
  public int Width;
}

New Type MonoTouch.Metal.MTLStencilDescriptor

public class MTLStencilDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLStencilDescriptor ();
  public MTLStencilDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLStencilDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLStencilDescriptor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MTLStencilOperation DepthFailureOperation { get; set; }
  public virtual MTLStencilOperation DepthStencilPassOperation { get; set; }
  public virtual uint ReadMask { get; set; }
  public virtual MTLCompareFunction StencilCompareFunction { get; set; }
  public virtual MTLStencilOperation StencilFailureOperation { get; set; }
  public virtual uint WriteMask { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Metal.MTLStencilOperation

[Serializable]
public enum MTLStencilOperation {
  DecrementClamp = 4,
  DecrementWrap = 7,
  IncrementClamp = 3,
  IncrementWrap = 6,
  Invert = 5,
  Keep = 0,
  Replace = 2,
  Zero = 1,
}

New Type MonoTouch.Metal.MTLStoreAction

[Serializable]
public enum MTLStoreAction {
  DontCare = 0,
  MultisampleResolve = 2,
  Store = 1,
}

New Type MonoTouch.Metal.MTLTexture_Extensions

public static class MTLTexture_Extensions {
}

New Type MonoTouch.Metal.MTLTextureDescriptor

public abstract class MTLTextureDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLTextureDescriptor ();
  public MTLTextureDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLTextureDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLTextureDescriptor (System.IntPtr handle);
  // properties
  public virtual uint ArrayLength { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual uint Depth { get; set; }
  public virtual uint Height { get; set; }
  public virtual uint MipmapLevelCount { get; set; }
  public virtual MTLPixelFormat PixelFormat { get; set; }
  public virtual MTLResourceOptions ResourceOptions { get; set; }
  public virtual uint SampleCount { get; set; }
  public virtual MTLTextureType TextureType { get; set; }
  public virtual uint Width { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static MTLTextureDescriptor CreateTexture2DDescriptor (MTLPixelFormat pixelFormat, uint width, uint height, bool mipmapped);
  public static MTLTextureDescriptor CreateTextureCubeDescriptor (MTLPixelFormat pixelFormat, uint size, bool mipmapped);
}

New Type MonoTouch.Metal.MTLTextureType

[Serializable]
public enum MTLTextureType {
  k1D = 0,
  k1DArray = 1,
  k2D = 2,
  k2DArray = 3,
  k2DMultisample = 4,
  k3D = 6,
  kCube = 5,
}

New Type MonoTouch.Metal.MTLTriangleFillMode

[Serializable]
public enum MTLTriangleFillMode {
  Fill = 0,
  Lines = 1,
}

New Type MonoTouch.Metal.MTLVertexDescriptor

public class MTLVertexDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public MTLVertexDescriptor ();
  public MTLVertexDescriptor (MonoTouch.Foundation.NSCoder coder);
  public MTLVertexDescriptor (MonoTouch.Foundation.NSObjectFlag t);
  public MTLVertexDescriptor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static MTLVertexDescriptor Create ();
  public virtual uint GetInstanceStepRate (uint vertexBufferIndex);
  public virtual uint GetOffset (uint attributeIndex);
  public virtual uint GetStride (uint vertexBufferIndex);
  public virtual uint GetVertexBufferIndex (uint attributeIndex);
  public virtual MTLVertexFormat GetVertexFormat (uint attributeIndex);
  public virtual void Reset ();
  public virtual void SetStride (uint stride, uint instanceStepRate, uint vertexBufferIndex);
  public virtual void SetVertexFormat (MTLVertexFormat vertexFormat, uint offset, uint vertexBufferIndex, uint attributeIndex);
}

New Type MonoTouch.Metal.MTLVertexFormat

[Serializable]
public enum MTLVertexFormat {
  Float = 28,
  Float2 = 29,
  Float3 = 30,
  Float4 = 31,
  FormatInt = 32,
  FormatInt2 = 33,
  FormatInt2101010Normalized = 40,
  FormatInt3 = 34,
  FormatInt4 = 35,
  FormatUInt = 36,
  FormatUInt2 = 37,
  FormatUInt2101010Normalized = 41,
  FormatUInt3 = 38,
  FormatUInt4 = 39,
  Half2 = 25,
  Half3 = 26,
  Half4 = 27,
  Invalid = 0,
  SChar2 = 4,
  SChar2Normalized = 10,
  SChar3 = 5,
  SChar3Normalized = 11,
  SChar4 = 6,
  SChar4Normalized = 12,
  Short2 = 16,
  Short2Normalized = 22,
  Short3 = 17,
  Short3Normalized = 23,
  Short4 = 18,
  Short4Normalized = 24,
  UChar2 = 1,
  UChar2Normalized = 7,
  UChar3 = 2,
  UChar3Normalized = 8,
  UChar4 = 3,
  UChar4Normalized = 9,
  UShort2 = 13,
  UShort2Normalized = 19,
  UShort3 = 14,
  UShort3Normalized = 20,
  UShort4 = 15,
  UShort4Normalized = 21,
}

New Type MonoTouch.Metal.MTLViewport

public struct MTLViewport {
  // constructors
  public MTLViewport (double originX, double originY, double width, double height, double znear, double zfar);
  // fields
  public double Height;
  public double OriginX;
  public double OriginY;
  public double Width;
  public double ZFar;
  public double ZNear;
  // methods
  public override string ToString ();
}

New Type MonoTouch.Metal.MTLVisibilityResultMode

[Serializable]
public enum MTLVisibilityResultMode {
  Boolean = 1,
  Disabled = 0,
}

New Type MonoTouch.Metal.MTLWinding

[Serializable]
public enum MTLWinding {
  Clockwise = 0,
  CounterClockwise = 1,
}

New Namespace MonoTouch.NotificationCenter

New Type MonoTouch.NotificationCenter.INCWidgetProviding

public interface INCWidgetProviding : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.NotificationCenter.NCUpdateResult

[Serializable]
public enum NCUpdateResult {
  Failed = 2,
  NewData = 0,
  NoData = 1,
}

New Type MonoTouch.NotificationCenter.NCWidgetController

public class NCWidgetController : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NCWidgetController ();
  public NCWidgetController (MonoTouch.Foundation.NSCoder coder);
  public NCWidgetController (MonoTouch.Foundation.NSObjectFlag t);
  public NCWidgetController (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual void SetHasContent (bool flag, string bundleID);
  public static NCWidgetController WidgetController ();
}

New Type MonoTouch.NotificationCenter.NCWidgetProviding

public class NCWidgetProviding : MonoTouch.Foundation.NSObject, INCWidgetProviding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public NCWidgetProviding ();
  public NCWidgetProviding (MonoTouch.Foundation.NSCoder coder);
  public NCWidgetProviding (MonoTouch.Foundation.NSObjectFlag t);
  public NCWidgetProviding (System.IntPtr handle);
  // methods
  public virtual MonoTouch.UIKit.UIEdgeInsets GetWidgetMarginInsets (MonoTouch.UIKit.UIEdgeInsets defaultMarginInsets);
  public virtual void WidgetPerformUpdate (System.Action<NCUpdateResult> completionHandler);
}

New Type MonoTouch.NotificationCenter.NCWidgetProviding_Extensions

public static class NCWidgetProviding_Extensions {
  // methods
  public static MonoTouch.UIKit.UIEdgeInsets GetWidgetMarginInsets (INCWidgetProviding This, MonoTouch.UIKit.UIEdgeInsets defaultMarginInsets);
  public static void WidgetPerformUpdate (INCWidgetProviding This, System.Action<NCUpdateResult> completionHandler);
}

New Type MonoTouch.NotificationCenter.UIVibrancyEffect_NotificationCenter

public static class UIVibrancyEffect_NotificationCenter {
  // methods
  public static MonoTouch.UIKit.UIVibrancyEffect NotificationCenterVibrancyEffect (MonoTouch.UIKit.UIVibrancyEffect This);
}

New Namespace MonoTouch.Photos

New Type MonoTouch.Photos.IPHPhotoLibraryChangeObserver

public interface IPHPhotoLibraryChangeObserver : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.Photos.PHAdjustmentData

public class PHAdjustmentData : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHAdjustmentData ();
  public PHAdjustmentData (MonoTouch.Foundation.NSCoder coder);
  public PHAdjustmentData (MonoTouch.Foundation.NSObjectFlag t);
  public PHAdjustmentData (System.IntPtr handle);
  public PHAdjustmentData (string formatIdentifier, string formatVersion, MonoTouch.Foundation.NSData data);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData Data { get; }
  public virtual string FormatIdentifier { get; }
  public virtual string FormatVersion { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Photos.PHAsset

public class PHAsset : MonoTouch.Photos.PHObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHAsset ();
  public PHAsset (MonoTouch.Foundation.NSCoder coder);
  public PHAsset (MonoTouch.Foundation.NSObjectFlag t);
  public PHAsset (System.IntPtr handle);
  // properties
  public virtual PHAssetSource AssetSource { get; }
  public virtual string BurstIdentifier { get; }
  public virtual PHAssetBurstSelectionType BurstSelectionTypes { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string CloudIdentifier { get; }
  public virtual MonoTouch.Foundation.NSDate CreationDate { get; }
  public virtual double Duration { get; }
  public virtual bool Favorite { get; }
  public virtual bool Hidden { get; }
  public virtual MonoTouch.CoreLocation.CLLocation Location { get; }
  public virtual PHAssetMediaSubtype MediaSubtypes { get; }
  public virtual PHAssetMediaType MediaType { get; }
  public virtual MonoTouch.Foundation.NSDate ModificationDate { get; }
  public virtual uint PixelHeight { get; }
  public virtual uint PixelWidth { get; }
  public virtual bool RepresentsBurst { get; }
  // methods
  public virtual bool CanPerformEditOperation (PHAssetEditOperation editOperation);
  protected override void Dispose (bool disposing);
  public static PHFetchResult FetchAssets (PHAssetMediaType mediaType, PHFetchOptions options);
  public static PHFetchResult FetchAssets (MonoTouch.Foundation.NSUrl[] assetUrls, PHFetchOptions options);
  public static PHFetchResult FetchAssets (PHAssetCollection assetCollection, PHFetchOptions options);
  public static PHFetchResult FetchAssets (string burstIdentifier, PHFetchOptions options);
  public static PHFetchResult FetchAssets (PHFetchOptions options);
  public static PHFetchResult FetchAssetsUsingCloudIdentifiers (string[] identifiers, PHFetchOptions options);
  public static PHFetchResult FetchAssetsUsingLocalIdentifiers (string[] identifiers, PHFetchOptions options);
  public static PHFetchResult FetchKeyAssets (PHAssetCollection assetCollection, PHFetchOptions options);
}

New Type MonoTouch.Photos.PHAssetBurstSelectionType

[Serializable]
[Flags]
public enum PHAssetBurstSelectionType {
  AutoPick = 1,
  None = 0,
  UserPick = 2,
}

New Type MonoTouch.Photos.PHAssetChangeRequest

public class PHAssetChangeRequest : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHAssetChangeRequest ();
  public PHAssetChangeRequest (MonoTouch.Foundation.NSCoder coder);
  public PHAssetChangeRequest (MonoTouch.Foundation.NSObjectFlag t);
  public PHAssetChangeRequest (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHContentEditingOutput ContentEditingOutput { get; set; }
  public virtual MonoTouch.Foundation.NSDate CreationDate { get; set; }
  public virtual bool Favorite { get; set; }
  public virtual bool Hidden { get; set; }
  public virtual MonoTouch.CoreLocation.CLLocation Location { get; set; }
  public virtual PHObjectPlaceholder PlaceholderForCreatedAsset { get; }
  // methods
  public static PHAssetChangeRequest ChangeRequest (PHAsset asset);
  public static void DeleteAssets (PHAsset[] assets);
  protected override void Dispose (bool disposing);
  public static PHAssetChangeRequest FromImage (MonoTouch.UIKit.UIImage image);
  public static PHAssetChangeRequest FromImage (MonoTouch.Foundation.NSUrl fileUrl);
  public static PHAssetChangeRequest FromVideo (MonoTouch.Foundation.NSUrl fileUrl);
  public virtual void RevertAssetToOriginal ();
}

New Type MonoTouch.Photos.PHAssetCollection

public class PHAssetCollection : MonoTouch.Photos.PHCollection, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHAssetCollection ();
  public PHAssetCollection (MonoTouch.Foundation.NSCoder coder);
  public PHAssetCollection (MonoTouch.Foundation.NSObjectFlag t);
  public PHAssetCollection (System.IntPtr handle);
  // properties
  public virtual MonoTouch.CoreLocation.CLLocation ApproximateLocation { get; }
  public virtual PHAssetCollectionSubtype AssetCollectionSubtype { get; }
  public virtual PHAssetCollectionType AssetCollectionType { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate EndDate { get; }
  public virtual uint EstimatedAssetCount { get; }
  public virtual string[] LocalizedLocationNames { get; }
  public virtual MonoTouch.Foundation.NSDate StartDate { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static PHFetchResult FetchAssetCollections (string[] identifiers, PHFetchOptions options);
  public static PHFetchResult FetchAssetCollections (MonoTouch.Foundation.NSUrl[] assetGroupUrls, PHFetchOptions options);
  public static PHFetchResult FetchAssetCollections (PHAsset asset, PHAssetCollectionType type, PHFetchOptions options);
  public static PHFetchResult FetchAssetCollections (PHAssetCollectionType type, PHAssetCollectionSubtype subtype, PHFetchOptions options);
  public static PHFetchResult FetchMoments (PHFetchOptions options);
  public static PHFetchResult FetchMoments (PHCollectionList momentList, PHFetchOptions options);
  public static PHAssetCollection GetTransientAssetCollection (PHAsset[] assets, string title);
  public static PHAssetCollection GetTransientAssetCollection (PHFetchResult fetchResult, string title);
}

New Type MonoTouch.Photos.PHAssetCollectionChangeRequest

public class PHAssetCollectionChangeRequest : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHAssetCollectionChangeRequest (MonoTouch.Foundation.NSCoder coder);
  public PHAssetCollectionChangeRequest (MonoTouch.Foundation.NSObjectFlag t);
  public PHAssetCollectionChangeRequest (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHObjectPlaceholder PlaceholderForCreatedAssetCollection { get; }
  public virtual string Title { get; set; }
  // methods
  public virtual void AddAssets (PHAsset[] assets);
  public static PHAssetCollectionChangeRequest ChangeRequest (PHAssetCollection assetCollection);
  public static PHAssetCollectionChangeRequest ChangeRequest (PHAssetCollection assetCollection, PHFetchResult assets);
  public static PHAssetCollectionChangeRequest CreateAssetCollection (string assetCollectionTitle);
  public static void DeleteAssetCollections (PHAssetCollection[] assetCollections);
  protected override void Dispose (bool disposing);
  public virtual void InsertAssets (PHAsset[] assets, MonoTouch.Foundation.NSIndexSet indexes);
  public virtual void MoveAssets (MonoTouch.Foundation.NSIndexSet fromIndexes, uint toIndex);
  public virtual void RemoveAssets (PHAsset[] assets);
  public virtual void RemoveAssets (MonoTouch.Foundation.NSIndexSet indexes);
  public virtual void ReplaceAssets (MonoTouch.Foundation.NSIndexSet indexes, PHAsset[] assets);
}

New Type MonoTouch.Photos.PHAssetCollectionSubtype

[Serializable]
public enum PHAssetCollectionSubtype {
  AlbumCloudShared = 101,
  AlbumImported = 5,
  AlbumMyPhotoStream = 100,
  AlbumRegular = 2,
  AlbumSynced = 3,
  AlbumSyncedFaces = 4,
  Any = 2147483647,
  SmartAlbumAllHidden = 205,
  SmartAlbumFavorites = 203,
  SmartAlbumGeneric = 200,
  SmartAlbumPanoramas = 201,
  SmartAlbumRecentlyAdded = 206,
  SmartAlbumTimelapses = 204,
  SmartAlbumVideos = 202,
}

New Type MonoTouch.Photos.PHAssetCollectionType

[Serializable]
public enum PHAssetCollectionType {
  Album = 1,
  Moment = 3,
  SmartAlbum = 2,
}

New Type MonoTouch.Photos.PHAssetContentEditingInputExtensions

public static class PHAssetContentEditingInputExtensions {
  // methods
  public static void CancelContentEditingInputRequest (PHAsset This, uint requestID);
  public static uint RequestContentEditingInput (PHAsset This, PHContentEditingInputRequestOptions options, PHContentEditingHandler completionHandler);
}

New Type MonoTouch.Photos.PHAssetEditOperation

[Serializable]
[Flags]
public enum PHAssetEditOperation {
  Content = 2,
  Delete = 1,
  None = 0,
  Properties = 4,
}

New Type MonoTouch.Photos.PHAssetImageProgressHandler

public sealed delegate PHAssetImageProgressHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHAssetImageProgressHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (bool degraded, double progress, MonoTouch.Foundation.NSError error, out bool stop, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (out bool stop, System.IAsyncResult result);
  public virtual void Invoke (bool degraded, double progress, MonoTouch.Foundation.NSError error, out bool stop);
}

New Type MonoTouch.Photos.PHAssetMediaSubtype

[Serializable]
[Flags]
public enum PHAssetMediaSubtype {
  None = 0,
  PhotoHDR = 2,
  PhotoPanorama = 1,
  VideoHighFrameRate = 131072,
  VideoStreamed = 65536,
  VideoTimelapse = 262144,
}

New Type MonoTouch.Photos.PHAssetMediaType

[Serializable]
public enum PHAssetMediaType {
  Audio = 3,
  Image = 1,
  Unknown = 0,
  Video = 2,
}

New Type MonoTouch.Photos.PHAssetSource

[Serializable]
public enum PHAssetSource {
  Camera = 3,
  CameraConnectionKit = 5,
  CloudPhotoLibrary = 6,
  CloudShared = 4,
  iTunesSync = 256,
  PhotoBooth = 1,
  PhotoStream = 2,
  Unknown = 0,
}

New Type MonoTouch.Photos.PHAssetVideoProgressHandler

public sealed delegate PHAssetVideoProgressHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHAssetVideoProgressHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (double progress, MonoTouch.Foundation.NSError error, out bool stop, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (out bool stop, System.IAsyncResult result);
  public virtual void Invoke (double progress, MonoTouch.Foundation.NSError error, out bool stop);
}

New Type MonoTouch.Photos.PHCachingImageManager

public class PHCachingImageManager : MonoTouch.Photos.PHImageManager, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHCachingImageManager ();
  public PHCachingImageManager (MonoTouch.Foundation.NSCoder coder);
  public PHCachingImageManager (MonoTouch.Foundation.NSObjectFlag t);
  public PHCachingImageManager (System.IntPtr handle);
  // properties
  public virtual bool AllowsCachingHighQualityImages { get; set; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual void StartCaching (PHAsset[] assets, System.Drawing.SizeF targetSize, PHImageContentMode contentMode, PHImageRequestOptions options);
  public virtual void StopCaching (PHAsset[] assets, System.Drawing.SizeF targetSize, PHImageContentMode contentMode, PHImageRequestOptions options);
  public virtual void StopCaching ();
}

New Type MonoTouch.Photos.PHChange

public class PHChange : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHChange ();
  public PHChange (MonoTouch.Foundation.NSCoder coder);
  public PHChange (MonoTouch.Foundation.NSObjectFlag t);
  public PHChange (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual PHFetchResultChangeDetails GetFetchResultChangeDetails (PHFetchResult obj);
  public virtual PHObjectChangeDetails GetObjectChangeDetails (PHObject obj);
}

New Type MonoTouch.Photos.PHChangeDetailEnumerator

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

New Type MonoTouch.Photos.PHCollection

public class PHCollection : MonoTouch.Photos.PHObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHCollection (MonoTouch.Foundation.NSCoder coder);
  public PHCollection (MonoTouch.Foundation.NSObjectFlag t);
  public PHCollection (System.IntPtr handle);
  // properties
  public virtual bool CanContainAssets { get; }
  public virtual bool CanContainCollections { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string LocalizedTitle { get; }
  // methods
  public virtual bool CanPerformEditOperation (PHCollectionEditOperation anOperation);
  public static PHFetchResult FetchCollections (PHCollectionList collectionList, PHFetchOptions options);
  public static PHFetchResult FetchTopLevelUserCollections (PHFetchOptions options);
}

New Type MonoTouch.Photos.PHCollectionEditOperation

[Serializable]
[Flags]
public enum PHCollectionEditOperation {
  AddContent = 4,
  CreateContent = 8,
  Delete = 32,
  DeleteContent = 1,
  None = 0,
  RearrangeContent = 16,
  RemoveContent = 2,
  Rename = 64,
}

New Type MonoTouch.Photos.PHCollectionList

public class PHCollectionList : MonoTouch.Photos.PHCollection, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHCollectionList ();
  public PHCollectionList (MonoTouch.Foundation.NSCoder coder);
  public PHCollectionList (MonoTouch.Foundation.NSObjectFlag t);
  public PHCollectionList (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHCollectionListType CollectionListType { get; }
  public virtual MonoTouch.Foundation.NSDate EndDate { get; }
  public virtual string[] LocalizedLocationNames { get; }
  public virtual MonoTouch.Foundation.NSDate StartDate { get; }
  // methods
  public static PHCollectionList CreateTransientCollectionList (PHAssetCollection[] collections, string title);
  public static PHCollectionList CreateTransientCollectionList (PHFetchResult fetchResult, string title);
  protected override void Dispose (bool disposing);
  public static PHFetchResult FetchCollectionList (PHCollection collection, PHFetchOptions options);
  public static PHFetchResult FetchCollectionLists (PHCollectionListType collectionListType, PHFetchOptions options);
  public static PHFetchResult FetchCollectionLists (string[] identifiers, PHFetchOptions options);
  public static PHFetchResult FetchMomentLists (PHCollectionListType momentListType, PHAssetCollection moment, PHFetchOptions options);
  public static PHFetchResult FetchMomentLists (PHCollectionListType momentListType, PHFetchOptions options);
}

New Type MonoTouch.Photos.PHCollectionListChangeRequest

public class PHCollectionListChangeRequest : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHCollectionListChangeRequest (MonoTouch.Foundation.NSCoder coder);
  public PHCollectionListChangeRequest (MonoTouch.Foundation.NSObjectFlag t);
  public PHCollectionListChangeRequest (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHObjectPlaceholder PlaceholderForCreatedCollectionList { get; }
  public virtual string Title { get; set; }
  // methods
  public virtual void AddChildCollections (PHCollection[] collections);
  public static PHCollectionListChangeRequest ChangeRequest (PHCollectionList collectionList);
  public static PHCollectionListChangeRequest ChangeRequest (PHCollectionList collectionList, PHFetchResult childCollections);
  public static PHCollectionListChangeRequest CreateAssetCollection (string title);
  public static void DeleteCollectionLists (PHCollectionList[] collectionLists);
  protected override void Dispose (bool disposing);
  public virtual void InsertChildCollections (PHCollection[] collections, MonoTouch.Foundation.NSIndexSet indexes);
  public virtual void MoveChildCollections (MonoTouch.Foundation.NSIndexSet indexes, uint toIndex);
  public virtual void RemoveChildCollections (PHCollection[] collections);
  public virtual void RemoveChildCollections (MonoTouch.Foundation.NSIndexSet indexes);
  public virtual void ReplaceChildCollection (MonoTouch.Foundation.NSIndexSet indexes, PHCollection[] collections);
}

New Type MonoTouch.Photos.PHCollectionListType

[Serializable]
public enum PHCollectionListType {
  Folder = 3,
  MomentCluster = 1,
  MomentYear = 2,
}

New Type MonoTouch.Photos.PHContentEditingHandler

public sealed delegate PHContentEditingHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHContentEditingHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (PHContentEditingInput contentEditingInput, MonoTouch.Foundation.NSDictionary requestStatusInfo, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (PHContentEditingInput contentEditingInput, MonoTouch.Foundation.NSDictionary requestStatusInfo);
}

New Type MonoTouch.Photos.PHContentEditingInput

public class PHContentEditingInput : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHContentEditingInput ();
  public PHContentEditingInput (MonoTouch.Foundation.NSCoder coder);
  public PHContentEditingInput (MonoTouch.Foundation.NSObjectFlag t);
  public PHContentEditingInput (System.IntPtr handle);
  // properties
  public virtual PHAdjustmentData AdjustmentData { get; }
  public virtual MonoTouch.AVFoundation.AVAsset AvAsset { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDate CreationDate { get; }
  public virtual MonoTouch.UIKit.UIImage DisplaySizeImage { get; }
  public virtual int FullSizeImageOrientation { get; }
  public virtual MonoTouch.Foundation.NSUrl FullSizeImageUrl { get; }
  public virtual MonoTouch.CoreLocation.CLLocation Location { get; }
  public virtual PHAssetMediaSubtype MediaSubtypes { get; }
  public virtual PHAssetMediaType MediaType { get; }
  public virtual string UniformTypeIdentifier { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Photos.PHContentEditingInputRequestOptions

public class PHContentEditingInputRequestOptions : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHContentEditingInputRequestOptions ();
  public PHContentEditingInputRequestOptions (MonoTouch.Foundation.NSCoder coder);
  public PHContentEditingInputRequestOptions (MonoTouch.Foundation.NSObjectFlag t);
  public PHContentEditingInputRequestOptions (System.IntPtr handle);
  // properties
  public static MonoTouch.Foundation.NSString CancelledKey { get; }
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString InputErrorKey { get; }
  public virtual bool NetworkAccessAllowed { get; set; }
  public static MonoTouch.Foundation.NSString ResultIsInCloudKey { get; }
  // methods
  public virtual void SetCanHandleAdjustmentDataHandler (System.Func<PHAdjustmentData,System.Boolean> canHandleAdjustmentDataPredicate);
  public virtual void SetProgressHandler (PHProgressHandler progressHandler);
}

New Type MonoTouch.Photos.PHContentEditingOutput

public class PHContentEditingOutput : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHContentEditingOutput ();
  public PHContentEditingOutput (MonoTouch.Foundation.NSCoder coder);
  public PHContentEditingOutput (MonoTouch.Foundation.NSObjectFlag t);
  public PHContentEditingOutput (System.IntPtr handle);
  public PHContentEditingOutput (PHContentEditingInput contentEditingInput);
  // properties
  public virtual PHAdjustmentData AdjustmentData { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSUrl RenderedContentUrl { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Photos.PHFetchOptions

public class PHFetchOptions : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHFetchOptions ();
  public PHFetchOptions (MonoTouch.Foundation.NSCoder coder);
  public PHFetchOptions (MonoTouch.Foundation.NSObjectFlag t);
  public PHFetchOptions (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool IncludeAllBurstAssets { get; set; }
  public virtual MonoTouch.Foundation.NSPredicate Predicate { get; set; }
  public virtual MonoTouch.Foundation.NSSortDescriptor[] SortDescriptors { get; set; }
  public virtual bool WantsIncrementalChangeDetails { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Photos.PHFetchResult

public class PHFetchResult : MonoTouch.Foundation.NSObject, System.Collections.Generic.IEnumerable<MonoTouch.Foundation.NSObject>, MonoTouch.Foundation.INSCopying, System.Collections.IEnumerable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHFetchResult (MonoTouch.Foundation.NSCoder coder);
  public PHFetchResult (MonoTouch.Foundation.NSObjectFlag t);
  public PHFetchResult (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual uint Count { get; }
  public virtual MonoTouch.Foundation.NSObject firstObject { get; }
  public MonoTouch.Foundation.NSObject Item { get; }
  public virtual MonoTouch.Foundation.NSObject LastObject { get; }
  // methods
  public virtual bool Contains (MonoTouch.Foundation.NSObject id);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public virtual void Enumerate (MonoTouch.Foundation.NSIndexSet idx, MonoTouch.Foundation.NSEnumerationOptions opts, PHFetchResultEnumerator handler);
  public virtual void Enumerate (MonoTouch.Foundation.NSEnumerationOptions opts, PHFetchResultEnumerator handler);
  public virtual void Enumerate (PHFetchResultEnumerator handler);
  public virtual System.Collections.Generic.IEnumerator<MonoTouch.Foundation.NSObject> GetEnumerator ();
  public virtual uint IndexOf (MonoTouch.Foundation.NSObject id);
  public virtual uint IndexOf (MonoTouch.Foundation.NSObject id, MonoTouch.Foundation.NSRange range);
  public virtual MonoTouch.Foundation.NSObject ObjectAt (uint index);
  public T[] ObjectsAt<T> (MonoTouch.Foundation.NSIndexSet indexes);
}

New Type MonoTouch.Photos.PHFetchResultChangeDetails

public class PHFetchResultChangeDetails : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHFetchResultChangeDetails ();
  public PHFetchResultChangeDetails (MonoTouch.Foundation.NSCoder coder);
  public PHFetchResultChangeDetails (MonoTouch.Foundation.NSObjectFlag t);
  public PHFetchResultChangeDetails (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSIndexSet ChangedIndexes { get; }
  public virtual PHObject[] ChangedObjects { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual PHFetchResult FetchResultAfterChanges { get; }
  public virtual PHFetchResult FetchResultBeforeChanges { get; }
  public virtual bool HasIncrementalChanges { get; }
  public virtual bool HasMoves { get; }
  public virtual MonoTouch.Foundation.NSIndexSet InsertedIndexes { get; }
  public virtual PHObject[] InsertedObjects { get; }
  public virtual MonoTouch.Foundation.NSIndexSet RemovedIndexes { get; }
  public virtual PHObject[] RemovedObjects { get; }
  // methods
  public static PHFetchResultChangeDetails ChangeDetails (PHFetchResult fromResult, PHFetchResult toResult, PHObject[] changedObjects);
  protected override void Dispose (bool disposing);
  public virtual void EnumerateMoves (PHChangeDetailEnumerator handler);
}

New Type MonoTouch.Photos.PHFetchResultEnumerator

public sealed delegate PHFetchResultEnumerator : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHFetchResultEnumerator (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.Foundation.NSObject element, uint elementIndex, out bool stop, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (out bool stop, System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.Foundation.NSObject element, uint elementIndex, out bool stop);
}

New Type MonoTouch.Photos.PHImageContentMode

[Serializable]
public enum PHImageContentMode {
  AspectFill = 1,
  AspectFit = 0,
  Default = 0,
}

New Type MonoTouch.Photos.PHImageKeys

public static class PHImageKeys {
  // properties
  public static MonoTouch.Foundation.NSString Cancelled { get; }
  public static MonoTouch.Foundation.NSString Error { get; }
  public static MonoTouch.Foundation.NSString FileData { get; }
  public static MonoTouch.Foundation.NSString FileOrientation { get; }
  public static MonoTouch.Foundation.NSString FileUti { get; }
  public static MonoTouch.Foundation.NSString ResultIsDegraded { get; }
  public static MonoTouch.Foundation.NSString ResultIsInCloud { get; }
}

New Type MonoTouch.Photos.PHImageManager

public class PHImageManager : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHImageManager ();
  public PHImageManager (MonoTouch.Foundation.NSCoder coder);
  public PHImageManager (MonoTouch.Foundation.NSObjectFlag t);
  public PHImageManager (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static PHImageManager GetDefaultManager { get; }
  public static System.Drawing.SizeF MaximumSize { get; }
  // methods
  public virtual void CancelImageRequest (uint requestID);
  public virtual uint RequestAvAsset (PHAsset asset, PHVideoRequestOptions options, PHImageManagerRequestAvAssetHandler resultHandler);
  public virtual uint RequestExportSession (PHAsset asset, PHVideoRequestOptions options, string exportPreset, PHImageManagerRequestExportHandler resultHandler);
  public virtual uint RequestImageForAsset (PHAsset asset, System.Drawing.SizeF targetSize, PHImageContentMode contentMode, PHImageRequestOptions options, PHImageResultHandler resultHandler);
  public virtual uint RequestPlayerItem (PHAsset asset, PHVideoRequestOptions options, PHImageManagerRequestPlayerHandler resultHandler);
}

New Type MonoTouch.Photos.PHImageManagerRequestAvAssetHandler

public sealed delegate PHImageManagerRequestAvAssetHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHImageManagerRequestAvAssetHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.AVFoundation.AVAsset asset, MonoTouch.AVFoundation.AVAudioMix audioMix, MonoTouch.Foundation.NSDictionary info, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.AVFoundation.AVAsset asset, MonoTouch.AVFoundation.AVAudioMix audioMix, MonoTouch.Foundation.NSDictionary info);
}

New Type MonoTouch.Photos.PHImageManagerRequestExportHandler

public sealed delegate PHImageManagerRequestExportHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHImageManagerRequestExportHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.AVFoundation.AVAssetExportSession exportSession, MonoTouch.Foundation.NSDictionary info, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.AVFoundation.AVAssetExportSession exportSession, MonoTouch.Foundation.NSDictionary info);
}

New Type MonoTouch.Photos.PHImageManagerRequestPlayerHandler

public sealed delegate PHImageManagerRequestPlayerHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHImageManagerRequestPlayerHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.AVFoundation.AVPlayerItem playerItem, MonoTouch.Foundation.NSDictionary info, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.AVFoundation.AVPlayerItem playerItem, MonoTouch.Foundation.NSDictionary info);
}

New Type MonoTouch.Photos.PHImageRequestOptions

public class PHImageRequestOptions : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHImageRequestOptions ();
  public PHImageRequestOptions (MonoTouch.Foundation.NSCoder coder);
  public PHImageRequestOptions (MonoTouch.Foundation.NSObjectFlag t);
  public PHImageRequestOptions (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHImageRequestOptionsDeliveryMode DeliveryMode { get; set; }
  public virtual PHImageRequestOptionsLoadingMode LoadingMode { get; set; }
  public virtual bool NetworkAccessAllowed { get; set; }
  public virtual System.Drawing.RectangleF NormalizedCropRect { get; set; }
  public virtual PHAssetImageProgressHandler ProgressHandler { get; set; }
  public virtual PHImageRequestOptionsResizeMode ResizeMode { get; set; }
  public virtual bool Synchronous { get; set; }
  public virtual PHImageRequestOptionsVersion Version { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Photos.PHImageRequestOptionsDeliveryMode

[Serializable]
public enum PHImageRequestOptionsDeliveryMode {
  FastFormat = 2,
  HighQualityFormat = 1,
  Opportunistic = 0,
}

New Type MonoTouch.Photos.PHImageRequestOptionsLoadingMode

[Serializable]
public enum PHImageRequestOptionsLoadingMode {
  FileData = 1,
  Image = 0,
}

New Type MonoTouch.Photos.PHImageRequestOptionsResizeMode

[Serializable]
public enum PHImageRequestOptionsResizeMode {
  Exact = 2,
  Fast = 1,
  None = 0,
}

New Type MonoTouch.Photos.PHImageRequestOptionsVersion

[Serializable]
public enum PHImageRequestOptionsVersion {
  Current = 0,
  Original = 2,
  Unadjusted = 1,
}

New Type MonoTouch.Photos.PHImageResultHandler

public sealed delegate PHImageResultHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHImageResultHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.UIKit.UIImage result, MonoTouch.Foundation.NSDictionary info, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.UIKit.UIImage result, MonoTouch.Foundation.NSDictionary info);
}

New Type MonoTouch.Photos.PHObject

public class PHObject : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHObject (MonoTouch.Foundation.NSCoder coder);
  public PHObject (MonoTouch.Foundation.NSObjectFlag t);
  public PHObject (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string LocalIdentifier { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Photos.PHObjectChangeDetails

public class PHObjectChangeDetails : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHObjectChangeDetails ();
  public PHObjectChangeDetails (MonoTouch.Foundation.NSCoder coder);
  public PHObjectChangeDetails (MonoTouch.Foundation.NSObjectFlag t);
  public PHObjectChangeDetails (System.IntPtr handle);
  // properties
  public virtual bool AssetContentChanged { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSObject ObjectAfterChanges { get; }
  public virtual MonoTouch.Foundation.NSObject ObjectBeforeChanges { get; }
  public virtual bool ObjectWasDeleted { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.Photos.PHObjectPlaceholder

public class PHObjectPlaceholder : MonoTouch.Photos.PHObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHObjectPlaceholder ();
  public PHObjectPlaceholder (MonoTouch.Foundation.NSCoder coder);
  public PHObjectPlaceholder (MonoTouch.Foundation.NSObjectFlag t);
  public PHObjectPlaceholder (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.Photos.PHPhotoLibrary

public class PHPhotoLibrary : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHPhotoLibrary (MonoTouch.Foundation.NSCoder coder);
  public PHPhotoLibrary (MonoTouch.Foundation.NSObjectFlag t);
  public PHPhotoLibrary (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public static PHPhotoLibrary GetSharedPhotoLibrary { get; }
  // methods
  public virtual void PerformChanges (System.Action changeHandler, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completionHandler);
  public virtual bool PerformChangesAndWait (System.Action changeHandler, out MonoTouch.Foundation.NSError error);
  public virtual void RegisterChangeObserver (PHPhotoLibraryChangeObserver observer);
  public virtual void UnregisterChangeObserver (PHPhotoLibraryChangeObserver observer);
}

New Type MonoTouch.Photos.PHPhotoLibraryChangeObserver

public class PHPhotoLibraryChangeObserver : MonoTouch.Foundation.NSObject, IPHPhotoLibraryChangeObserver, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHPhotoLibraryChangeObserver ();
  public PHPhotoLibraryChangeObserver (MonoTouch.Foundation.NSCoder coder);
  public PHPhotoLibraryChangeObserver (MonoTouch.Foundation.NSObjectFlag t);
  public PHPhotoLibraryChangeObserver (System.IntPtr handle);
  // methods
  public virtual void PhotoLibraryDidChange (PHChange changeInstance);
}

New Type MonoTouch.Photos.PHPhotoLibraryChangeObserver_Extensions

public static class PHPhotoLibraryChangeObserver_Extensions {
  // methods
  public static void PhotoLibraryDidChange (IPHPhotoLibraryChangeObserver This, PHChange changeInstance);
}

New Type MonoTouch.Photos.PHProgressHandler

public sealed delegate PHProgressHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public PHProgressHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (double progress, ref bool stop, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (ref bool stop, System.IAsyncResult result);
  public virtual void Invoke (double progress, ref bool stop);
}

New Type MonoTouch.Photos.PHVideoRequestOptions

public class PHVideoRequestOptions : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHVideoRequestOptions ();
  public PHVideoRequestOptions (MonoTouch.Foundation.NSCoder coder);
  public PHVideoRequestOptions (MonoTouch.Foundation.NSObjectFlag t);
  public PHVideoRequestOptions (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual PHVideoRequestOptionsDeliveryMode DeliveryMode { get; set; }
  public virtual bool NetworkAccessAllowed { get; set; }
  public virtual PHAssetVideoProgressHandler ProgressHandler { get; set; }
  public virtual PHVideoRequestOptionsVersion Version { get; set; }
}

New Type MonoTouch.Photos.PHVideoRequestOptionsDeliveryMode

[Serializable]
public enum PHVideoRequestOptionsDeliveryMode {
  Automatic = 0,
  FastFormat = 2,
  HighQualityFormat = 1,
}

New Type MonoTouch.Photos.PHVideoRequestOptionsVersion

[Serializable]
public enum PHVideoRequestOptionsVersion {
  Current = 0,
  Original = 1,
}

New Namespace MonoTouch.PhotosUI

New Type MonoTouch.PhotosUI.IPHContentEditingController

public interface IPHContentEditingController : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void CancelContentEditing ();
  public virtual bool CanHandleAdjustmentData (MonoTouch.Photos.PHAdjustmentData adjustmentData);
  public virtual void FinishContentEditing (System.Action<MonoTouch.Photos.PHContentEditingOutput> completionHandler);
  public virtual void StartContentEditing (MonoTouch.Photos.PHContentEditingInput contentEditingInput, MonoTouch.UIKit.UIImage placeholderImage);
}

New Type MonoTouch.PhotosUI.PHContentEditingController

public abstract class PHContentEditingController : MonoTouch.Foundation.NSObject, IPHContentEditingController, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PHContentEditingController ();
  public PHContentEditingController (MonoTouch.Foundation.NSCoder coder);
  public PHContentEditingController (MonoTouch.Foundation.NSObjectFlag t);
  public PHContentEditingController (System.IntPtr handle);
  // methods
  public virtual void CancelContentEditing ();
  public virtual bool CanHandleAdjustmentData (MonoTouch.Photos.PHAdjustmentData adjustmentData);
  public virtual void FinishContentEditing (System.Action<MonoTouch.Photos.PHContentEditingOutput> completionHandler);
  public virtual void StartContentEditing (MonoTouch.Photos.PHContentEditingInput contentEditingInput, MonoTouch.UIKit.UIImage placeholderImage);
}

New Type MonoTouch.PhotosUI.PHContentEditingController_Extensions

public static class PHContentEditingController_Extensions {
}

New Namespace MonoTouch.PushKit

New Type MonoTouch.PushKit.IPKPushRegistryDelegate

public interface IPKPushRegistryDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void DidReceiveIncomingPush (PKPushRegistry registry, PKPushPayload payload, string type);
  public virtual void DidUpdatePushCredentials (PKPushRegistry registry, PKPushCredentials credentials, string type);
}

New Type MonoTouch.PushKit.PKPushCredentials

public class PKPushCredentials : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PKPushCredentials (MonoTouch.Foundation.NSCoder coder);
  public PKPushCredentials (MonoTouch.Foundation.NSObjectFlag t);
  public PKPushCredentials (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData Token { get; }
  public virtual string Type { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.PushKit.PKPushPayload

public class PKPushPayload : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PKPushPayload (MonoTouch.Foundation.NSCoder coder);
  public PKPushPayload (MonoTouch.Foundation.NSObjectFlag t);
  public PKPushPayload (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDictionary DictionaryPayload { get; }
  public virtual string Type { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.PushKit.PKPushRegistry

public class PKPushRegistry : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PKPushRegistry (MonoTouch.Foundation.NSCoder coder);
  public PKPushRegistry (MonoTouch.Foundation.NSObjectFlag t);
  public PKPushRegistry (System.IntPtr handle);
  public PKPushRegistry (MonoTouch.CoreFoundation.DispatchQueue queue);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public PKPushRegistryDelegate Delegate { get; set; }
  public virtual MonoTouch.Foundation.NSSet DesiredPushTypes { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.Foundation.NSData PushToken (string type);
}

New Type MonoTouch.PushKit.PKPushRegistryDelegate

public abstract class PKPushRegistryDelegate : MonoTouch.Foundation.NSObject, IPKPushRegistryDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public PKPushRegistryDelegate ();
  public PKPushRegistryDelegate (MonoTouch.Foundation.NSCoder coder);
  public PKPushRegistryDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public PKPushRegistryDelegate (System.IntPtr handle);
  // methods
  public virtual void DidInvalidatePushToken (PKPushRegistry registry, string type);
  public virtual void DidReceiveIncomingPush (PKPushRegistry registry, PKPushPayload payload, string type);
  public virtual void DidUpdatePushCredentials (PKPushRegistry registry, PKPushCredentials credentials, string type);
}

New Type MonoTouch.PushKit.PKPushRegistryDelegate_Extensions

public static class PKPushRegistryDelegate_Extensions {
  // methods
  public static void DidInvalidatePushToken (IPKPushRegistryDelegate This, PKPushRegistry registry, string type);
}

New Type MonoTouch.PushKit.PKPushType

public static class PKPushType {
  // properties
  public static MonoTouch.Foundation.NSString Voip { get; }
}

New Namespace MonoTouch.SceneKit

New Type MonoTouch.SceneKit.ISCNActionable

public interface ISCNActionable : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNAnimatable

public interface ISCNAnimatable : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNBoundingVolume

public interface ISCNBoundingVolume : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNNodeRendererDelegate

public interface ISCNNodeRendererDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNPhysicsContactDelegate

public interface ISCNPhysicsContactDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNProgramDelegate

public interface ISCNProgramDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNSceneRenderer

public interface ISCNSceneRenderer : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.Foundation.NSDictionary options);
}

New Type MonoTouch.SceneKit.ISCNSceneRendererDelegate

public interface ISCNSceneRendererDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNShadable

public interface ISCNShadable : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.ISCNTechniqueSupport

public interface ISCNTechniqueSupport : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.SceneKit.SCNAction

public class SCNAction : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNAction ();
  public SCNAction (MonoTouch.Foundation.NSCoder coder);
  public SCNAction (MonoTouch.Foundation.NSObjectFlag t);
  public SCNAction (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual double DurationInSeconds { get; set; }
  public virtual float Speed { get; set; }
  public virtual SCNActionTimingMode TimingMode { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual SCNAction ReversedAction ();
}

New Type MonoTouch.SceneKit.SCNActionable

public class SCNActionable : MonoTouch.Foundation.NSObject, ISCNActionable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNActionable ();
  public SCNActionable (MonoTouch.Foundation.NSCoder coder);
  public SCNActionable (MonoTouch.Foundation.NSObjectFlag t);
  public SCNActionable (System.IntPtr handle);
  // methods
  public virtual SCNAction GetAction (string key);
  public virtual bool HasActions ();
  public virtual void RemoveAction (string key);
  public virtual void RemoveAllActions ();
  public virtual void RunAction (SCNAction action);
  public virtual void RunAction (SCNAction action, System.Action block);
  public virtual void RunAction (SCNAction action, string key);
  public virtual void RunAction (SCNAction action, string key, System.Action block);
}

New Type MonoTouch.SceneKit.SCNActionable_Extensions

public static class SCNActionable_Extensions {
  // methods
  public static SCNAction GetAction (ISCNActionable This, string key);
  public static bool HasActions (ISCNActionable This);
  public static void RemoveAction (ISCNActionable This, string key);
  public static void RemoveAllActions (ISCNActionable This);
  public static void RunAction (ISCNActionable This, SCNAction action);
  public static void RunAction (ISCNActionable This, SCNAction action, string key);
  public static void RunAction (ISCNActionable This, SCNAction action, System.Action block);
  public static void RunAction (ISCNActionable This, SCNAction action, string key, System.Action block);
}

New Type MonoTouch.SceneKit.SCNActionNodeWithElapsedTimeHandler

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

New Type MonoTouch.SceneKit.SCNActions

public static class SCNActions {
  // methods
  public static SCNAction CustomAction (SCNAction This, double seconds, SCNActionNodeWithElapsedTimeHandler handler);
  public static SCNAction FadeIn (SCNAction This, double durationInSeconds);
  public static SCNAction FadeOpacityBy (SCNAction This, float factor, double durationInSeconds);
  public static SCNAction FadeOpacityTo (SCNAction This, float opacity, double durationInSeconds);
  public static SCNAction FadeOut (SCNAction This, double durationInSeconds);
  public static SCNAction Group (SCNAction This, SCNAction[] actions);
  public static SCNAction JavaScriptAction (SCNAction This, string script, double seconds);
  public static SCNAction MoveBy (SCNAction This, float deltaX, float deltaY, float deltaZ, double durationInSeconds);
  public static SCNAction MoveBy (SCNAction This, SCNVector3 delta, double durationInSeconds);
  public static SCNAction MoveTo (SCNAction This, SCNVector3 location, double durationInSeconds);
  public static SCNAction RemoveFromParentNode (SCNAction This);
  public static SCNAction RepeatAction (SCNAction This, SCNAction action, uint count);
  public static SCNAction RepeatActionForever (SCNAction This, SCNAction action);
  public static SCNAction RotateBy (SCNAction This, float xAngle, float yAngle, float zAngle, double durationInSeconds);
  public static SCNAction RotateBy (SCNAction This, float angle, SCNVector3 axis, double durationInSeconds);
  public static SCNAction RotateTo (SCNAction This, float xAngle, float yAngle, float zAngle, double durationInSeconds);
  public static SCNAction RotateTo (SCNAction This, float xAngle, float yAngle, float zAngle, double durationInSeconds, bool shortestUnitArc);
  public static SCNAction RotateTo (SCNAction This, SCNVector4 axisAngle, double durationInSeconds);
  public static SCNAction Run (SCNAction This, System.Action handler, MonoTouch.CoreFoundation.DispatchQueue queue);
  public static SCNAction Run (SCNAction This, System.Action handler);
  public static SCNAction ScaleBy (SCNAction This, float scale, double durationInSeconds);
  public static SCNAction ScaleTo (SCNAction This, float scale, double durationInSeconds);
  public static SCNAction Sequence (SCNAction This, SCNAction[] actions);
  public static SCNAction Wait (SCNAction This, double durationInSeconds);
  public static SCNAction Wait (SCNAction This, double durationInSeconds, double durationRange);
}

New Type MonoTouch.SceneKit.SCNActionTimingMode

[Serializable]
public enum SCNActionTimingMode {
  EaseIn = 1,
  EaseInEaseOut = 3,
  EaseOut = 2,
  Linear = 0,
}

New Type MonoTouch.SceneKit.SCNAnimatable

public class SCNAnimatable : MonoTouch.Foundation.NSObject, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNAnimatable ();
  public SCNAnimatable (MonoTouch.Foundation.NSCoder coder);
  public SCNAnimatable (MonoTouch.Foundation.NSObjectFlag t);
  public SCNAnimatable (System.IntPtr handle);
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNAnimatable_Extensions

public static class SCNAnimatable_Extensions {
  // methods
  public static void AddAnimation (ISCNAnimatable This, MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public static MonoTouch.CoreAnimation.CAAnimation GetAnimation (ISCNAnimatable This, MonoTouch.Foundation.NSString key);
  public static MonoTouch.Foundation.NSString[] GetAnimationKeys (ISCNAnimatable This);
  public static bool IsAnimationPaused (ISCNAnimatable This, MonoTouch.Foundation.NSString key);
  public static void PauseAnimation (ISCNAnimatable This, MonoTouch.Foundation.NSString key);
  public static void RemoveAllAnimations (ISCNAnimatable This);
  public static void RemoveAnimation (ISCNAnimatable This, MonoTouch.Foundation.NSString key);
  public static void RemoveAnimation (ISCNAnimatable This, MonoTouch.Foundation.NSString key, float duration);
  public static void ResumeAnimation (ISCNAnimatable This, MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNAnimationEvent

public class SCNAnimationEvent : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNAnimationEvent (MonoTouch.Foundation.NSCoder coder);
  public SCNAnimationEvent (MonoTouch.Foundation.NSObjectFlag t);
  public SCNAnimationEvent (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static SCNAnimationEvent Create (float keyTime, SCNAnimationEventHandler eventHandler);
}

New Type MonoTouch.SceneKit.SCNAnimationEventHandler

public sealed delegate SCNAnimationEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNAnimationEventHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSObject animatedObject, bool playingBackward, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSObject animatedObject, bool playingBackward);
}

New Type MonoTouch.SceneKit.SCNBindingHandler

public sealed delegate SCNBindingHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNBindingHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (uint programId, uint location, SCNNode renderedNode, SCNRenderer renderer, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (uint programId, uint location, SCNNode renderedNode, SCNRenderer renderer);
}

New Type MonoTouch.SceneKit.SCNBoundingVolume

public class SCNBoundingVolume : MonoTouch.Foundation.NSObject, ISCNBoundingVolume, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNBoundingVolume ();
  public SCNBoundingVolume (MonoTouch.Foundation.NSCoder coder);
  public SCNBoundingVolume (MonoTouch.Foundation.NSObjectFlag t);
  public SCNBoundingVolume (System.IntPtr handle);
  // methods
  public virtual bool GetBoundingBox (ref SCNVector3 min, ref SCNVector3 max);
  public virtual bool GetBoundingSphere (ref SCNVector3 center, ref float radius);
}

New Type MonoTouch.SceneKit.SCNBoundingVolume_Extensions

public static class SCNBoundingVolume_Extensions {
  // methods
  public static bool GetBoundingBox (ISCNBoundingVolume This, ref SCNVector3 min, ref SCNVector3 max);
  public static bool GetBoundingSphere (ISCNBoundingVolume This, ref SCNVector3 center, ref float radius);
}

New Type MonoTouch.SceneKit.SCNBox

public class SCNBox : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNBox ();
  public SCNBox (MonoTouch.Foundation.NSCoder coder);
  public SCNBox (MonoTouch.Foundation.NSObjectFlag t);
  public SCNBox (System.IntPtr handle);
  // properties
  public virtual float ChamferRadius { get; set; }
  public virtual int ChamferSegmentCount { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual float Length { get; set; }
  public virtual int LengthSegmentCount { get; set; }
  public virtual float Width { get; set; }
  public virtual int WidthSegmentCount { get; set; }
  // methods
  public static SCNBox Create (float width, float height, float length, float chamferRadius);
}

New Type MonoTouch.SceneKit.SCNCamera

public class SCNCamera : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNTechniqueSupport, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNCamera ();
  public SCNCamera (MonoTouch.Foundation.NSCoder coder);
  public SCNCamera (MonoTouch.Foundation.NSObjectFlag t);
  public SCNCamera (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D ProjectionTransform { get; set; }
  public virtual SCNTechnique Technique { get; set; }
  public virtual bool UsesOrthographicProjection { get; set; }
  public virtual double XFov { get; set; }
  public virtual double YFov { get; set; }
  public virtual double ZFar { get; set; }
  public virtual double ZNear { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNCamera Create ();
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNCapsule

public class SCNCapsule : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNCapsule ();
  public SCNCapsule (MonoTouch.Foundation.NSCoder coder);
  public SCNCapsule (MonoTouch.Foundation.NSObjectFlag t);
  public SCNCapsule (System.IntPtr handle);
  // properties
  public virtual float CapRadius { get; set; }
  public virtual int CapSegmentCount { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual int RadialSegmentCount { get; set; }
  // methods
  public static SCNCapsule Create (float capRadius, float height);
}

New Type MonoTouch.SceneKit.SCNChamferMode

[Serializable]
public enum SCNChamferMode {
  Back = 2,
  Both = 0,
  Front = 1,
}

New Type MonoTouch.SceneKit.SCNCone

public class SCNCone : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNCone ();
  public SCNCone (MonoTouch.Foundation.NSCoder coder);
  public SCNCone (MonoTouch.Foundation.NSObjectFlag t);
  public SCNCone (System.IntPtr handle);
  // properties
  public virtual float BottomRadius { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual int RadialSegmentCount { get; set; }
  public virtual float TopRadius { get; set; }
  // methods
  public static SCNCone Create (float topRadius, float bottomRadius, float height);
}

New Type MonoTouch.SceneKit.SCNConstraint

public class SCNConstraint : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNConstraint (MonoTouch.Foundation.NSCoder coder);
  public SCNConstraint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNConstraint (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float InfluenceFactor { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNCullMode

[Serializable]
public enum SCNCullMode {
  Back = 0,
  Front = 1,
}

New Type MonoTouch.SceneKit.SCNCylinder

public class SCNCylinder : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNCylinder ();
  public SCNCylinder (MonoTouch.Foundation.NSCoder coder);
  public SCNCylinder (MonoTouch.Foundation.NSObjectFlag t);
  public SCNCylinder (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual int RadialSegmentCount { get; set; }
  public virtual float Radius { get; set; }
  // methods
  public static SCNCylinder Create (float radius, float height);
}

New Type MonoTouch.SceneKit.SCNFieldForceEvaluator

public sealed delegate SCNFieldForceEvaluator : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNFieldForceEvaluator (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (SCNVector3 position, SCNVector3 velocity, float mass, float charge, double timeInSeconds, System.AsyncCallback callback, object object);
  public virtual SCNVector3 EndInvoke (System.IAsyncResult result);
  public virtual SCNVector3 Invoke (SCNVector3 position, SCNVector3 velocity, float mass, float charge, double timeInSeconds);
}

New Type MonoTouch.SceneKit.SCNFilterMode

[Serializable]
public enum SCNFilterMode {
  Linear = 2,
  Nearest = 1,
  None = 0,
}

New Type MonoTouch.SceneKit.SCNFloor

public class SCNFloor : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNFloor ();
  public SCNFloor (MonoTouch.Foundation.NSCoder coder);
  public SCNFloor (MonoTouch.Foundation.NSObjectFlag t);
  public SCNFloor (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float ReflectionFalloffEnd { get; set; }
  public virtual float ReflectionFalloffStart { get; set; }
  public virtual float ReflectionResolutionScaleFactor { get; set; }
  public virtual float Reflectivity { get; set; }
  // methods
  public static SCNFloor Create ();
}

New Type MonoTouch.SceneKit.SCNGeometry

public class SCNGeometry : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNGeometry (MonoTouch.Foundation.NSCoder coder);
  public SCNGeometry (MonoTouch.Foundation.NSObjectFlag t);
  public SCNGeometry (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNGeometryElement EdgeCreasesElement { get; set; }
  public virtual SCNGeometrySource EdgeCreasesSource { get; set; }
  public virtual SCNMaterial FirstMaterial { get; set; }
  public virtual int GeometryElementCount { get; }
  public virtual SCNLevelOfDetail[] LevelsOfDetail { get; set; }
  public virtual SCNMaterial[] Materials { get; set; }
  public virtual string Name { get; set; }
  public virtual SCNProgram Program { get; set; }
  public virtual MonoTouch.Foundation.NSDictionary ShaderModifiers { get; set; }
  public virtual uint SubdivisionLevel { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNGeometry Create ();
  protected override void Dispose (bool disposing);
  public static MonoTouch.Foundation.NSObject FromSources (SCNGeometrySource[] sources, SCNGeometryElement[] elements);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool GetBoundingBox (ref SCNVector3 min, ref SCNVector3 max);
  public virtual bool GetBoundingSphere (ref SCNVector3 center, ref float radius);
  public virtual SCNGeometryElement GetGeometryElement (int elementIndex);
  public virtual SCNGeometrySource[] GetGeometrySourcesForSemantic (string semantic);
  public virtual SCNMaterial GetMaterial (string name);
  public virtual void HandleBinding (string symbol, SCNBindingHandler handler);
  public virtual void HandleUnbinding (string symbol, SCNBindingHandler handler);
  public virtual void InsertMaterial (SCNMaterial material, int index);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveMaterial (int index);
  public virtual void ReplaceMaterial (int materialIndex, SCNMaterial newMaterial);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNGeometryElement

public class SCNGeometryElement : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNGeometryElement ();
  public SCNGeometryElement (MonoTouch.Foundation.NSCoder coder);
  public SCNGeometryElement (MonoTouch.Foundation.NSObjectFlag t);
  public SCNGeometryElement (System.IntPtr handle);
  // properties
  public virtual int BytesPerIndex { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData Data { get; }
  public virtual int PrimitiveCount { get; }
  public virtual SCNGeometryPrimitiveType PrimitiveType { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static SCNGeometryElement FromData (MonoTouch.Foundation.NSData data, SCNGeometryPrimitiveType primitiveType, int primitiveCount, int bytesPerIndex);
}

New Type MonoTouch.SceneKit.SCNGeometryPrimitiveType

[Serializable]
public enum SCNGeometryPrimitiveType {
  Line = 2,
  Point = 3,
  Triangles = 0,
  TriangleStrip = 1,
}

New Type MonoTouch.SceneKit.SCNGeometrySource

public class SCNGeometrySource : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNGeometrySource ();
  public SCNGeometrySource (MonoTouch.Foundation.NSCoder coder);
  public SCNGeometrySource (MonoTouch.Foundation.NSObjectFlag t);
  public SCNGeometrySource (System.IntPtr handle);
  // properties
  public virtual int BytesPerComponent { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual int ComponentsPerVector { get; }
  public virtual MonoTouch.Foundation.NSData Data { get; }
  public virtual int DataOffset { get; }
  public virtual int DataStride { get; }
  public virtual bool FloatComponents { get; }
  public virtual MonoTouch.Foundation.NSString Semantic { get; }
  public virtual int VectorCount { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static SCNGeometrySource FromData (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSString geometrySourceSemantic, int vectorCount, bool floatComponents, int componentsPerVector, int bytesPerComponent, int offset, int stride);
  public static SCNGeometrySource FromNormals (SCNVector3[] normals);
  public static SCNGeometrySource FromTextureCoordinates (System.Drawing.PointF[] texcoords);
  public static SCNGeometrySource FromVertices (SCNVector3[] vertices);
}

New Type MonoTouch.SceneKit.SCNGeometrySourceSemantic

public static class SCNGeometrySourceSemantic {
  // properties
  public static MonoTouch.Foundation.NSString BoneIndices { get; }
  public static MonoTouch.Foundation.NSString BoneWeights { get; }
  public static MonoTouch.Foundation.NSString Color { get; }
  public static MonoTouch.Foundation.NSString EdgeCrease { get; }
  public static MonoTouch.Foundation.NSString Normal { get; }
  public static MonoTouch.Foundation.NSString Texcoord { get; }
  public static MonoTouch.Foundation.NSString Vertex { get; }
  public static MonoTouch.Foundation.NSString VertexCrease { get; }
}

New Type MonoTouch.SceneKit.SCNHitTest

public static class SCNHitTest {
  // properties
  public static MonoTouch.Foundation.NSString BackFaceCullingKey { get; }
  public static MonoTouch.Foundation.NSString BoundingBoxOnlyKey { get; }
  public static MonoTouch.Foundation.NSString ClipToZRangeKey { get; }
  public static MonoTouch.Foundation.NSString FirstFoundOnlyKey { get; }
  public static MonoTouch.Foundation.NSString IgnoreChildNodesKey { get; }
  public static MonoTouch.Foundation.NSString IgnoreHiddenNodes { get; }
  public static MonoTouch.Foundation.NSString RootNodeKey { get; }
  public static MonoTouch.Foundation.NSString SortResultsKey { get; }
}

New Type MonoTouch.SceneKit.SCNHitTestOptions

public class SCNHitTestOptions : MonoTouch.Foundation.DictionaryContainer {
  // constructors
  public SCNHitTestOptions ();
  public SCNHitTestOptions (MonoTouch.Foundation.NSDictionary dictionary);
  // properties
  public bool? BackFaceCulling { get; set; }
  public bool? BoundingBoxOnly { get; set; }
  public bool? ClipToZRange { get; set; }
  public bool? FirstFoundOnly { get; set; }
  public bool? IgnoreChildNodes { get; set; }
  public bool? IgnoreHiddenNodes { get; set; }
  public SCNNode RootNode { get; set; }
  public bool? SortResults { get; set; }
}

New Type MonoTouch.SceneKit.SCNHitTestResult

public class SCNHitTestResult : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNHitTestResult (MonoTouch.Foundation.NSCoder coder);
  public SCNHitTestResult (MonoTouch.Foundation.NSObjectFlag t);
  public SCNHitTestResult (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual int FaceIndex { get; }
  public virtual int GeometryIndex { get; }
  public virtual SCNVector3 LocalCoordinates { get; }
  public virtual SCNVector3 LocalNormal { get; }
  public virtual MonoTouch.CoreAnimation.CATransform3D ModelTransform { get; }
  public virtual SCNNode Node { get; }
  public virtual SCNVector3 WorldCoordinates { get; }
  public virtual SCNVector3 WorldNormal { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual System.Drawing.PointF GetTextureCoordinatesWithMappingChannel (int channel);
}

New Type MonoTouch.SceneKit.SCNIKConstraint

public class SCNIKConstraint : MonoTouch.SceneKit.SCNConstraint, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNIKConstraint (MonoTouch.Foundation.NSCoder coder);
  public SCNIKConstraint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNIKConstraint (System.IntPtr handle);
  // properties
  public virtual SCNNode ChainRootNode { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNVector3 TargetPosition { get; set; }
  // methods
  public static SCNIKConstraint Create (SCNNode chainRootNode);
  protected override void Dispose (bool disposing);
  public virtual float GetMaxAllowedRotationAngle (SCNNode node);
  public virtual void SetMaxAllowedRotationAnglet (float angle, SCNNode node);
}

New Type MonoTouch.SceneKit.SCNJavaScript

public static class SCNJavaScript {
  // methods
  public static void ExportModule (MonoTouch.JavaScriptCore.JSContext context);
}

New Type MonoTouch.SceneKit.SCNLevelOfDetail

public class SCNLevelOfDetail : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNLevelOfDetail (MonoTouch.Foundation.NSCoder coder);
  public SCNLevelOfDetail (MonoTouch.Foundation.NSObjectFlag t);
  public SCNLevelOfDetail (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNGeometry Geometry { get; }
  public virtual float ScreenSpaceRadius { get; }
  public virtual float WorldSpaceDistance { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNLevelOfDetail CreateWithScreenSpaceRadius (SCNGeometry geometry, float screenSpaceRadius);
  public static SCNLevelOfDetail CreateWithWorldSpaceDistance (SCNGeometry geometry, float worldSpaceDistance);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNLight

public class SCNLight : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNTechniqueSupport, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNLight ();
  public SCNLight (MonoTouch.Foundation.NSCoder coder);
  public SCNLight (MonoTouch.Foundation.NSObjectFlag t);
  public SCNLight (System.IntPtr handle);
  // properties
  public virtual float AttenuationEndDistance { get; set; }
  public virtual float AttenuationFalloffExponent { get; set; }
  public virtual float AttenuationStartDistance { get; set; }
  public virtual bool CastsShadow { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public MonoTouch.UIKit.UIColor Color { get; set; }
  public virtual SCNMaterialProperty Gobo { get; }
  public virtual MonoTouch.Foundation.NSString LightType { get; set; }
  public virtual string Name { get; set; }
  public virtual float OrthographicScale { get; set; }
  public virtual float ShadowBias { get; set; }
  public MonoTouch.UIKit.UIColor ShadowColor { get; set; }
  public virtual System.Drawing.SizeF ShadowMapSize { get; set; }
  public virtual SCNShadowMode ShadowMode { get; set; }
  public virtual float ShadowRadius { get; set; }
  public virtual uint ShadowSampleCount { get; set; }
  public virtual float SpotInnerAngle { get; set; }
  public virtual float SpotOuterAngle { get; set; }
  public virtual SCNTechnique Technique { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakColor { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakShadowColor { get; set; }
  public virtual float ZFar { get; set; }
  public virtual float ZNear { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNLight Create ();
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual MonoTouch.Foundation.NSObject GetAttribute (MonoTouch.Foundation.NSString lightAttribute);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
  public virtual void SetAttribute (MonoTouch.Foundation.NSObject value, MonoTouch.Foundation.NSString attribuetKey);
}

New Type MonoTouch.SceneKit.SCNLightAttribute

public static class SCNLightAttribute {
  // properties
  public static MonoTouch.Foundation.NSString AttenuationEndKey { get; }
  public static MonoTouch.Foundation.NSString AttenuationFalloffExponentKey { get; }
  public static MonoTouch.Foundation.NSString AttenuationStartKey { get; }
  public static MonoTouch.Foundation.NSString ShadowFarClippingKey { get; }
  public static MonoTouch.Foundation.NSString ShadowNearClippingKey { get; }
  public static MonoTouch.Foundation.NSString SpotInnerAngleKey { get; }
  public static MonoTouch.Foundation.NSString SpotOuterAngleKey { get; }
}

New Type MonoTouch.SceneKit.SCNLightingModel

public static class SCNLightingModel {
  // properties
  public static MonoTouch.Foundation.NSString Blinn { get; }
  public static MonoTouch.Foundation.NSString Constant { get; }
  public static MonoTouch.Foundation.NSString Lambert { get; }
  public static MonoTouch.Foundation.NSString Phong { get; }
}

New Type MonoTouch.SceneKit.SCNLightType

public static class SCNLightType {
  // properties
  public static MonoTouch.Foundation.NSString Ambient { get; }
  public static MonoTouch.Foundation.NSString Directional { get; }
  public static MonoTouch.Foundation.NSString Omni { get; }
  public static MonoTouch.Foundation.NSString Spot { get; }
}

New Type MonoTouch.SceneKit.SCNLookAtConstraint

public class SCNLookAtConstraint : MonoTouch.SceneKit.SCNConstraint, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNLookAtConstraint (MonoTouch.Foundation.NSCoder coder);
  public SCNLookAtConstraint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNLookAtConstraint (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool GimbalLockEnabled { get; set; }
  public virtual SCNNode Target { get; }
  // methods
  public static SCNLookAtConstraint Create (SCNNode target);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNMaterial

public class SCNMaterial : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNMaterial ();
  public SCNMaterial (MonoTouch.Foundation.NSCoder coder);
  public SCNMaterial (MonoTouch.Foundation.NSObjectFlag t);
  public SCNMaterial (System.IntPtr handle);
  // properties
  public virtual SCNMaterialProperty Ambient { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNCullMode CullMode { get; set; }
  public virtual SCNMaterialProperty Diffuse { get; }
  public virtual bool DoubleSided { get; set; }
  public virtual SCNMaterialProperty Emission { get; }
  public virtual MonoTouch.Foundation.NSString LightingModelName { get; set; }
  public virtual bool LitPerPixel { get; set; }
  public virtual bool LocksAmbientWithDiffuse { get; set; }
  public virtual SCNMaterialProperty Multiply { get; }
  public virtual string Name { get; set; }
  public virtual SCNMaterialProperty Normal { get; }
  public virtual SCNProgram Program { get; set; }
  public virtual SCNMaterialProperty Reflective { get; }
  public virtual MonoTouch.Foundation.NSDictionary ShaderModifiers { get; set; }
  public virtual float Shininess { get; set; }
  public virtual SCNMaterialProperty Specular { get; }
  public virtual float Transparency { get; set; }
  public virtual SCNTransparencyMode TransparencyMode { get; set; }
  public virtual SCNMaterialProperty Transparent { get; }
  public virtual bool WritesToDepthBuffer { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNMaterial Create ();
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual void HandleBinding (string symbol, SCNBindingHandler handler);
  public virtual void HandleUnbinding (string symbol, SCNBindingHandler handler);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNMaterialProperty

public class SCNMaterialProperty : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNMaterialProperty (MonoTouch.Foundation.NSCoder coder);
  public SCNMaterialProperty (MonoTouch.Foundation.NSObjectFlag t);
  public SCNMaterialProperty (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSObject BorderColor { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSObject Contents { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D ContentsTransform { get; set; }
  public virtual SCNFilterMode MagnificationFilter { get; set; }
  public virtual int MappingChannel { get; set; }
  public virtual SCNFilterMode MinificationFilter { get; set; }
  public virtual SCNFilterMode MipFilter { get; set; }
  public virtual SCNWrapMode WrapS { get; set; }
  public virtual SCNWrapMode WrapT { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNMorpher

public class SCNMorpher : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNMorpher ();
  public SCNMorpher (MonoTouch.Foundation.NSCoder coder);
  public SCNMorpher (MonoTouch.Foundation.NSObjectFlag t);
  public SCNMorpher (System.IntPtr handle);
  // properties
  public virtual SCNMorpherCalculationMode CalculationMode { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNGeometry[] Targets { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual float GetWeight (uint targetIndex);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
  public virtual void SetWeight (float weight, uint targetIndex);
}

New Type MonoTouch.SceneKit.SCNMorpherCalculationMode

[Serializable]
public enum SCNMorpherCalculationMode {
  Additive = 1,
  Normalized = 0,
}

New Type MonoTouch.SceneKit.SCNNode

public class SCNNode : MonoTouch.Foundation.NSObject, System.Collections.Generic.IEnumerable<SCNNode>, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNActionable, ISCNAnimatable, ISCNBoundingVolume, System.Collections.IEnumerable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNNode ();
  public SCNNode (MonoTouch.Foundation.NSCoder coder);
  public SCNNode (MonoTouch.Foundation.NSObjectFlag t);
  public SCNNode (System.IntPtr handle);
  // properties
  public virtual SCNCamera Camera { get; set; }
  public virtual bool CastsShadow { get; set; }
  public virtual uint CategoryBitMask { get; set; }
  public virtual SCNNode[] ChildNodes { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNConstraint[] Constraints { get; set; }
  public virtual SCNVector3 EulerAngles { get; set; }
  public virtual MonoTouch.CoreImage.CIFilter[] Filters { get; set; }
  public virtual SCNGeometry Geometry { get; set; }
  public virtual bool Hidden { get; set; }
  public virtual SCNLight Light { get; set; }
  public virtual SCNMorpher Morpher { get; set; }
  public virtual string Name { get; set; }
  public virtual float Opacity { get; set; }
  public virtual SCNVector4 Orientation { get; set; }
  public virtual SCNNode ParentNode { get; }
  public virtual SCNParticleSystem[] ParticleSystems { get; }
  public virtual bool Paused { get; set; }
  public virtual SCNPhysicsBody PhysicsBody { get; set; }
  public virtual SCNPhysicsField PhysicsField { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D Pivot { get; set; }
  public virtual SCNVector3 Position { get; set; }
  public virtual SCNNode PresentationNode { get; }
  public SCNNodeRendererDelegate RendererDelegate { get; set; }
  public virtual int RenderingOrder { get; set; }
  public virtual SCNVector4 Rotation { get; set; }
  public virtual SCNVector3 Scale { get; set; }
  public virtual SCNSkinner Skinner { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D Transform { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakRendererDelegate { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D WorldTransform { get; }
  // methods
  public void Add (SCNNode node);
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual void AddChildNode (SCNNode child);
  public virtual void AddParticleSystem (SCNParticleSystem system);
  public virtual SCNNode Clone ();
  public virtual SCNVector3 ConvertPosition (SCNVector3 position, SCNNode node);
  public virtual MonoTouch.CoreAnimation.CATransform3D ConvertTransform (MonoTouch.CoreAnimation.CATransform3D transform, SCNNode node);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNNode Create ();
  protected override void Dispose (bool disposing);
  public virtual void EnumerateChildNodes (SCNNodePredicate predicate);
  public virtual SCNNode FindChildNode (string childName, bool recursively);
  public virtual SCNNode FindNodes (SCNNodePredicate predicate);
  public virtual SCNNode FlattenedClone ();
  public static SCNNode FromGeometry (SCNGeometry geometry);
  public virtual SCNAction GetAction (string key);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual bool GetBoundingBox (ref SCNVector3 min, ref SCNVector3 max);
  public virtual bool GetBoundingSphere (ref SCNVector3 center, ref float radius);
  public virtual System.Collections.Generic.IEnumerator<SCNNode> GetEnumerator ();
  public virtual bool HasActions ();
  public SCNHitTestResult[] HitTest (SCNVector3 pointA, SCNVector3 pointB, SCNHitTestOptions options);
  public virtual SCNHitTestResult[] HitTest (SCNVector3 pointA, SCNVector3 pointB, MonoTouch.Foundation.NSDictionary options);
  public virtual void InsertChildNode (SCNNode child, int index);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAction (string key);
  public virtual void RemoveAllActions ();
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAllParticleSystems ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveFromParentNode ();
  public virtual void RemoveParticleSystem (SCNParticleSystem system);
  public virtual void ReplaceChildNode (SCNNode child, SCNNode child2);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RunAction (SCNAction action, System.Action block);
  public virtual void RunAction (SCNAction action, string key);
  public virtual void RunAction (SCNAction action, string key, System.Action block);
  public virtual void RunAction (SCNAction action);
}

New Type MonoTouch.SceneKit.SCNNodePredicate

public sealed delegate SCNNodePredicate : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNNodePredicate (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (SCNNode node, out bool stop, System.AsyncCallback callback, object object);
  public virtual bool EndInvoke (out bool stop, System.IAsyncResult result);
  public virtual bool Invoke (SCNNode node, out bool stop);
}

New Type MonoTouch.SceneKit.SCNNodeRendererDelegate

public class SCNNodeRendererDelegate : MonoTouch.Foundation.NSObject, ISCNNodeRendererDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNNodeRendererDelegate ();
  public SCNNodeRendererDelegate (MonoTouch.Foundation.NSCoder coder);
  public SCNNodeRendererDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public SCNNodeRendererDelegate (System.IntPtr handle);
  // methods
  public virtual void Render (SCNNode node, SCNRenderer renderer, MonoTouch.Foundation.NSDictionary arguments);
}

New Type MonoTouch.SceneKit.SCNNodeRendererDelegate_Extensions

public static class SCNNodeRendererDelegate_Extensions {
  // methods
  public static void Render (ISCNNodeRendererDelegate This, SCNNode node, SCNRenderer renderer, MonoTouch.Foundation.NSDictionary arguments);
}

New Type MonoTouch.SceneKit.SCNParticleBirthDirection

[Serializable]
public enum SCNParticleBirthDirection {
  Constant = 0,
  Random = 2,
  SurfaceNormal = 1,
}

New Type MonoTouch.SceneKit.SCNParticleBirthLocation

[Serializable]
public enum SCNParticleBirthLocation {
  Surface = 0,
  Vertex = 2,
  Volume = 1,
}

New Type MonoTouch.SceneKit.SCNParticleBlendMode

[Serializable]
public enum SCNParticleBlendMode {
  Additive = 0,
  Alpha = 4,
  Multiply = 2,
  Replace = 5,
  Screen = 3,
  Subtract = 1,
}

New Type MonoTouch.SceneKit.SCNParticleEvent

[Serializable]
public enum SCNParticleEvent {
  Birth = 0,
  Collision = 2,
  Death = 1,
}

New Type MonoTouch.SceneKit.SCNParticleEventHandler

public sealed delegate SCNParticleEventHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNParticleEventHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (System.IntPtr data, System.IntPtr dataStride, System.IntPtr indices, int count, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (System.IntPtr data, System.IntPtr dataStride, System.IntPtr indices, int count);
}

New Type MonoTouch.SceneKit.SCNParticleImageSequenceAnimationMode

[Serializable]
public enum SCNParticleImageSequenceAnimationMode {
  AutoReverse = 2,
  Clamp = 1,
  Repeat = 0,
}

New Type MonoTouch.SceneKit.SCNParticleInputMode

[Serializable]
public enum SCNParticleInputMode {
  OverDistance = 1,
  OverLife = 0,
  OverOtherProperty = 2,
}

New Type MonoTouch.SceneKit.SCNParticleModifierHandler

public sealed delegate SCNParticleModifierHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNParticleModifierHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (System.IntPtr data, System.IntPtr dataStride, int start, int end, float deltaTime, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (System.IAsyncResult result);
  public virtual void Invoke (System.IntPtr data, System.IntPtr dataStride, int start, int end, float deltaTime);
}

New Type MonoTouch.SceneKit.SCNParticleModifierStage

[Serializable]
public enum SCNParticleModifierStage {
  PostCollision = 3,
  PostDynamics = 1,
  PreCollision = 2,
  PreDynamics = 0,
}

New Type MonoTouch.SceneKit.SCNParticleOrientationMode

[Serializable]
public enum SCNParticleOrientationMode {
  BillboardScreenAligned = 0,
  BillboardViewAligned = 1,
  BillboardYAligned = 3,
  Free = 2,
}

New Type MonoTouch.SceneKit.SCNParticlePropertyController

public class SCNParticlePropertyController : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNParticlePropertyController (MonoTouch.Foundation.NSCoder coder);
  public SCNParticlePropertyController (MonoTouch.Foundation.NSObjectFlag t);
  public SCNParticlePropertyController (System.IntPtr handle);
  // properties
  public virtual MonoTouch.CoreAnimation.CAAnimation Animation { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float InputBias { get; set; }
  public virtual SCNParticleInputMode InputMode { get; set; }
  public virtual SCNNode InputOrigin { get; set; }
  public virtual MonoTouch.Foundation.NSString InputProperty { get; set; }
  public virtual float InputScale { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNParticlePropertyController Create (MonoTouch.CoreAnimation.CAAnimation animation);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNParticleSortingMode

[Serializable]
public enum SCNParticleSortingMode {
  Distance = 2,
  None = 0,
  OldestFirst = 3,
  ProjectedDepth = 1,
  YoungestFirst = 4,
}

New Type MonoTouch.SceneKit.SCNParticleSystem

public class SCNParticleSystem : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNParticleSystem (MonoTouch.Foundation.NSCoder coder);
  public SCNParticleSystem (MonoTouch.Foundation.NSObjectFlag t);
  public SCNParticleSystem (System.IntPtr handle);
  // properties
  public virtual SCNVector3 Acceleration { get; set; }
  public virtual bool AffectedByGravity { get; set; }
  public virtual bool AffectedByPhysicsFields { get; set; }
  public virtual SCNParticleBirthDirection BirthDirection { get; set; }
  public virtual SCNParticleBirthLocation BirthLocation { get; set; }
  public virtual float BirthRate { get; set; }
  public virtual float BirthRateVariation { get; set; }
  public virtual bool BlackPassEnabled { get; set; }
  public virtual SCNParticleBlendMode BlendMode { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNNode[] ColliderNodes { get; set; }
  public virtual float DampingFactor { get; set; }
  public virtual float EmissionDuration { get; set; }
  public virtual float EmissionDurationVariation { get; set; }
  public virtual SCNGeometry EmitterShape { get; set; }
  public virtual SCNVector3 EmittingDirection { get; set; }
  public virtual float FresnelExponent { get; set; }
  public virtual float IdleDuration { get; set; }
  public virtual float IdleDurationVariation { get; set; }
  public virtual SCNParticleImageSequenceAnimationMode ImageSequenceAnimationMode { get; set; }
  public virtual uint ImageSequenceColumnCount { get; set; }
  public virtual float ImageSequenceFrameRate { get; set; }
  public virtual float ImageSequenceFrameRateVariation { get; set; }
  public virtual float ImageSequenceInitialFrame { get; set; }
  public virtual float ImageSequenceInitialFrameVariation { get; set; }
  public virtual uint ImageSequenceRowCount { get; set; }
  public virtual bool LightingEnabled { get; set; }
  public virtual bool Local { get; set; }
  public virtual bool Loops { get; set; }
  public virtual SCNParticleOrientationMode OrientationMode { get; set; }
  public virtual float ParticleAngle { get; set; }
  public virtual float ParticleAngleVariation { get; set; }
  public virtual float ParticleAngularVelocity { get; set; }
  public virtual float ParticleAngularVelocityVariation { get; set; }
  public virtual float ParticleBounce { get; set; }
  public virtual float ParticleBounceVariation { get; set; }
  public virtual MonoTouch.UIKit.UIColor ParticleColor { get; set; }
  public virtual SCNVector4 ParticleColorVariation { get; set; }
  public virtual bool ParticleDiesOnCollision { get; set; }
  public virtual float ParticleFriction { get; set; }
  public virtual float ParticleFrictionVariation { get; set; }
  public virtual MonoTouch.Foundation.NSObject ParticleImage { get; set; }
  public virtual float ParticleLifeSpan { get; set; }
  public virtual float ParticleLifeSpanVariation { get; set; }
  public virtual float ParticleMass { get; set; }
  public virtual float ParticleMassVariation { get; set; }
  public virtual float ParticleSize { get; set; }
  public virtual float ParticleSizeVariation { get; set; }
  public virtual float ParticleVelocity { get; set; }
  public virtual float ParticleVelocityVariation { get; set; }
  public virtual SCNParticleSortingMode SortingMode { get; set; }
  public virtual float SpeedFactor { get; set; }
  public virtual float SpreadingAngle { get; set; }
  public virtual float StretchFactor { get; set; }
  public virtual SCNParticleSystem SystemSpawnedOnCollision { get; set; }
  public virtual SCNParticleSystem SystemSpawnedOnDying { get; set; }
  public virtual SCNParticleSystem SystemSpawnedOnLiving { get; set; }
  public virtual float WarmupDuration { get; set; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual void AddModifier (MonoTouch.Foundation.NSString[] properties, SCNParticleModifierStage stage, SCNParticleModifierHandler handler);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNParticleSystem Create ();
  public static SCNParticleSystem Create (string name, string directory);
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual void HandleEvent (SCNParticleEvent evnt, MonoTouch.Foundation.NSString[] properties, SCNParticleEventHandler handler);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAllModifiers ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void RemoveModifiers (SCNParticleModifierStage stage);
  public virtual void Reset ();
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNPhysicsBallSocketJoint

public class SCNPhysicsBallSocketJoint : MonoTouch.SceneKit.SCNPhysicsBehavior, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsBallSocketJoint (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsBallSocketJoint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsBallSocketJoint (System.IntPtr handle);
  // properties
  public virtual SCNVector3 AnchorA { get; set; }
  public virtual SCNVector3 AnchorB { get; set; }
  public virtual SCNPhysicsBody BodyA { get; }
  public virtual SCNPhysicsBody BodyB { get; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static SCNPhysicsBallSocketJoint Create (SCNPhysicsBody bodyA, SCNVector3 anchorA, SCNPhysicsBody bodyB, SCNVector3 anchorB);
  public static SCNPhysicsBallSocketJoint Create (SCNPhysicsBody body, SCNVector3 anchor);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNPhysicsBehavior

public class SCNPhysicsBehavior : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsBehavior ();
  public SCNPhysicsBehavior (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsBehavior (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsBehavior (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.SceneKit.SCNPhysicsBody

public class SCNPhysicsBody : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsBody (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsBody (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsBody (System.IntPtr handle);
  // properties
  public virtual bool AllowsResting { get; set; }
  public virtual float AngularDamping { get; set; }
  public virtual SCNVector4 AngularVelocity { get; set; }
  public virtual SCNVector3 AngularVelocityFactor { get; set; }
  public virtual uint CategoryBitMask { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual uint CollisionBitMask { get; set; }
  public virtual float Damping { get; set; }
  public virtual float Friction { get; set; }
  public virtual bool IsResting { get; }
  public virtual float Mass { get; set; }
  public virtual SCNPhysicsShape PhysicsShape { get; set; }
  public virtual float Restitution { get; set; }
  public virtual float RollingFriction { get; set; }
  public virtual SCNPhysicsBodyType Type { get; set; }
  public virtual SCNVector3 Velocity { get; set; }
  public virtual SCNVector3 VelocityFactor { get; set; }
  // methods
  public virtual void ApplyForce (SCNVector3 direction, bool impulse);
  public virtual void ApplyForce (SCNVector3 direction, SCNVector3 position, bool impulse);
  public virtual void ApplyTorque (SCNVector4 torque, bool impulse);
  public virtual void ClearAllForces ();
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNPhysicsBody CreateBody (SCNPhysicsBodyType type, SCNPhysicsShape shape);
  public static SCNPhysicsBody CreateDynamicBody ();
  public static SCNPhysicsBody CreateKinematicBody ();
  public static SCNPhysicsBody CreateStaticBody ();
  protected override void Dispose (bool disposing);
  public virtual void ResetTransform ();
}

New Type MonoTouch.SceneKit.SCNPhysicsBodyType

[Serializable]
public enum SCNPhysicsBodyType {
  Dynamic = 1,
  Kinematic = 2,
  Static = 0,
}

New Type MonoTouch.SceneKit.SCNPhysicsContact

public class SCNPhysicsContact : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsContact (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsContact (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsContact (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float CollisionImpulse { get; }
  public virtual SCNVector3 ContactNormal { get; }
  public virtual SCNVector3 ContactPoint { get; }
  public virtual SCNNode NodeA { get; }
  public virtual SCNNode NodeB { get; }
  public virtual float PenetrationDistance { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNPhysicsContactDelegate

public class SCNPhysicsContactDelegate : MonoTouch.Foundation.NSObject, ISCNPhysicsContactDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsContactDelegate ();
  public SCNPhysicsContactDelegate (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsContactDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsContactDelegate (System.IntPtr handle);
  // methods
  public virtual void DidBeginContact (SCNPhysicsWorld world, SCNPhysicsContact contact);
  public virtual void DidEndContact (SCNPhysicsWorld world, SCNPhysicsContact contact);
  public virtual void DidUpdateContact (SCNPhysicsWorld world, SCNPhysicsContact contact);
}

New Type MonoTouch.SceneKit.SCNPhysicsContactDelegate_Extensions

public static class SCNPhysicsContactDelegate_Extensions {
  // methods
  public static void DidBeginContact (ISCNPhysicsContactDelegate This, SCNPhysicsWorld world, SCNPhysicsContact contact);
  public static void DidEndContact (ISCNPhysicsContactDelegate This, SCNPhysicsWorld world, SCNPhysicsContact contact);
  public static void DidUpdateContact (ISCNPhysicsContactDelegate This, SCNPhysicsWorld world, SCNPhysicsContact contact);
}

New Type MonoTouch.SceneKit.SCNPhysicsContactEventArgs

public class SCNPhysicsContactEventArgs : System.EventArgs {
  // constructors
  public SCNPhysicsContactEventArgs (SCNPhysicsContact contact);
  // properties
  public SCNPhysicsContact Contact { get; set; }
}

New Type MonoTouch.SceneKit.SCNPhysicsField

public class SCNPhysicsField : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsField (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsField (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsField (System.IntPtr handle);
  // properties
  public virtual bool Active { get; set; }
  public virtual uint CategoryBitMask { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNVector3 Direction { get; set; }
  public virtual bool Exclusive { get; set; }
  public virtual float FalloffExponent { get; set; }
  public virtual SCNVector3 HalfExtent { get; set; }
  public virtual float MinimumDistance { get; set; }
  public virtual SCNVector3 Offset { get; set; }
  public virtual SCNPhysicsFieldScope Scope { get; set; }
  public virtual float Strength { get; set; }
  public virtual bool UsesEllipsoidalExtent { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNPhysicsField CreateDragField ();
  public static SCNPhysicsField CreateElectricField ();
  public static SCNPhysicsField CreateLinearGravityField ();
  public static SCNPhysicsField CreateMagneticField ();
  public static SCNPhysicsField CreateNoiseField (float smoothness, float scale, float speed);
  public static SCNPhysicsField CreateRadialGravityField ();
  public static SCNPhysicsField CreateSpringField ();
  public static SCNPhysicsField CreateTurbulenceField ();
  public static SCNPhysicsField CreateVortexField ();
  public static SCNPhysicsField CustomField (SCNFieldForceEvaluator evaluator);
}

New Type MonoTouch.SceneKit.SCNPhysicsFieldScope

[Serializable]
public enum SCNPhysicsFieldScope {
  InsideExtent = 0,
  OutsideExtent = 1,
}

New Type MonoTouch.SceneKit.SCNPhysicsHingeJoint

public class SCNPhysicsHingeJoint : MonoTouch.SceneKit.SCNPhysicsBehavior, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsHingeJoint (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsHingeJoint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsHingeJoint (System.IntPtr handle);
  // properties
  public virtual SCNVector3 AnchorA { get; set; }
  public virtual SCNVector3 AnchorB { get; set; }
  public virtual SCNVector3 AxisA { get; set; }
  public virtual SCNVector3 AxisB { get; set; }
  public virtual SCNPhysicsBody BodyA { get; }
  public virtual SCNPhysicsBody BodyB { get; }
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static SCNPhysicsHingeJoint Create (SCNPhysicsBody bodyA, SCNVector3 axisA, SCNVector3 anchorA, SCNPhysicsBody bodyB, SCNVector3 axisB, SCNVector3 anchorB);
  public static SCNPhysicsHingeJoint Create (SCNPhysicsBody body, SCNVector3 axis, SCNVector3 anchor);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNPhysicsShape

public class SCNPhysicsShape : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsShape (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsShape (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsShape (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNPhysicsShape Create (SCNPhysicsShape[] shapes, SCNVector3[] transforms);
  public static SCNPhysicsShape Create (SCNGeometry geometry, MonoTouch.Foundation.NSDictionary options);
  public static SCNPhysicsShape Create (SCNNode node, SCNPhysicsShapeOptions options);
  public static SCNPhysicsShape Create (SCNNode node, SCNPhysicsShapeType? shapeType, bool? keepAsCompound, SCNVector3? scale);
  public static SCNPhysicsShape Create (SCNGeometry geometry, SCNPhysicsShapeOptions options);
  public static SCNPhysicsShape Create (SCNGeometry geometry, SCNPhysicsShapeType? shapeType, bool? keepAsCompound, SCNVector3? scale);
  public static SCNPhysicsShape Create (SCNNode node, MonoTouch.Foundation.NSDictionary options);
}

New Type MonoTouch.SceneKit.SCNPhysicsShapeOptions

public class SCNPhysicsShapeOptions {
  // constructors
  public SCNPhysicsShapeOptions ();
  // properties
  public bool? KeepAsCompound { get; set; }
  public SCNVector3? Scale { get; set; }
  public SCNPhysicsShapeType? ShapeType { get; set; }
  // methods
  public MonoTouch.Foundation.NSDictionary ToDictionary ();
}

New Type MonoTouch.SceneKit.SCNPhysicsShapeOptionsKeys

public static class SCNPhysicsShapeOptionsKeys {
  // properties
  public static MonoTouch.Foundation.NSString KeepAsCompound { get; }
  public static MonoTouch.Foundation.NSString Scale { get; }
  public static MonoTouch.Foundation.NSString Type { get; }
}

New Type MonoTouch.SceneKit.SCNPhysicsShapeOptionsTypes

public static class SCNPhysicsShapeOptionsTypes {
  // properties
  public static MonoTouch.Foundation.NSString BoundingBox { get; }
  public static MonoTouch.Foundation.NSString ConcavePolyhedron { get; }
  public static MonoTouch.Foundation.NSString ConvexHull { get; }
}

New Type MonoTouch.SceneKit.SCNPhysicsShapeType

[Serializable]
public enum SCNPhysicsShapeType {
  BoundingBox = 1,
  ConcavePolyhedron = 2,
  ConvexHull = 0,
}

New Type MonoTouch.SceneKit.SCNPhysicsSliderJoint

public class SCNPhysicsSliderJoint : MonoTouch.SceneKit.SCNPhysicsBehavior, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsSliderJoint (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsSliderJoint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsSliderJoint (System.IntPtr handle);
  // properties
  public virtual SCNVector3 AnchorA { get; set; }
  public virtual SCNVector3 AnchorB { get; set; }
  public virtual SCNVector3 AxisA { get; set; }
  public virtual SCNVector3 AxisB { get; set; }
  public virtual SCNPhysicsBody BodyA { get; }
  public virtual SCNPhysicsBody BodyB { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float MaximumAngularLimit { get; set; }
  public virtual float MaximumLinearLimit { get; set; }
  public virtual float MinimumAngularLimit { get; set; }
  public virtual float MinimumLinearLimit { get; set; }
  public virtual float MotorMaximumForce { get; set; }
  public virtual float MotorMaximumTorque { get; set; }
  public virtual float MotorTargetAngularVelocity { get; set; }
  public virtual float MotorTargetLinearVelocity { get; set; }
  // methods
  public static SCNPhysicsSliderJoint Create (SCNPhysicsBody bodyA, SCNVector3 axisA, SCNVector3 anchorA, SCNPhysicsBody bodyB, SCNVector3 axisB, SCNVector3 anchorB);
  public static SCNPhysicsSliderJoint Create (SCNPhysicsBody body, SCNVector3 axis, SCNVector3 anchor);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNPhysicsTestKeys

public static class SCNPhysicsTestKeys {
  // properties
  public static MonoTouch.Foundation.NSString BackfaceCulling { get; }
  public static MonoTouch.Foundation.NSString CollisionBitMask { get; }
  public static MonoTouch.Foundation.NSString SearchMode { get; }
}

New Type MonoTouch.SceneKit.SCNPhysicsTestSearchModeAny

public static class SCNPhysicsTestSearchModeAny {
  // properties
  public static MonoTouch.Foundation.NSString All { get; }
  public static MonoTouch.Foundation.NSString Any { get; }
  public static MonoTouch.Foundation.NSString Closest { get; }
}

New Type MonoTouch.SceneKit.SCNPhysicsVehicle

public class SCNPhysicsVehicle : MonoTouch.SceneKit.SCNPhysicsBehavior, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsVehicle (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsVehicle (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsVehicle (System.IntPtr handle);
  // properties
  public virtual SCNPhysicsBody ChassisBody { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float SpeedInKilometersPerHour { get; }
  public virtual SCNPhysicsVehicleWheel[] Wheels { get; }
  // methods
  public virtual void ApplyBrakingForce (float value, int index);
  public virtual void ApplyEngineForce (float value, int index);
  public static SCNPhysicsVehicle Create (SCNPhysicsBody chassisBody, SCNPhysicsVehicleWheel[] wheels);
  protected override void Dispose (bool disposing);
  public virtual void SetSteeringAngle (float value, int index);
}

New Type MonoTouch.SceneKit.SCNPhysicsVehicleWheel

public class SCNPhysicsVehicleWheel : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsVehicleWheel (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsVehicleWheel (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsVehicleWheel (System.IntPtr handle);
  // properties
  public virtual SCNVector3 Axle { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNVector3 ConnectionPosition { get; set; }
  public virtual float FrictionSlip { get; set; }
  public virtual float MaximumSuspensionForce { get; set; }
  public virtual float MaximumSuspensionTravel { get; set; }
  public virtual SCNNode Node { get; }
  public virtual float Radius { get; set; }
  public virtual SCNVector3 SteeringAxis { get; set; }
  public virtual float SuspensionCompression { get; set; }
  public virtual float SuspensionDamping { get; set; }
  public virtual float SuspensionRestLength { get; set; }
  public virtual float SuspensionStiffness { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNPhysicsVehicleWheel Create (SCNNode node);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNPhysicsWorld

public class SCNPhysicsWorld : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPhysicsWorld (MonoTouch.Foundation.NSCoder coder);
  public SCNPhysicsWorld (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPhysicsWorld (System.IntPtr handle);
  // properties
  public virtual SCNPhysicsBehavior[] AllBehaviors { get; }
  public override System.IntPtr ClassHandle { get; }
  public SCNPhysicsContactDelegate ContactDelegate { get; set; }
  public virtual SCNVector3 Gravity { get; set; }
  public virtual float Speed { get; set; }
  public virtual double TimeStep { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakContactDelegate { get; set; }
  // events
  public event System.EventHandler<SCNPhysicsContactEventArgs> DidBeginContact;
  public event System.EventHandler<SCNPhysicsContactEventArgs> DidEndContact;
  public event System.EventHandler<SCNPhysicsContactEventArgs> DidUpdateContact;
  // methods
  public virtual void AddBehavior (SCNPhysicsBehavior behavior);
  public virtual SCNPhysicsContact[] ContactTest (SCNPhysicsBody bodyA, SCNPhysicsBody bodyB, MonoTouch.Foundation.NSDictionary options);
  public virtual SCNPhysicsContact[] ContactTest (SCNPhysicsBody body, MonoTouch.Foundation.NSDictionary options);
  public virtual SCNPhysicsContact[] ConvexSweepTest (SCNPhysicsShape shape, MonoTouch.CoreAnimation.CATransform3D from, MonoTouch.CoreAnimation.CATransform3D to, MonoTouch.Foundation.NSDictionary options);
  protected override void Dispose (bool disposing);
  public virtual SCNHitTestResult[] RayTestWithSegmentFromPoint (SCNVector3 origin, SCNVector3 dest, MonoTouch.Foundation.NSDictionary options);
  public virtual void RemoveAllBehaviors ();
  public virtual void RemoveBehavior (SCNPhysicsBehavior behavior);
  public virtual void UpdateCollisionPairs ();
}

New Type MonoTouch.SceneKit.SCNPlane

public class SCNPlane : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPlane ();
  public SCNPlane (MonoTouch.Foundation.NSCoder coder);
  public SCNPlane (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPlane (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual float Width { get; set; }
  public virtual int WidthSegmentCount { get; set; }
  // methods
  public static SCNPlane Create (float width, float height);
}

New Type MonoTouch.SceneKit.SCNProgram

public class SCNProgram : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNProgram ();
  public SCNProgram (MonoTouch.Foundation.NSCoder coder);
  public SCNProgram (MonoTouch.Foundation.NSObjectFlag t);
  public SCNProgram (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public SCNProgramDelegate Delegate { get; set; }
  public virtual string FragmentShader { get; set; }
  public static MonoTouch.Foundation.NSString MappingChannelKey { get; }
  public virtual bool Opaque { get; set; }
  public virtual string VertexShader { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  public static SCNProgram Create ();
  protected override void Dispose (bool disposing);
  public virtual MonoTouch.Foundation.NSString GetSemanticForSymbol (string symbol);
  public virtual void SetSemantic (MonoTouch.Foundation.NSString geometrySourceSemantic, string symbol, MonoTouch.Foundation.NSDictionary options);
  public void SetSemantic (MonoTouch.Foundation.NSString geometrySourceSemantic, string symbol, SCNProgramSemanticOptions options);
}

New Type MonoTouch.SceneKit.SCNProgramDelegate

public class SCNProgramDelegate : MonoTouch.Foundation.NSObject, ISCNProgramDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNProgramDelegate ();
  public SCNProgramDelegate (MonoTouch.Foundation.NSCoder coder);
  public SCNProgramDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public SCNProgramDelegate (System.IntPtr handle);
  // methods
  public virtual bool BindValue (SCNProgram program, string symbol, uint location, uint programID, SCNRenderer renderer);
  public virtual void HandleError (SCNProgram program, MonoTouch.Foundation.NSError error);
  public virtual bool IsProgramOpaque (SCNProgram program);
  public virtual void UnbindValue (SCNProgram program, string symbol, uint location, uint programID, SCNRenderer renderer);
}

New Type MonoTouch.SceneKit.SCNProgramDelegate_Extensions

public static class SCNProgramDelegate_Extensions {
  // methods
  public static bool BindValue (ISCNProgramDelegate This, SCNProgram program, string symbol, uint location, uint programID, SCNRenderer renderer);
  public static void HandleError (ISCNProgramDelegate This, SCNProgram program, MonoTouch.Foundation.NSError error);
  public static bool IsProgramOpaque (ISCNProgramDelegate This, SCNProgram program);
  public static void UnbindValue (ISCNProgramDelegate This, SCNProgram program, string symbol, uint location, uint programID, SCNRenderer renderer);
}

New Type MonoTouch.SceneKit.SCNProgramSemanticOptions

public class SCNProgramSemanticOptions : MonoTouch.Foundation.DictionaryContainer {
  // constructors
  public SCNProgramSemanticOptions ();
  public SCNProgramSemanticOptions (MonoTouch.Foundation.NSDictionary dictionary);
  // properties
  public uint? ProgrammChannel { get; set; }
}

New Type MonoTouch.SceneKit.SCNPyramid

public class SCNPyramid : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNPyramid ();
  public SCNPyramid (MonoTouch.Foundation.NSCoder coder);
  public SCNPyramid (MonoTouch.Foundation.NSObjectFlag t);
  public SCNPyramid (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual float Length { get; set; }
  public virtual int LengthSegmentCount { get; set; }
  public virtual float Width { get; set; }
  public virtual int WidthSegmentCount { get; set; }
  // methods
  public static SCNPyramid Create (float width, float height, float length);
}

New Type MonoTouch.SceneKit.SCNRenderer

public class SCNRenderer : MonoTouch.Foundation.NSObject, ISCNSceneRenderer, ISCNTechniqueSupport, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNRenderer (MonoTouch.Foundation.NSCoder coder);
  public SCNRenderer (MonoTouch.Foundation.NSObjectFlag t);
  public SCNRenderer (System.IntPtr handle);
  // properties
  public virtual bool AutoenablesDefaultLighting { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual System.IntPtr Context { get; }
  public virtual bool JitteringEnabled { get; set; }
  public virtual bool Loops { get; set; }
  public virtual double NextFrameTimeInSeconds { get; }
  public virtual bool Playing { get; set; }
  public virtual SCNNode PointOfView { get; set; }
  public virtual SCNScene Scene { get; set; }
  public SCNSceneRendererDelegate SceneRendererDelegate { get; set; }
  public virtual double SceneTimeInSeconds { get; set; }
  public virtual bool ShowsStatistics { get; set; }
  public virtual SCNTechnique Technique { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakSceneRendererDelegate { get; set; }
  // methods
  protected override void Dispose (bool disposing);
  public static SCNRenderer FromContext (System.IntPtr context, MonoTouch.Foundation.NSDictionary options);
  public SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, SCNHitTestOptions options);
  public virtual SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.Foundation.NSDictionary options);
  public virtual bool IsNodeInsideFrustum (SCNNode node, SCNNode pointOfView);
  public virtual void Prepare (MonoTouch.Foundation.NSObject[] objects, System.Action<bool> completionHandler);
  public virtual bool Prepare (MonoTouch.Foundation.NSObject obj, System.Func<bool> abortHandler);
  public virtual SCNVector3 ProjectPoint (SCNVector3 point);
  public virtual void Render ();
  public virtual void Render (double timeInSeconds);
  public virtual SCNVector3 UnprojectPoint (SCNVector3 point);
}

New Type MonoTouch.SceneKit.SCNRenderingArguments

public static class SCNRenderingArguments {
  // properties
  public static MonoTouch.Foundation.NSString ModelTransform { get; }
  public static MonoTouch.Foundation.NSString ModelViewProjectionTransform { get; }
  public static MonoTouch.Foundation.NSString ModelViewTransform { get; }
  public static MonoTouch.Foundation.NSString NormalTransform { get; }
  public static MonoTouch.Foundation.NSString ProjectionTransform { get; }
  public static MonoTouch.Foundation.NSString ViewTransform { get; }
}

New Type MonoTouch.SceneKit.SCNScene

public class SCNScene : MonoTouch.Foundation.NSObject, System.Collections.Generic.IEnumerable<SCNNode>, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, System.Collections.IEnumerable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNScene ();
  public SCNScene (MonoTouch.Foundation.NSCoder coder);
  public SCNScene (MonoTouch.Foundation.NSObjectFlag t);
  public SCNScene (System.IntPtr handle);
  // properties
  public virtual SCNMaterialProperty Background { get; }
  public override System.IntPtr ClassHandle { get; }
  public static MonoTouch.Foundation.NSString ExportDestinationUrl { get; }
  public virtual MonoTouch.Foundation.NSObject FogColor { get; set; }
  public virtual float FogDensityExponent { get; set; }
  public virtual float FogEndDistance { get; set; }
  public virtual float FogStartDistance { get; set; }
  public virtual SCNParticleSystem[] ParticleSystems { get; }
  public virtual bool Paused { get; set; }
  public virtual SCNPhysicsWorld PhysicsWorld { get; }
  public virtual SCNNode RootNode { get; }
  // methods
  public void Add (SCNNode node);
  public virtual void AddParticleSystem (SCNParticleSystem system, MonoTouch.CoreAnimation.CATransform3D transform);
  public static SCNScene Create ();
  public static SCNScene Create (string name, string directory, MonoTouch.Foundation.NSDictionary options);
  public static SCNScene Create (string name, string directory, SCNSceneLoadingOptions options);
  protected override void Dispose (bool disposing);
  public static SCNScene FromUrl (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary options, out MonoTouch.Foundation.NSError error);
  public static SCNScene FromUrl (MonoTouch.Foundation.NSUrl url, SCNSceneLoadingOptions options, out MonoTouch.Foundation.NSError error);
  public virtual MonoTouch.Foundation.NSObject GetAttribute (MonoTouch.Foundation.NSString key);
  public virtual System.Collections.Generic.IEnumerator<SCNNode> GetEnumerator ();
  public virtual void RemoveAllParticleSystems ();
  public virtual void RemoveParticleSystem (SCNParticleSystem system);
  public virtual void SetAttribute (MonoTouch.Foundation.NSObject attribute, MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNSceneLoadingOptions

public class SCNSceneLoadingOptions : MonoTouch.Foundation.DictionaryContainer {
  // constructors
  public SCNSceneLoadingOptions ();
  public SCNSceneLoadingOptions (MonoTouch.Foundation.NSDictionary dictionary);
  // properties
  public MonoTouch.Foundation.NSUrl[] AssetDirectoryUrls { get; set; }
  public bool? CheckConsistency { get; set; }
  public bool? ConvertToYUp { get; set; }
  public float? ConvertUnitsToMeters { get; set; }
  public bool? CreateNormalsIfAbsent { get; set; }
  public bool? FlattenScene { get; set; }
  public bool? OverrideAssetURLs { get; set; }
  public bool? StrictConformance { get; set; }
  public bool? UseSafeMode { get; set; }
}

New Type MonoTouch.SceneKit.SCNSceneRenderer

public abstract class SCNSceneRenderer : MonoTouch.Foundation.NSObject, ISCNSceneRenderer, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNSceneRenderer ();
  public SCNSceneRenderer (MonoTouch.Foundation.NSCoder coder);
  public SCNSceneRenderer (MonoTouch.Foundation.NSObjectFlag t);
  public SCNSceneRenderer (System.IntPtr handle);
  // properties
  public virtual bool AutoenablesDefaultLighting { get; set; }
  public virtual System.IntPtr Context { get; }
  public virtual bool JitteringEnabled { get; set; }
  public virtual bool Loops { get; set; }
  public virtual bool Playing { get; set; }
  public virtual SCNNode PointOfView { get; set; }
  public SCNSceneRendererDelegate SceneRendererDelegate { get; set; }
  public virtual double SceneTimeInSeconds { get; set; }
  public virtual bool ShowsStatistics { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakSceneRendererDelegate { get; set; }
  // methods
  public virtual SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.Foundation.NSDictionary options);
  public SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, SCNHitTestOptions options);
  public virtual bool IsNodeInsideFrustum (SCNNode node, SCNNode pointOfView);
  public virtual bool Prepare (MonoTouch.Foundation.NSObject obj, System.Func<bool> abortHandler);
  public virtual void Prepare (MonoTouch.Foundation.NSObject[] objects, System.Action<bool> completionHandler);
  public virtual SCNVector3 ProjectPoint (SCNVector3 point);
  public virtual SCNVector3 UnprojectPoint (SCNVector3 point);
}

New Type MonoTouch.SceneKit.SCNSceneRenderer_Extensions

public static class SCNSceneRenderer_Extensions {
  // methods
  public static SCNHitTestResult[] HitTest (ISCNSceneRenderer This, System.Drawing.PointF thePoint, SCNHitTestOptions options);
  public static bool IsNodeInsideFrustum (ISCNSceneRenderer This, SCNNode node, SCNNode pointOfView);
  public static bool Prepare (ISCNSceneRenderer This, MonoTouch.Foundation.NSObject obj, System.Func<bool> abortHandler);
  public static void Prepare (ISCNSceneRenderer This, MonoTouch.Foundation.NSObject[] objects, System.Action<bool> completionHandler);
  public static SCNVector3 ProjectPoint (ISCNSceneRenderer This, SCNVector3 point);
  public static SCNVector3 UnprojectPoint (ISCNSceneRenderer This, SCNVector3 point);
}

New Type MonoTouch.SceneKit.SCNSceneRendererDelegate

public class SCNSceneRendererDelegate : MonoTouch.Foundation.NSObject, ISCNSceneRendererDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNSceneRendererDelegate ();
  public SCNSceneRendererDelegate (MonoTouch.Foundation.NSCoder coder);
  public SCNSceneRendererDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public SCNSceneRendererDelegate (System.IntPtr handle);
  // methods
  public virtual void DidApplyAnimations (SCNSceneRenderer renderer, double timeInSeconds);
  public virtual void DidRenderScene (SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);
  public virtual void DidSimulatePhysics (SCNSceneRenderer renderer, double timeInSeconds);
  public virtual void Update (SCNSceneRenderer renderer, double timeInSeconds);
  public virtual void WillRenderScene (SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);
}

New Type MonoTouch.SceneKit.SCNSceneRendererDelegate_Extensions

public static class SCNSceneRendererDelegate_Extensions {
  // methods
  public static void DidApplyAnimations (ISCNSceneRendererDelegate This, SCNSceneRenderer renderer, double timeInSeconds);
  public static void DidRenderScene (ISCNSceneRendererDelegate This, SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);
  public static void DidSimulatePhysics (ISCNSceneRendererDelegate This, SCNSceneRenderer renderer, double timeInSeconds);
  public static void Update (ISCNSceneRendererDelegate This, SCNSceneRenderer renderer, double timeInSeconds);
  public static void WillRenderScene (ISCNSceneRendererDelegate This, SCNSceneRenderer renderer, SCNScene scene, double timeInSeconds);
}

New Type MonoTouch.SceneKit.SCNSceneSource

public class SCNSceneSource : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNSceneSource (MonoTouch.Foundation.NSCoder coder);
  public SCNSceneSource (MonoTouch.Foundation.NSObjectFlag t);
  public SCNSceneSource (System.IntPtr handle);
  public SCNSceneSource (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary options);
  public SCNSceneSource (MonoTouch.Foundation.NSUrl url, SCNSceneLoadingOptions options);
  public SCNSceneSource (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSDictionary options);
  public SCNSceneSource (MonoTouch.Foundation.NSData data, SCNSceneLoadingOptions options);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSData Data { get; }
  public virtual MonoTouch.Foundation.NSUrl Url { get; }
  // methods
  protected override void Dispose (bool disposing);
  public static SCNSceneSource FromData (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSDictionary options);
  public static SCNSceneSource FromData (MonoTouch.Foundation.NSData data, SCNSceneLoadingOptions options);
  public static SCNSceneSource FromUrl (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary options);
  public SCNSceneSource FromUrl (MonoTouch.Foundation.NSUrl url, SCNSceneLoadingOptions options);
  public virtual MonoTouch.Foundation.NSObject GetEntryWithIdentifier (string uid, MonoTouch.ObjCRuntime.Class entryClass);
  public virtual MonoTouch.Foundation.NSObject GetProperty (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject[] IdentifiersOfEntriesWithClass (MonoTouch.ObjCRuntime.Class entryClass);
  public virtual SCNScene SceneFromOptions (MonoTouch.Foundation.NSDictionary options, SCNSceneSourceStatusHandler statusHandler);
  public SCNScene SceneFromOptions (SCNSceneLoadingOptions options, SCNSceneSourceStatusHandler statusHandler);
  public virtual SCNScene SceneWithOption (MonoTouch.Foundation.NSDictionary options, out MonoTouch.Foundation.NSError error);
  public SCNScene SceneWithOption (SCNSceneLoadingOptions options, out MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.SceneKit.SCNSceneSourceLoadErrors

public static class SCNSceneSourceLoadErrors {
  // properties
  public static MonoTouch.Foundation.NSString ConsistencyElementIDErrorKey { get; }
  public static MonoTouch.Foundation.NSString ConsistencyElementTypeErrorKey { get; }
  public static MonoTouch.Foundation.NSString ConsistencyLineNumberErrorKey { get; }
  public static MonoTouch.Foundation.NSString DetailedErrorsKey { get; }
}

New Type MonoTouch.SceneKit.SCNSceneSourceLoading

public static class SCNSceneSourceLoading {
  // properties
  public static MonoTouch.Foundation.NSString AnimationImportPolicyDoNotPlay { get; }
  public static MonoTouch.Foundation.NSString AnimationImportPolicyKey { get; }
  public static MonoTouch.Foundation.NSString AnimationImportPolicyPlay { get; }
  public static MonoTouch.Foundation.NSString AnimationImportPolicyPlayRepeatedly { get; }
  public static MonoTouch.Foundation.NSString AnimationImportPolicyPlayUsingSceneTimeBase { get; }
  public static MonoTouch.Foundation.NSString AssetDirectoryURLsKey { get; }
  public static MonoTouch.Foundation.NSString CheckConsistencyKey { get; }
  public static MonoTouch.Foundation.NSString ConvertToYUpKey { get; }
  public static MonoTouch.Foundation.NSString ConvertUnitsToMetersKey { get; }
  public static MonoTouch.Foundation.NSString CreateNormalsIfAbsentKey { get; }
  public static MonoTouch.Foundation.NSString FlattenSceneKey { get; }
  public static MonoTouch.Foundation.NSString OverrideAssetURLsKey { get; }
  public static MonoTouch.Foundation.NSString StrictConformanceKey { get; }
  public static MonoTouch.Foundation.NSString UseSafeModeKey { get; }
}

New Type MonoTouch.SceneKit.SCNSceneSourceProperties

public static class SCNSceneSourceProperties {
  // properties
  public static MonoTouch.Foundation.NSString AssetContributorsKey { get; }
  public static MonoTouch.Foundation.NSString AssetCreatedDateKey { get; }
  public static MonoTouch.Foundation.NSString AssetModifiedDateKey { get; }
  public static MonoTouch.Foundation.NSString AssetUnitKey { get; }
  public static MonoTouch.Foundation.NSString AssetUpAxisKey { get; }
}

New Type MonoTouch.SceneKit.SCNSceneSourceStatus

[Serializable]
public enum SCNSceneSourceStatus {
  Complete = 16,
  Error = -1,
  Parsing = 4,
  Processing = 12,
  Validating = 8,
}

New Type MonoTouch.SceneKit.SCNSceneSourceStatusHandler

public sealed delegate SCNSceneSourceStatusHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNSceneSourceStatusHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (float totalProgress, SCNSceneSourceStatus status, MonoTouch.Foundation.NSError error, ref bool stopLoading, System.AsyncCallback callback, object object);
  public virtual void EndInvoke (ref bool stopLoading, System.IAsyncResult result);
  public virtual void Invoke (float totalProgress, SCNSceneSourceStatus status, MonoTouch.Foundation.NSError error, ref bool stopLoading);
}

New Type MonoTouch.SceneKit.SCNShadable

public class SCNShadable : MonoTouch.Foundation.NSObject, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNShadable ();
  public SCNShadable (MonoTouch.Foundation.NSCoder coder);
  public SCNShadable (MonoTouch.Foundation.NSObjectFlag t);
  public SCNShadable (System.IntPtr handle);
  // properties
  public virtual SCNProgram Program { get; set; }
  public virtual MonoTouch.Foundation.NSDictionary ShaderModifiers { get; set; }
  // methods
  public virtual void HandleBinding (string symbol, SCNBindingHandler handler);
  public virtual void HandleUnbinding (string symbol, SCNBindingHandler handler);
}

New Type MonoTouch.SceneKit.SCNShadable_Extensions

public static class SCNShadable_Extensions {
  // methods
  public static void HandleBinding (ISCNShadable This, string symbol, SCNBindingHandler handler);
  public static void HandleUnbinding (ISCNShadable This, string symbol, SCNBindingHandler handler);
}

New Type MonoTouch.SceneKit.SCNShaderModifiers

public static class SCNShaderModifiers {
  // properties
  public static MonoTouch.Foundation.NSString EntryPointFragment { get; }
  public static MonoTouch.Foundation.NSString EntryPointGeometry { get; }
  public static MonoTouch.Foundation.NSString EntryPointLightingModel { get; }
  public static MonoTouch.Foundation.NSString EntryPointSurface { get; }
}

New Type MonoTouch.SceneKit.SCNShadowMode

[Serializable]
public enum SCNShadowMode {
  Deferred = 1,
  Forward = 0,
  Modulated = 2,
}

New Type MonoTouch.SceneKit.SCNShape

public class SCNShape : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNShape ();
  public SCNShape (MonoTouch.Foundation.NSCoder coder);
  public SCNShape (MonoTouch.Foundation.NSObjectFlag t);
  public SCNShape (System.IntPtr handle);
  // properties
  public virtual SCNChamferMode ChamferMode { get; set; }
  public virtual MonoTouch.UIKit.UIBezierPath ChamferProfile { get; set; }
  public virtual float ChamferRadius { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual float ExtrusionDepth { get; set; }
  public virtual MonoTouch.UIKit.UIBezierPath Path { get; set; }
  // methods
  public static SCNShape Create (MonoTouch.UIKit.UIBezierPath path, float extrusionDepth);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNSkinner

public class SCNSkinner : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNSkinner (MonoTouch.Foundation.NSCoder coder);
  public SCNSkinner (MonoTouch.Foundation.NSObjectFlag t);
  public SCNSkinner (System.IntPtr handle);
  // properties
  public virtual SCNGeometry BaseGeometry { get; set; }
  public virtual MonoTouch.CoreAnimation.CATransform3D BaseGeometryBindTransform { get; set; }
  public virtual SCNGeometrySource BoneIndices { get; }
  public MonoTouch.CoreAnimation.CATransform3D[] BoneInverseBindTransforms { get; }
  public virtual SCNNode[] Bones { get; }
  public virtual SCNGeometrySource BoneWeights { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual SCNNode Skeleton { get; set; }
  // methods
  public static SCNSkinner Create (SCNGeometry baseGeometry, SCNNode[] bones, MonoTouch.CoreAnimation.CATransform3D[] boneInverseBindTransforms, SCNGeometrySource boneWeights, SCNGeometrySource boneIndices);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNSphere

public class SCNSphere : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNSphere (MonoTouch.Foundation.NSCoder coder);
  public SCNSphere (MonoTouch.Foundation.NSObjectFlag t);
  public SCNSphere (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool Geodesic { get; set; }
  public virtual float Radius { get; set; }
  public virtual int SegmentCount { get; set; }
  // methods
  public static SCNSphere Create (float radius);
}

New Type MonoTouch.SceneKit.SCNTechnique

public class SCNTechnique : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTechnique (MonoTouch.Foundation.NSCoder coder);
  public SCNTechnique (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTechnique (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSDictionary DictionaryRepresentation { get; }
  // methods
  public virtual void AddAnimation (MonoTouch.CoreAnimation.CAAnimation animation, MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
  public static SCNTechnique From (MonoTouch.Foundation.NSObject[] techniques);
  public static SCNTechnique From (MonoTouch.Foundation.NSDictionary dictionary);
  public virtual MonoTouch.CoreAnimation.CAAnimation GetAnimation (MonoTouch.Foundation.NSString key);
  public virtual MonoTouch.Foundation.NSString[] GetAnimationKeys ();
  public virtual void HandleBinding (string symbol, SCNBindingHandler handler);
  public virtual bool IsAnimationPaused (MonoTouch.Foundation.NSString key);
  public virtual void PauseAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAllAnimations ();
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key);
  public virtual void RemoveAnimation (MonoTouch.Foundation.NSString key, float duration);
  public virtual void ResumeAnimation (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNTechniqueSupport

public class SCNTechniqueSupport : MonoTouch.Foundation.NSObject, ISCNTechniqueSupport, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTechniqueSupport ();
  public SCNTechniqueSupport (MonoTouch.Foundation.NSCoder coder);
  public SCNTechniqueSupport (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTechniqueSupport (System.IntPtr handle);
  // properties
  public virtual SCNTechnique Technique { get; set; }
}

New Type MonoTouch.SceneKit.SCNTechniqueSupport_Extensions

public static class SCNTechniqueSupport_Extensions {
}

New Type MonoTouch.SceneKit.SCNText

public class SCNText : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNText (MonoTouch.Foundation.NSCoder coder);
  public SCNText (MonoTouch.Foundation.NSObjectFlag t);
  public SCNText (System.IntPtr handle);
  // properties
  public virtual string AlignmentMode { get; set; }
  public virtual MonoTouch.UIKit.UIBezierPath ChamferProfile { get; set; }
  public virtual float ChamferRadius { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual System.Drawing.RectangleF ContainerFrame { get; set; }
  public virtual float ExtrusionDepth { get; set; }
  public virtual float Flatness { get; set; }
  public virtual MonoTouch.UIKit.UIFont Font { get; set; }
  public virtual MonoTouch.Foundation.NSObject String { get; set; }
  public virtual System.Drawing.SizeF TextSize { get; }
  public virtual string TruncationMode { get; set; }
  public virtual bool Wrapped { get; set; }
  // methods
  public static SCNText Create (string str, float extrusionDepth);
  public static SCNText Create (MonoTouch.Foundation.NSAttributedString attributedString, float extrusionDepth);
  public static SCNText Create (MonoTouch.Foundation.NSObject str, float extrusionDepth);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.SceneKit.SCNTorus

public class SCNTorus : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTorus (MonoTouch.Foundation.NSCoder coder);
  public SCNTorus (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTorus (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float PipeRadius { get; set; }
  public virtual int PipeSegmentCount { get; set; }
  public virtual float RingRadius { get; set; }
  public virtual int RingSegmentCount { get; set; }
  // methods
  public static SCNTorus Create (float ringRadius, float pipeRadius);
}

New Type MonoTouch.SceneKit.SCNTransaction

public class SCNTransaction : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTransaction ();
  public SCNTransaction (MonoTouch.Foundation.NSCoder coder);
  public SCNTransaction (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTransaction (System.IntPtr handle);
  // properties
  public static double AnimationDuration { get; set; }
  public static MonoTouch.CoreAnimation.CAMediaTimingFunction AnimationTimingFunction { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public static bool DisableActions { get; set; }
  // methods
  public static void Begin ();
  public static void Commit ();
  public static void Flush ();
  public static void Lock ();
  public static void SetCompletionBlock (MonoTouch.Foundation.NSAction completion);
  public static void SetValueForKey (MonoTouch.Foundation.NSObject value, MonoTouch.Foundation.NSString key);
  public static void Unlock ();
  public virtual MonoTouch.Foundation.NSObject ValueForKey (MonoTouch.Foundation.NSString key);
}

New Type MonoTouch.SceneKit.SCNTransformConstraint

public class SCNTransformConstraint : MonoTouch.SceneKit.SCNConstraint, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTransformConstraint (MonoTouch.Foundation.NSCoder coder);
  public SCNTransformConstraint (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTransformConstraint (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  // methods
  public static SCNTransformConstraint Create (bool inWorldSpace, SCNTransformConstraintHandler transformHandler);
}

New Type MonoTouch.SceneKit.SCNTransformConstraintHandler

public sealed delegate SCNTransformConstraintHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
  // constructors
  public SCNTransformConstraintHandler (object object, System.IntPtr method);
  // methods
  public virtual System.IAsyncResult BeginInvoke (SCNNode node, MonoTouch.CoreAnimation.CATransform3D transform, System.AsyncCallback callback, object object);
  public virtual MonoTouch.CoreAnimation.CATransform3D EndInvoke (System.IAsyncResult result);
  public virtual MonoTouch.CoreAnimation.CATransform3D Invoke (SCNNode node, MonoTouch.CoreAnimation.CATransform3D transform);
}

New Type MonoTouch.SceneKit.SCNTransparencyMode

[Serializable]
public enum SCNTransparencyMode {
  AOne = 0,
  RgbZero = 1,
}

New Type MonoTouch.SceneKit.SCNTube

public class SCNTube : MonoTouch.SceneKit.SCNGeometry, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, ISCNAnimatable, ISCNBoundingVolume, ISCNShadable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public SCNTube ();
  public SCNTube (MonoTouch.Foundation.NSCoder coder);
  public SCNTube (MonoTouch.Foundation.NSObjectFlag t);
  public SCNTube (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual float Height { get; set; }
  public virtual int HeightSegmentCount { get; set; }
  public virtual float InnerRadius { get; set; }
  public virtual float OuterRadius { get; set; }
  public virtual int RadialSegmentCount { get; set; }
  // methods
  public static SCNTube Create (float innerRadius, float outerRadius, float height);
}

New Type MonoTouch.SceneKit.SCNVector3

public struct SCNVector3 {
  // constructors
  public SCNVector3 (float x, float y, float z);
  public SCNVector3 (OpenTK.Vector3 vector);
  // fields
  public float X;
  public float Y;
  public float Z;
  // methods
  public static OpenTK.Vector3 op_Explicit (SCNVector3 source);
  public static SCNVector3 op_Implicit (OpenTK.Vector3 vector);
}

New Type MonoTouch.SceneKit.SCNVector4

public struct SCNVector4 {
  // constructors
  public SCNVector4 (float x, float y, float z, float w);
  public SCNVector4 (OpenTK.Vector4 vector);
  // fields
  public float W;
  public float X;
  public float Y;
  public float Z;
  // methods
  public static OpenTK.Vector4 op_Explicit (SCNVector4 source);
  public static SCNVector4 op_Implicit (OpenTK.Vector4 vector);
}

New Type MonoTouch.SceneKit.SCNView

public class SCNView : MonoTouch.UIKit.UIView, ISCNSceneRenderer, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIAccessibilityIdentification, MonoTouch.UIKit.IUIDynamicItem, MonoTouch.UIKit.IUITraitEnvironment {
  // constructors
  public SCNView (MonoTouch.Foundation.NSCoder coder);
  public SCNView (MonoTouch.Foundation.NSObjectFlag t);
  public SCNView (System.IntPtr handle);
  public SCNView (System.Drawing.RectangleF frame, MonoTouch.Foundation.NSDictionary options);
  public SCNView (System.Drawing.RectangleF frame);
  // properties
  public virtual bool AllowsCameraControl { get; set; }
  public static SCNView.SCNViewAppearance Appearance { get; }
  public virtual bool AutoenablesDefaultLighting { get; set; }
  public virtual MonoTouch.UIKit.UIColor BackgroundColor { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.OpenGLES.EAGLContext Context { get; set; }
  public virtual bool JitteringEnabled { get; set; }
  public virtual bool Loops { get; set; }
  public virtual bool Playing { get; set; }
  public virtual SCNNode PointOfView { get; set; }
  public virtual SCNScene Scene { get; set; }
  public SCNSceneRendererDelegate SceneRendererDelegate { get; set; }
  public virtual double SceneTimeInSeconds { get; set; }
  public virtual bool ShowsStatistics { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakSceneRendererDelegate { get; set; }
  // methods
  public static SCNView.SCNViewAppearance AppearanceWhenContainedIn (System.Type[] containers);
  protected override void Dispose (bool disposing);
  public static SCNView.SCNViewAppearance GetAppearance<T> ();
  public virtual SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, MonoTouch.Foundation.NSDictionary options);
  public SCNHitTestResult[] HitTest (System.Drawing.PointF thePoint, SCNHitTestOptions options);
  public virtual bool IsNodeInsideFrustum (SCNNode node, SCNNode pointOfView);
  public virtual void Pause (MonoTouch.Foundation.NSObject sender);
  public virtual void Play (MonoTouch.Foundation.NSObject sender);
  public virtual void Prepare (MonoTouch.Foundation.NSObject[] objects, System.Action<bool> completionHandler);
  public virtual bool Prepare (MonoTouch.Foundation.NSObject obj, System.Func<bool> abortHandler);
  public virtual SCNVector3 ProjectPoint (SCNVector3 point);
  public virtual MonoTouch.UIKit.UIImage Snapshot ();
  public virtual void Stop (MonoTouch.Foundation.NSObject sender);
  public virtual SCNVector3 UnprojectPoint (SCNVector3 point);

  // inner types
  public class SCNViewAppearance : MonoTouch.UIKit.UIView+UIViewAppearance, MonoTouch.UIKit.IUIAppearance, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  }
}

New Type MonoTouch.SceneKit.SCNWrapMode

[Serializable]
public enum SCNWrapMode {
  Clamp = 0,
  ClampToBorder = 2,
  Mirror = 3,
  Repeat = 1,
}

New Namespace MonoTouch.WebKit

New Type MonoTouch.WebKit.IWKNavigationDelegate

public interface IWKNavigationDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.WebKit.IWKScriptMessageHandler

public interface IWKScriptMessageHandler : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // methods
  public virtual void DidReceiveScriptMessage (WKUserContentController userContentController, WKScriptMessage message);
}

New Type MonoTouch.WebKit.IWKUIDelegate

public interface IWKUIDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
}

New Type MonoTouch.WebKit.WKBackForwardList

public class WKBackForwardList : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKBackForwardList (MonoTouch.Foundation.NSCoder coder);
  public WKBackForwardList (MonoTouch.Foundation.NSObjectFlag t);
  public WKBackForwardList (System.IntPtr handle);
  // properties
  public virtual WKBackForwardListItem BackItem { get; }
  public virtual WKBackForwardListItem[] BackList { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual WKBackForwardListItem CurrentItem { get; }
  public virtual WKBackForwardListItem ForwardItem { get; }
  public virtual WKBackForwardListItem[] ForwardList { get; }
  // methods
  protected override void Dispose (bool disposing);
  public virtual WKBackForwardListItem ItemAtIndex (int index);
}

New Type MonoTouch.WebKit.WKBackForwardListItem

public class WKBackForwardListItem : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKBackForwardListItem (MonoTouch.Foundation.NSCoder coder);
  public WKBackForwardListItem (MonoTouch.Foundation.NSObjectFlag t);
  public WKBackForwardListItem (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSUrl InitialUrl { get; }
  public virtual string Title { get; }
  public virtual MonoTouch.Foundation.NSUrl Url { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKFrameInfo

public class WKFrameInfo : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKFrameInfo ();
  public WKFrameInfo (MonoTouch.Foundation.NSCoder coder);
  public WKFrameInfo (MonoTouch.Foundation.NSObjectFlag t);
  public WKFrameInfo (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual bool MainFrame { get; }
  public virtual MonoTouch.Foundation.NSUrlRequest Request { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKNavigation

public class WKNavigation : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKNavigation ();
  public WKNavigation (MonoTouch.Foundation.NSCoder coder);
  public WKNavigation (MonoTouch.Foundation.NSObjectFlag t);
  public WKNavigation (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual MonoTouch.Foundation.NSError Error { get; }
  public virtual MonoTouch.Foundation.NSUrlRequest InitialRequest { get; }
  public virtual MonoTouch.Foundation.NSUrlRequest Request { get; }
  public virtual MonoTouch.Foundation.NSUrlResponse Response { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKNavigationAction

public class WKNavigationAction : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKNavigationAction ();
  public WKNavigationAction (MonoTouch.Foundation.NSCoder coder);
  public WKNavigationAction (MonoTouch.Foundation.NSObjectFlag t);
  public WKNavigationAction (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual WKNavigationType NavigationType { get; }
  public virtual MonoTouch.Foundation.NSUrlRequest Request { get; }
  public virtual WKFrameInfo SourceFrame { get; }
  public virtual WKFrameInfo TargetFrame { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKNavigationActionPolicy

[Serializable]
public enum WKNavigationActionPolicy {
  Allow = 1,
  Cancel = 0,
}

New Type MonoTouch.WebKit.WKNavigationDelegate

public class WKNavigationDelegate : MonoTouch.Foundation.NSObject, IWKNavigationDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKNavigationDelegate ();
  public WKNavigationDelegate (MonoTouch.Foundation.NSCoder coder);
  public WKNavigationDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public WKNavigationDelegate (System.IntPtr handle);
  // methods
  public virtual void DecidePolicy (WKWebView webView, WKNavigationAction navigationAction, System.Action<WKNavigationActionPolicy> decisionHandler);
  public virtual void DecidePolicy (WKWebView webView, WKNavigationResponse navigationResponse, System.Action<WKNavigationResponsePolicy> decisionHandler);
  public virtual void DidCommitNavigation (WKWebView webView, WKNavigation navigation);
  public virtual void DidFailNavigation (WKWebView webView, WKNavigation navigation, MonoTouch.Foundation.NSError error);
  public virtual void DidFailProvisionalNavigation (WKWebView webView, WKNavigation navigation, MonoTouch.Foundation.NSError error);
  public virtual void DidFinishNavigation (WKWebView webView, WKNavigation navigation);
  public virtual void DidReceiveServerRedirectForProvisionalNavigation (WKWebView webView, WKNavigation navigation);
  public virtual void DidStartProvisionalNavigation (WKWebView webView, WKNavigation navigation);
}

New Type MonoTouch.WebKit.WKNavigationDelegate_Extensions

public static class WKNavigationDelegate_Extensions {
  // methods
  public static void DecidePolicy (IWKNavigationDelegate This, WKWebView webView, WKNavigationAction navigationAction, System.Action<WKNavigationActionPolicy> decisionHandler);
  public static void DecidePolicy (IWKNavigationDelegate This, WKWebView webView, WKNavigationResponse navigationResponse, System.Action<WKNavigationResponsePolicy> decisionHandler);
  public static void DidCommitNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation);
  public static void DidFailNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation, MonoTouch.Foundation.NSError error);
  public static void DidFailProvisionalNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation, MonoTouch.Foundation.NSError error);
  public static void DidFinishNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation);
  public static void DidReceiveServerRedirectForProvisionalNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation);
  public static void DidStartProvisionalNavigation (IWKNavigationDelegate This, WKWebView webView, WKNavigation navigation);
}

New Type MonoTouch.WebKit.WKNavigationResponse

public class WKNavigationResponse : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKNavigationResponse ();
  public WKNavigationResponse (MonoTouch.Foundation.NSCoder coder);
  public WKNavigationResponse (MonoTouch.Foundation.NSObjectFlag t);
  public WKNavigationResponse (System.IntPtr handle);
  // properties
  public virtual bool CanShowMimeType { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool IsForMainFrame { get; }
  public virtual MonoTouch.Foundation.NSUrlResponse Response { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKNavigationResponsePolicy

[Serializable]
public enum WKNavigationResponsePolicy {
  Allow = 1,
  Cancel = 0,
}

New Type MonoTouch.WebKit.WKNavigationType

[Serializable]
public enum WKNavigationType {
  BackForward = 2,
  FormResubmitted = 4,
  FormSubmitted = 1,
  LinkActivated = 0,
  Other = -1,
  Reload = 3,
}

New Type MonoTouch.WebKit.WKPreferences

public class WKPreferences : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKPreferences ();
  public WKPreferences (MonoTouch.Foundation.NSCoder coder);
  public WKPreferences (MonoTouch.Foundation.NSObjectFlag t);
  public WKPreferences (System.IntPtr handle);
  public WKPreferences (string userDefaultsKeyPrefix);
  // properties
  public virtual bool AllowsInlineMediaPlayback { get; set; }
  public override System.IntPtr ClassHandle { get; }
  public virtual bool JavaScriptCanOpenWindowsAutomatically { get; set; }
  public virtual bool JavaScriptEnabled { get; set; }
  public virtual bool MediaPlaybackAllowsAirPlay { get; set; }
  public virtual bool MediaPlaybackRequiresUserAction { get; set; }
  public virtual float MinimumFontSize { get; set; }
  public virtual bool SuppressesIncrementalRendering { get; set; }
  public virtual string UserDefaultsKeyPrefix { get; }
}

New Type MonoTouch.WebKit.WKProcessPool

public class WKProcessPool : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKProcessPool ();
  public WKProcessPool (MonoTouch.Foundation.NSCoder coder);
  public WKProcessPool (MonoTouch.Foundation.NSObjectFlag t);
  public WKProcessPool (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.WebKit.WKScriptMessage

public class WKScriptMessage : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKScriptMessage ();
  public WKScriptMessage (MonoTouch.Foundation.NSCoder coder);
  public WKScriptMessage (MonoTouch.Foundation.NSObjectFlag t);
  public WKScriptMessage (System.IntPtr handle);
  // properties
  public virtual MonoTouch.Foundation.NSObject Body { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual string Name { get; }
  public virtual WKWebView WebView { get; }
  // methods
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKScriptMessageHandler

public abstract class WKScriptMessageHandler : MonoTouch.Foundation.NSObject, IWKScriptMessageHandler, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKScriptMessageHandler ();
  public WKScriptMessageHandler (MonoTouch.Foundation.NSCoder coder);
  public WKScriptMessageHandler (MonoTouch.Foundation.NSObjectFlag t);
  public WKScriptMessageHandler (System.IntPtr handle);
  // methods
  public virtual void DidReceiveScriptMessage (WKUserContentController userContentController, WKScriptMessage message);
}

New Type MonoTouch.WebKit.WKScriptMessageHandler_Extensions

public static class WKScriptMessageHandler_Extensions {
}

New Type MonoTouch.WebKit.WKUIDelegate

public class WKUIDelegate : MonoTouch.Foundation.NSObject, IWKUIDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKUIDelegate ();
  public WKUIDelegate (MonoTouch.Foundation.NSCoder coder);
  public WKUIDelegate (MonoTouch.Foundation.NSObjectFlag t);
  public WKUIDelegate (System.IntPtr handle);
  // methods
  public virtual WKWebView CreateWebView (WKWebView webView, WKWebViewConfiguration configuration, WKNavigationAction navigationAction, WKWindowFeatures windowFeatures);
  public virtual void RunJavaScriptAlertPanel (WKWebView webView, string message, WKFrameInfo frame, System.Action completionHandler);
  public virtual void RunJavaScriptConfirmPanel (WKWebView webView, string message, WKFrameInfo frame, System.Action<bool> completionHandler);
  public virtual void RunJavaScriptTextInputPanel (WKWebView webView, string prompt, string defaultText, WKFrameInfo frame, System.Action<string> completionHandler);
}

New Type MonoTouch.WebKit.WKUIDelegate_Extensions

public static class WKUIDelegate_Extensions {
  // methods
  public static WKWebView CreateWebView (IWKUIDelegate This, WKWebView webView, WKWebViewConfiguration configuration, WKNavigationAction navigationAction, WKWindowFeatures windowFeatures);
  public static void RunJavaScriptAlertPanel (IWKUIDelegate This, WKWebView webView, string message, WKFrameInfo frame, System.Action completionHandler);
  public static void RunJavaScriptConfirmPanel (IWKUIDelegate This, WKWebView webView, string message, WKFrameInfo frame, System.Action<bool> completionHandler);
  public static void RunJavaScriptTextInputPanel (IWKUIDelegate This, WKWebView webView, string prompt, string defaultText, WKFrameInfo frame, System.Action<string> completionHandler);
}

New Type MonoTouch.WebKit.WKUserContentController

public class WKUserContentController : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKUserContentController ();
  public WKUserContentController (MonoTouch.Foundation.NSCoder coder);
  public WKUserContentController (MonoTouch.Foundation.NSObjectFlag t);
  public WKUserContentController (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual WKUserScript[] UserScripts { get; }
  // methods
  public virtual void AddScriptMessageHandler (WKScriptMessageHandler scriptMessageHandler, string name);
  public virtual void AddUserScript (WKUserScript userScript);
  protected override void Dispose (bool disposing);
  public virtual void RemoveAllUserScripts ();
  public virtual void RemoveScriptMessageHandler (string name);
}

New Type MonoTouch.WebKit.WKUserScript

public class WKUserScript : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKUserScript (MonoTouch.Foundation.NSCoder coder);
  public WKUserScript (MonoTouch.Foundation.NSObjectFlag t);
  public WKUserScript (System.IntPtr handle);
  public WKUserScript (string source, WKUserScriptInjectionTime injectionTime, bool isForMainFrameOnly);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual WKUserScriptInjectionTime InjectionTime { get; }
  public virtual bool IsForMainFrameOnly { get; }
  public virtual string Source { get; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.WebKit.WKUserScriptInjectionTime

[Serializable]
public enum WKUserScriptInjectionTime {
  AtDocumentEnd = 1,
  AtDocumentStart = 0,
}

New Type MonoTouch.WebKit.WKWebView

public class WKWebView : MonoTouch.UIKit.UIView, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIAccessibilityIdentification, MonoTouch.UIKit.IUIDynamicItem, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKWebView (MonoTouch.Foundation.NSCoder coder);
  public WKWebView (MonoTouch.Foundation.NSObjectFlag t);
  public WKWebView (System.IntPtr handle);
  public WKWebView (System.Drawing.RectangleF frame, WKWebViewConfiguration configuration);
  // properties
  public virtual bool AllowsBackForwardNavigationGestures { get; set; }
  public static WKWebView.WKWebViewAppearance Appearance { get; }
  public virtual WKBackForwardList BackForwardList { get; }
  public virtual bool CanGoBack { get; }
  public virtual bool CanGoForward { get; }
  public override System.IntPtr ClassHandle { get; }
  public virtual WKWebViewConfiguration Configuration { get; }
  public virtual double EstimatedProgress { get; }
  public virtual bool HasOnlySecureContent { get; }
  public virtual bool IsLoading { get; }
  public WKNavigationDelegate NavigationDelegate { get; set; }
  public virtual string Title { get; }
  public WKUIDelegate UIDelegate { get; set; }
  public virtual MonoTouch.Foundation.NSUrl Url { get; }
  public virtual MonoTouch.Foundation.NSObject WeakNavigationDelegate { get; set; }
  public virtual MonoTouch.Foundation.NSObject WeakUIDelegate { get; set; }
  // methods
  public static WKWebView.WKWebViewAppearance AppearanceWhenContainedIn (System.Type[] containers);
  protected override void Dispose (bool disposing);
  public static WKWebView.WKWebViewAppearance GetAppearance<T> ();
  public virtual WKNavigation GoBack ();
  public virtual WKNavigation GoForward ();
  public virtual WKNavigation GoTo (WKBackForwardListItem item);
  public virtual WKNavigation LoadRequest (MonoTouch.Foundation.NSUrlRequest request);
  public virtual WKNavigation Reload ();
  public virtual WKNavigation ReloadFromOrigin ();
  public virtual void StopLoading ();

  // inner types
  public class WKWebViewAppearance : MonoTouch.UIKit.UIView+UIViewAppearance, MonoTouch.UIKit.IUIAppearance, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  }
}

New Type MonoTouch.WebKit.WKWebViewConfiguration

public class WKWebViewConfiguration : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKWebViewConfiguration ();
  public WKWebViewConfiguration (MonoTouch.Foundation.NSCoder coder);
  public WKWebViewConfiguration (MonoTouch.Foundation.NSObjectFlag t);
  public WKWebViewConfiguration (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
  public virtual WKPreferences Preferences { get; set; }
  public virtual WKProcessPool ProcessPool { get; set; }
  public virtual WKUserContentController UserContentController { get; set; }
  // methods
  public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
  protected override void Dispose (bool disposing);
}

New Type MonoTouch.WebKit.WKWindowFeatures

public class WKWindowFeatures : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
  // constructors
  public WKWindowFeatures ();
  public WKWindowFeatures (MonoTouch.Foundation.NSCoder coder);
  public WKWindowFeatures (MonoTouch.Foundation.NSObjectFlag t);
  public WKWindowFeatures (System.IntPtr handle);
  // properties
  public override System.IntPtr ClassHandle { get; }
}


MonoTouch.Dialog-1.dll

Namespace MonoTouch.Dialog

Type Changed: MonoTouch.Dialog.BaseBooleanImageElement

Type Changed: MonoTouch.Dialog.BaseBooleanImageElement.TextWithImageCellView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.Dialog.DialogViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.Dialog.GlassButton

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.Dialog.MessageSummaryView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.Dialog.RefreshTableHeaderView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment


MonoTouch.NUnitLite.dll

Namespace MonoTouch.NUnit.UI

Type Changed: MonoTouch.NUnit.UI.TouchViewController

Added interfaces:

  MonoTouch.UIKit.IUIContentContainer
  MonoTouch.UIKit.IUITraitEnvironment


OpenTK.dll

Namespace OpenTK.Platform.iPhoneOS

Type Changed: OpenTK.Platform.iPhoneOS.iPhoneOSGameView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment


OpenTK-1.0.dll

Namespace OpenTK.Platform.iPhoneOS

Type Changed: OpenTK.Platform.iPhoneOS.iPhoneOSGameView

Added interface:

  MonoTouch.UIKit.IUITraitEnvironment


Xamarin Workbook

If it's not already installed, install the Xamarin Workbooks app first. The workbook file should download automatically, but if it doesn't, just click to start the workbook download manually.