From 7.4.0 to 8.0.0

monotouch.dll

Namespace MonoTouch

Type Changed: MonoTouch.Constants

Removed fields:

public static const string CoreServicesLibrary = "/System/Library/Frameworks/CoreServices.framework/CoreServices";
    public static const string Version = "7.4.0";

Added fields:

public static const string AVKitLibrary = "/System/Library/Frameworks/AVKit.framework/AVKit";
    public static const string CloudKitLibrary = "/System/Library/Frameworks/CloudKit.framework/CloudKit";
    public static const string CoreAudioKitLibrary = "/System/Library/Frameworks/CoreAudioKit.framework/CoreAudioKit";
    public static const string CoreMotionLibrary = "System/Library/Frameworks/CoreMotion.framework/CoreMotion";
    public static const string CoreServicesLibrary = "/System/Library/Frameworks/MobileCoreServices.framework/MobileCoreServices";
    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 = "8.0.0";
    public static const string VideoToolboxLibrary = "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox";

Namespace MonoTouch.Accounts

Type Changed: MonoTouch.Accounts.ACErrorCode

Added values:

CoreDataSaveFailed = 18,
    DeniedByPlugin = 17,
    FailedSerializingAccountInfo = 19,
    InvalidCommand = 20,
    MissingMessageID = 21,

Namespace MonoTouch.AddressBook

Type Changed: MonoTouch.AddressBook.ABPerson

Added methods:

public static ABPropertyType GetPropertyType (int propertyId);
    public static string LocalizedPropertyName (int propertyId);

Type Changed: MonoTouch.AddressBook.ABRecord

Added method:

public static ABRecord FromHandle (System.IntPtr handle);

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; }

Added methods:

public static ABPeoplePickerNavigationController.ABPeoplePickerNavigationControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static ABPeoplePickerNavigationController.ABPeoplePickerNavigationControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationControllerDelegate

Added methods:

public virtual void DidSelectPerson (ABPeoplePickerNavigationController peoplePicker, MonoTouch.AddressBook.ABPerson selectedPerson);
    public virtual void DidSelectPerson (ABPeoplePickerNavigationController peoplePicker, MonoTouch.AddressBook.ABPerson selectedPerson, int propertyId, System.IntPtr abMultiValueIdentifier);

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationControllerDelegate_Extensions

Added methods:

public static void DidSelectPerson (IABPeoplePickerNavigationControllerDelegate This, ABPeoplePickerNavigationController peoplePicker, MonoTouch.AddressBook.ABPerson selectedPerson);
    public static void DidSelectPerson (IABPeoplePickerNavigationControllerDelegate This, ABPeoplePickerNavigationController peoplePicker, MonoTouch.AddressBook.ABPerson selectedPerson, int propertyId, 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

Type Changed: MonoTouch.AddressBookUI.IABPeoplePickerNavigationControllerDelegate

Added interface:

MonoTouch.UIKit.IUINavigationControllerDelegate

New Type MonoTouch.AddressBookUI.ABPersonPredicateKey

public static class ABPersonPredicateKey {
    // properties
    public static MonoTouch.Foundation.NSString Birthday { get; }
    public static MonoTouch.Foundation.NSString Dates { get; }
    public static MonoTouch.Foundation.NSString DepartmentName { get; }
    public static MonoTouch.Foundation.NSString EmailAddresses { get; }
    public static MonoTouch.Foundation.NSString FamilyName { get; }
    public static MonoTouch.Foundation.NSString GivenName { get; }
    public static MonoTouch.Foundation.NSString InstantMessageAddresses { get; }
    public static MonoTouch.Foundation.NSString JobTitle { get; }
    public static MonoTouch.Foundation.NSString MiddleName { get; }
    public static MonoTouch.Foundation.NSString NamePrefix { get; }
    public static MonoTouch.Foundation.NSString NameSuffix { get; }
    public static MonoTouch.Foundation.NSString Nickname { get; }
    public static MonoTouch.Foundation.NSString Note { get; }
    public static MonoTouch.Foundation.NSString OrganizationName { get; }
    public static MonoTouch.Foundation.NSString PhoneNumbers { get; }
    public static MonoTouch.Foundation.NSString PhoneticFamilyName { get; }
    public static MonoTouch.Foundation.NSString PhoneticGivenName { get; }
    public static MonoTouch.Foundation.NSString PhoneticMiddleName { get; }
    public static MonoTouch.Foundation.NSString PostalAddresses { get; }
    public static MonoTouch.Foundation.NSString PreviousFamilyName { get; }
    public static MonoTouch.Foundation.NSString RelatedNames { get; }
    public static MonoTouch.Foundation.NSString SocialProfiles { get; }
    public static MonoTouch.Foundation.NSString UrlAddresses { get; }
}

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);

Type Changed: MonoTouch.AudioToolbox.AudioFormatType

Added value:

AMRWideBand = 1935767394,

Type Changed: MonoTouch.AudioToolbox.AudioQueueStatus

Added value:

BufferEnqueuedTwice = -66666,

Type Changed: MonoTouch.AudioToolbox.AudioStreamBasicDescription

Added fields:

public static AudioFormatFlags AudioFormatFlagsAudioUnitNativeFloat;
    public static AudioFormatFlags AudioFormatFlagsNativeFloat;

Obsoleted field:

[Obsolete ("Canonical is no longer encouraged, since fixed-point no longer provides a performance advantage over floating point.   AudioFormatFlagsNativeFloatPacked is preffered instead")]
    public static AudioFormatFlags AudioFormatFlagsAudioUnitCanonical;

Namespace MonoTouch.AudioUnit

Type Changed: MonoTouch.AudioUnit.AudioTypeConverter

Added value:

RoundTripAAC = 1918984547,

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:

Distance = 2,
    Elevation = 1,
    Enable = 5,
    Gain = 3,
    GlobalReverbGain = 9,
    MaxGain = 7,
    MinGain = 6,
    ObstructionAttenuation = 11,
    OcclussionAttenuation = 10,
    PlaybackRate = 4,
    ReverbBlend = 8,
    ReverbFilterEnable = 18,
    ReverbFilterType = 17,
    RoundTripAacEncodingStrategy = 1,
    RoundTripAacFormat = 0,
    RoundTripAacRateOrQuality = 2,
    SpacialMixerAzimuth = 0,
    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,
    MidiSynthEnablePreload = 4119,
    ParameterIDName = 34,
    ParameterStringFromValue = 33,
    ParameterValueFromString = 38,
    RenderingFlags = 3003,
    ReverbRoomType = 10,
    SoundBankURL = 1100,
    SpatializationAlgorithm = 3000,
    UsesInternalReverb = 1005,

New Type MonoTouch.AudioUnit.AudioComponentDescriptionNative

public struct AudioComponentDescriptionNative {
    // constructors
    public AudioComponentDescriptionNative (AudioComponentDescription other);
    // fields
    public AudioComponentFlag ComponentFlags;
    public int ComponentFlagsMask;
    public AudioComponentManufacturerType ComponentManufacturer;
    public int ComponentSubType;
    public AudioComponentType ComponentType;
}

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 ShouldWaitForRenewalOfRequestedResource (AVAssetResourceLoader resourceLoader, AVAssetResourceRenewalRequest renewalRequest);
    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 ShouldWaitForRenewalOfRequestedResource (IAVAssetResourceLoaderDelegate This, AVAssetResourceLoader resourceLoader, AVAssetResourceRenewalRequest renewalRequest);
    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 properties:

public virtual MonoTouch.Foundation.NSString[] AvailableMediaTypes { get; }
    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 SetPassHandler (MonoTouch.CoreFoundation.DispatchQueue queue, System.Action passHandler);

Type Changed: MonoTouch.AVFoundation.AVAudioSession

Added properties:

public virtual AVAudioSessionRecordPermission RecordPermission { get; }
    public virtual bool SecondaryAudioShouldBeSilencedHint { get; }
    public static MonoTouch.Foundation.NSString SilenceSecondaryAudioHintNotification { get; }

Type Changed: MonoTouch.AVFoundation.AVAudioSession.Notifications

Added method:

public static MonoTouch.Foundation.NSObject ObserveSilenceSecondaryAudioHint (System.EventHandler<AVAudioSessionSecondaryAudioHintEventArgs> handler);

Type Changed: MonoTouch.AVFoundation.AVAudioSessionErrorCode

Added value:

InsufficientPriority = 561017449,

Type Changed: MonoTouch.AVFoundation.AVCaptureConnection

Added constructors:

public AVCaptureConnection (AVCaptureInputPort[] inputPorts, AVCaptureOutput output);
    public AVCaptureConnection (AVCaptureInputPort inputPort, AVCaptureVideoPreviewLayer layer);

Added properties:

public virtual AVCaptureVideoStabilizationMode ActiveVideoStabilizationMode { get; }
    public virtual AVCaptureVideoStabilizationMode PreferredVideoStabilizationMode { get; set; }

Type Changed: MonoTouch.AVFoundation.AVCaptureDevice

Added properties:

public virtual bool AutomaticallyAdjustsVideoHdrEnabled { get; set; }
    public virtual AVCaptureWhiteBalanceGains DeviceWhiteBalanceGains { get; }
    public virtual MonoTouch.CoreMedia.CMTime ExposureDuration { get; }
    public static MonoTouch.CoreMedia.CMTime ExposureDurationCurrent { get; }
    public virtual float ExposureTargetBias { get; }
    public static float ExposureTargetBiasCurrent { get; }
    public virtual float ExposureTargetOffset { get; }
    public static float FocusModeLensPositionCurrent { get; }
    public virtual AVCaptureWhiteBalanceGains GrayWorldDeviceWhiteBalanceGains { get; }
    public virtual float ISO { get; }
    public static float ISOCurrent { get; }
    public virtual float LensAperture { get; }
    public virtual float LensPosition { get; }
    public static float LensPositionCurrent { get; }
    public virtual float MaxExposureTargetBias { get; }
    public virtual float MaxWhiteBalanceGain { get; }
    public virtual float MinExposureTargetBias { get; }
    public virtual bool SubjectAreaChangeMonitoringEnabled { get; set; }
    public virtual bool VideoHdrEnabled { get; set; }
    public static AVCaptureWhiteBalanceGains WhiteBalanceGainsCurrent { get; }

Added methods:

public virtual AVCaptureWhiteBalanceChromaticityValues GetChromaticityValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
    public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceChromaticityValues chromaticityValues);
    public virtual AVCaptureWhiteBalanceGains GetDeviceWhiteBalanceGains (AVCaptureWhiteBalanceTemperatureAndTintValues tempAndTintValues);
    public virtual AVCaptureWhiteBalanceTemperatureAndTintValues GetTemperatureAndTintValues (AVCaptureWhiteBalanceGains whiteBalanceGains);
    public virtual void LockExposure (MonoTouch.CoreMedia.CMTime duration, float ISO, System.Action<MonoTouch.CoreMedia.CMTime> completionHandler);
    public virtual System.Threading.Tasks.Task<MonoTouch.CoreMedia.CMTime> LockExposureAsync (MonoTouch.CoreMedia.CMTime duration, float ISO);
    public virtual void SetExposureTargetBias (float bias, System.Action<MonoTouch.CoreMedia.CMTime> completionHandler);
    public virtual System.Threading.Tasks.Task<MonoTouch.CoreMedia.CMTime> SetExposureTargetBiasAsync (float bias);
    public virtual void SetFocusModeLocked (float lensPosition, System.Action<MonoTouch.CoreMedia.CMTime> completionHandler);
    public virtual System.Threading.Tasks.Task<MonoTouch.CoreMedia.CMTime> SetFocusModeLockedAsync (float lensPosition);
    public virtual void SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGains (AVCaptureWhiteBalanceGains whiteBalanceGains, System.Action<MonoTouch.CoreMedia.CMTime> completionHandler);
    public virtual System.Threading.Tasks.Task<MonoTouch.CoreMedia.CMTime> SetWhiteBalanceModeLockedWithDeviceWhiteBalanceGainsAsync (AVCaptureWhiteBalanceGains whiteBalanceGains);

Type Changed: MonoTouch.AVFoundation.AVCaptureDeviceFormat

Added properties:

public virtual AVCaptureAutoFocusSystem AutoFocusSystem { get; }
    public virtual System.Drawing.Size HighResolutionStillImageDimensions { get; }
    public virtual MonoTouch.CoreMedia.CMTime MaxExposureDuration { get; }
    public virtual float MaxISO { get; }
    public virtual MonoTouch.CoreMedia.CMTime MinExposureDuration { get; }
    public virtual float MinISO { get; }
    public virtual bool videoHDRSupportedVideoHDREnabled { get; }

Added method:

public virtual bool IsVideoStabilizationModeSupported (AVCaptureVideoStabilizationMode mode);

Type Changed: MonoTouch.AVFoundation.AVCaptureDevicePosition

Added value:

Unspecified = 0,

Type Changed: MonoTouch.AVFoundation.AVCaptureExposureMode

Added value:

Custom = 3,

Type Changed: MonoTouch.AVFoundation.AVCaptureFileOutput

Added method:

public void StartRecordingToOutputFile (MonoTouch.Foundation.NSUrl outputFileUrl, System.Action<MonoTouch.Foundation.NSObject[]> startRecordingFromConnections, System.Action<MonoTouch.Foundation.NSObject[],MonoTouch.Foundation.NSError> finishedRecording);

Type Changed: MonoTouch.AVFoundation.AVCaptureFocusMode

Added values:

AutoFocus = 1,
    ContinuousAutoFocus = 2,
    Locked = 0,

Obsoleted fields:

[Obsolete ("use AutoFocus instead")]
    ModeAutoFocus = 1,

    [Obsolete ("use ContinuousAutoFocus instead")]
    ModeContinuousAutoFocus = 2,

    [Obsolete ("use Locked instead")]
    ModeLocked = 0,

Type Changed: MonoTouch.AVFoundation.AVCaptureSession

Added methods:

public virtual void AddConnection (AVCaptureConnection connection);
    public virtual void AddInputWithNoConnections (AVCaptureInput input);
    public virtual void AddOutputWithNoConnections (AVCaptureOutput output);
    public virtual bool CanAddConnection (AVCaptureConnection connection);
    public virtual void RemoveConnection (AVCaptureConnection connection);

Type Changed: MonoTouch.AVFoundation.AVCaptureStillImageOutput

Added properties:

public virtual bool HighResolutionStillImageOutputEnabled { get; set; }
    public virtual uint MaxBracketedCaptureStillImageCount { get; }

Added methods:

public virtual void CaptureStillImageBracket (AVCaptureConnection connection, AVCaptureBracketedStillImageSettings[] settings, System.Action<MonoTouch.CoreMedia.CMSampleBuffer,MonoTouch.AVFoundation.AVCaptureBracketedStillImageSettings,MonoTouch.Foundation.NSError> imageHandler);
    public virtual void PrepareToCaptureStillImageBracket (AVCaptureConnection connection, AVCaptureBracketedStillImageSettings[] settings, System.Action<System.Boolean,MonoTouch.Foundation.NSError> handler);

Type Changed: MonoTouch.AVFoundation.AVCaptureVideoPreviewLayer

Added methods:

public static AVCaptureVideoPreviewLayer CreateWithNoConnection (AVCaptureSession session);
    public virtual void SetSessionWithNoConnection (AVCaptureSession session);

Type Changed: MonoTouch.AVFoundation.AVError

Added values:

FailedToParse2 = -11853,
    FileTypeDoesNotSupportSampleReferences = -11854,
    UndecodableMediaData = -11855,

Type Changed: MonoTouch.AVFoundation.AVMediaSelectionGroup

Added property:

public virtual AVMediaSelectionOption DefaultOption { get; }

Type Changed: MonoTouch.AVFoundation.AVMetadata

Added properties:

public static MonoTouch.Foundation.NSString FormatHlsMetadata { get; }
    public static MonoTouch.Foundation.NSString IcyMetadataKeyStreamTitle { get; }
    public static MonoTouch.Foundation.NSString IcyMetadataKeyStreamUrl { get; }
    public static MonoTouch.Foundation.NSString IsoUserDataKeyTaggedCharacteristic { get; }
    public static MonoTouch.Foundation.NSString KeySpaceIcy { get; }

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.AVMetadataItem

Removed properties:

public virtual MonoTouch.CoreMedia.CMTime Duration { get; }
    public virtual MonoTouch.Foundation.NSDictionary ExtraAttributes { get; }
    public virtual string KeySpace { get; }
    public virtual MonoTouch.Foundation.NSLocale Locale { get; }
    public virtual MonoTouch.CoreMedia.CMTime Time { get; }
    public virtual MonoTouch.Foundation.NSObject Value { get; }

Added properties:

public virtual MonoTouch.Foundation.NSString DataType { get; set; }
    public virtual MonoTouch.CoreMedia.CMTime Duration { get; set; }
    public virtual string ExtendedLanguageTag { get; set; }
    public virtual MonoTouch.Foundation.NSDictionary ExtraAttributes { get; set; }
    public virtual string KeySpace { get; set; }
    public virtual MonoTouch.Foundation.NSLocale Locale { get; set; }
    public virtual MonoTouch.Foundation.NSString MetadataIdentifier { get; set; }
    public virtual MonoTouch.CoreMedia.CMTime Time { get; set; }
    public virtual MonoTouch.Foundation.NSObject Value { get; set; }

Added methods:

public static AVMetadataItem[] FilterWithIdentifier (AVMetadataItem[] metadataItems, MonoTouch.Foundation.NSString metadataIdentifer);
    public static MonoTouch.Foundation.NSObject GetKeyForIdentifier (MonoTouch.Foundation.NSString identifier);
    public static MonoTouch.Foundation.NSString GetKeySpaceForIdentifier (MonoTouch.Foundation.NSString identifier);
    public static MonoTouch.Foundation.NSString GetMetadataIdentifier (MonoTouch.Foundation.NSObject key, MonoTouch.Foundation.NSString keySpace);

Type Changed: MonoTouch.AVFoundation.AVMetadataObject

Added properties:

public static MonoTouch.Foundation.NSString TypeDataMatrixCode { get; }
    public static MonoTouch.Foundation.NSString TypeInterleaved2of5Code { get; }
    public static MonoTouch.Foundation.NSString TypeITF14Code { get; }

Type Changed: MonoTouch.AVFoundation.AVMutableMetadataItem

Removed properties:

public virtual MonoTouch.CoreMedia.CMTime Duration { get; set; }
    public virtual MonoTouch.Foundation.NSDictionary ExtraAttributes { get; set; }
    public virtual string KeySpace { get; set; }
    public virtual MonoTouch.Foundation.NSLocale Locale { get; set; }
    public virtual MonoTouch.CoreMedia.CMTime Time { get; set; }
    public virtual MonoTouch.Foundation.NSObject Value { get; set; }

Added properties:

public override MonoTouch.Foundation.NSString DataType { get; set; }
    public override MonoTouch.CoreMedia.CMTime Duration { get; set; }
    public override string ExtendedLanguageTag { get; set; }
    public override MonoTouch.Foundation.NSDictionary ExtraAttributes { get; set; }
    public override string KeySpace { get; set; }
    public override MonoTouch.Foundation.NSLocale Locale { get; set; }
    public override MonoTouch.Foundation.NSString MetadataIdentifier { get; set; }
    public override MonoTouch.CoreMedia.CMTime Time { get; set; }
    public override MonoTouch.Foundation.NSObject Value { get; set; }

Type Changed: MonoTouch.AVFoundation.AVPlayerItem

Added property:

public virtual double PreferredPeakBitRate { get; set; }

Type Changed: MonoTouch.AVFoundation.AVTimedMetadataGroup

Added constructor:

public AVTimedMetadataGroup (MonoTouch.CoreMedia.CMSampleBuffer sampleBuffer);

Added method:

public virtual MonoTouch.CoreMedia.CMFormatDescription CopyFormatDescription ();

Type Changed: MonoTouch.AVFoundation.AVUrlAsset

Removed constructor:

public AVUrlAsset (MonoTouch.Foundation.NSUrl URL, MonoTouch.Foundation.NSDictionary options);

Added constructor:

public AVUrlAsset (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary options);

Added property:

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

Removed method:

public static AVUrlAsset FromUrl (MonoTouch.Foundation.NSUrl URL, MonoTouch.Foundation.NSDictionary options);

Added method:

public static AVUrlAsset FromUrl (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary options);

Type Changed: MonoTouch.AVFoundation.AVVideoCodecSettings

Removed properties:

public AVVideoPixelAspectRatioSettings PixelAspectRatio { set; }
    public AVVideoCleanApertureSettings VideoCleanAperture { set; }

Added properties:

public AVVideoPixelAspectRatioSettings PixelAspectRatio { get; set; }
    public AVVideoCleanApertureSettings VideoCleanAperture { get; set; }

Type Changed: MonoTouch.AVFoundation.AVVideoSettingsCompressed

Removed properties:

public AVVideoCodec? Codec { set; }
    public AVVideoCodecSettings CodecSettings { set; }
    public AVVideoScalingMode? ScalingMode { set; }

Added properties:

public AVVideoCodec? Codec { get; set; }
    public AVVideoCodecSettings CodecSettings { get; set; }
    public AVVideoScalingMode? ScalingMode { get; set; }

Type Changed: MonoTouch.AVFoundation.AVVideoSettingsUncompressed

Removed property:

public AVVideoScalingMode? ScalingMode { set; }

Added property:

public AVVideoScalingMode? ScalingMode { get; set; }

Type Changed: MonoTouch.AVFoundation.IAVPlayerItemLegibleOutputPushDelegate

Added interface:

IAVPlayerItemOutputPushDelegate

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
    public static AVAssetReaderOutputMetadataAdaptor Create (AVAssetReaderTrackOutput trackOutput);
    protected override void Dispose (bool disposing);
    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
    public static AVAssetReaderSampleReferenceOutput Create (AVAssetTrack track);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.AVFoundation.AVAssetResourceRenewalRequest

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

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);
    public static AVAssetWriterInputMetadataAdaptor Create (AVAssetWriterInput input);
    protected override void Dispose (bool disposing);
}

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.AVAudio3DAngularOrientation

public struct AVAudio3DAngularOrientation {
    // fields
    public float Pitch;
    public float Roll;
    public float Yaw;
    // methods
    public override bool Equals (object obj);
    public bool Equals (AVAudio3DAngularOrientation other);
    public override int GetHashCode ();
    public static bool op_Equality (AVAudio3DAngularOrientation left, AVAudio3DAngularOrientation right);
    public static bool op_Inequality (AVAudio3DAngularOrientation left, AVAudio3DAngularOrientation right);
    public override string ToString ();
}

New Type MonoTouch.AVFoundation.AVAudio3DMixing

public abstract class AVAudio3DMixing : MonoTouch.Foundation.NSObject, IAVAudio3DMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudio3DMixing ();
    public AVAudio3DMixing (MonoTouch.Foundation.NSCoder coder);
    public AVAudio3DMixing (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudio3DMixing (System.IntPtr handle);
    // properties
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudio3DMixing_Extensions

public static class AVAudio3DMixing_Extensions {
}

New Type MonoTouch.AVFoundation.AVAudio3DMixingRenderingAlgorithm

[Serializable]
public enum AVAudio3DMixingRenderingAlgorithm {
    EqualPowerPanning = 0,
    HRTF = 2,
    SoundField = 3,
    SphericalHead = 1,
    StereoPassThrough = 5,
}

New Type MonoTouch.AVFoundation.AVAudio3DVectorOrientation

public struct AVAudio3DVectorOrientation {
    // constructors
    public AVAudio3DVectorOrientation (OpenTK.Vector3 forward, OpenTK.Vector3 up);
    // fields
    public OpenTK.Vector3 Forward;
    public OpenTK.Vector3 Up;
    // methods
    public override bool Equals (object obj);
    public bool Equals (AVAudio3DVectorOrientation other);
    public override int GetHashCode ();
    public static bool op_Equality (AVAudio3DVectorOrientation left, AVAudio3DVectorOrientation right);
    public static bool op_Inequality (AVAudio3DVectorOrientation left, AVAudio3DVectorOrientation right);
    public override string ToString ();
}

New Type MonoTouch.AVFoundation.AVAudioBuffer

public class AVAudioBuffer : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioBuffer (MonoTouch.Foundation.NSCoder coder);
    public AVAudioBuffer (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioBuffer (System.IntPtr handle);
    // properties
    public MonoTouch.AudioToolbox.AudioBuffers AudioBufferList { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioFormat Format { get; }
    public MonoTouch.AudioToolbox.AudioBuffers MutableAudioBufferList { get; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    protected override void Dispose (bool disposing);
    public virtual MonoTouch.Foundation.NSObject MutableCopy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.AVFoundation.AVAudioChannelLayout

public class AVAudioChannelLayout : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioChannelLayout (MonoTouch.AudioToolbox.AudioChannelLayout layout);
    public AVAudioChannelLayout ();
    public AVAudioChannelLayout (MonoTouch.Foundation.NSCoder coder);
    public AVAudioChannelLayout (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioChannelLayout (System.IntPtr handle);
    public AVAudioChannelLayout (uint layoutTag);
    // properties
    public virtual uint ChannelCount { get; }
    public override System.IntPtr ClassHandle { get; }
    public MonoTouch.AudioToolbox.AudioChannelLayout Layout { get; }
    public virtual uint LayoutTag { get; }
    // methods
    public override bool Equals (object obj);
    public override int GetHashCode ();
    public static bool op_Equality (AVAudioChannelLayout a, AVAudioChannelLayout b);
    public static bool op_Inequality (AVAudioChannelLayout a, AVAudioChannelLayout b);
}

New Type MonoTouch.AVFoundation.AVAudioCommonFormat

[Serializable]
public enum AVAudioCommonFormat {
    Other = 0,
    PCMFloat32 = 1,
    PCMFloat64 = 2,
    PCMInt16 = 3,
    PCMInt32 = 4,
}

New Type MonoTouch.AVFoundation.AVAudioEngine

public class AVAudioEngine : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioEngine ();
    public AVAudioEngine (MonoTouch.Foundation.NSCoder coder);
    public AVAudioEngine (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioEngine (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public static MonoTouch.Foundation.NSString ConfigurationChangeNotification { get; }
    public virtual AVAudioInputNode InputNode { get; }
    public virtual AVAudioMixerNode MainMixerNode { get; }
    public virtual MonoTouch.AudioToolbox.MusicSequence MusicSequence { get; set; }
    public virtual AVAudioOutputNode OutputNode { get; }
    public virtual bool Running { get; }
    // methods
    public virtual void AttachNode (AVAudioNode node);
    public virtual void Connect (AVAudioNode sourceNode, AVAudioNode targetNode, uint sourceBus, uint targetBus, AVAudioFormat format);
    public virtual void Connect (AVAudioNode sourceNode, AVAudioNode targetNode, AVAudioFormat format);
    public virtual void DetachNode (AVAudioNode node);
    public virtual void DisconnectNodeInput (AVAudioNode node, uint bus);
    public virtual void DisconnectNodeInput (AVAudioNode node);
    public virtual void DisconnectNodeOutput (AVAudioNode node);
    public virtual void DisconnectNodeOutput (AVAudioNode node, uint bus);
    protected override void Dispose (bool disposing);
    public virtual void Pause ();
    public virtual void Prepare ();
    public virtual void Reset ();
    public virtual bool StartAndReturnError (out MonoTouch.Foundation.NSError outError);
    public virtual void Stop ();

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

New Type MonoTouch.AVFoundation.AVAudioEnvironmentDistanceAttenuationModel

[Serializable]
public enum AVAudioEnvironmentDistanceAttenuationModel {
    Exponential = 1,
    Inverse = 2,
    Linear = 3,
}

New Type MonoTouch.AVFoundation.AVAudioEnvironmentDistanceAttenuationParameters

public class AVAudioEnvironmentDistanceAttenuationParameters : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioEnvironmentDistanceAttenuationParameters (MonoTouch.Foundation.NSCoder coder);
    public AVAudioEnvironmentDistanceAttenuationParameters (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioEnvironmentDistanceAttenuationParameters (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioEnvironmentDistanceAttenuationModel DistanceAttenuationModel { get; set; }
    public virtual float MaximumDistance { get; set; }
    public virtual float ReferenceDistance { get; set; }
    public virtual float RolloffFactor { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioEnvironmentNode

public class AVAudioEnvironmentNode : MonoTouch.AVFoundation.AVAudioNode, IAVAudio3DMixing, IAVAudioMixing, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioEnvironmentNode ();
    public AVAudioEnvironmentNode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioEnvironmentNode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioEnvironmentNode (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioEnvironmentDistanceAttenuationParameters DistanceAttenuationParameters { get; }
    public virtual AVAudio3DAngularOrientation ListenerAngularOrientation { get; set; }
    public virtual OpenTK.Vector3 ListenerPosition { get; set; }
    public virtual AVAudio3DVectorOrientation ListenerVectorOrientation { get; set; }
    public virtual uint NextAvailableInputBus { get; }
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual float OutputVolume { get; set; }
    public virtual float Pan { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
    public virtual AVAudioEnvironmentReverbParameters ReverbParameters { get; }
    public virtual float Volume { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject[] ApplicableRenderingAlgorithms ();
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.AVFoundation.AVAudioEnvironmentReverbParameters

public class AVAudioEnvironmentReverbParameters : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioEnvironmentReverbParameters (MonoTouch.Foundation.NSCoder coder);
    public AVAudioEnvironmentReverbParameters (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioEnvironmentReverbParameters (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual bool Enable { get; set; }
    public virtual AVAudioUnitEQFilterParameters FilterParameters { get; }
    public virtual float Level { get; set; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual void LoadFactoryReverbPreset (AVAudioUnitReverbPreset preset);
}

New Type MonoTouch.AVFoundation.AVAudioFile

public class AVAudioFile : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioFile ();
    public AVAudioFile (MonoTouch.Foundation.NSUrl fileUrl, AudioSettings settings, out MonoTouch.Foundation.NSError outError);
    public AVAudioFile (MonoTouch.Foundation.NSUrl fileUrl, AVAudioCommonFormat format, bool interleaved, out MonoTouch.Foundation.NSError outError);
    public AVAudioFile (MonoTouch.Foundation.NSUrl fileUrl, out MonoTouch.Foundation.NSError outError);
    public AVAudioFile (System.IntPtr handle);
    public AVAudioFile (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioFile (MonoTouch.Foundation.NSCoder coder);
    public AVAudioFile (MonoTouch.Foundation.NSUrl fileUrl, AudioSettings settings, AVAudioCommonFormat format, bool interleaved, out MonoTouch.Foundation.NSError outError);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioFormat FileFormat { get; }
    public virtual long FramePosition { get; set; }
    public virtual long Length { get; }
    public virtual AVAudioFormat ProcessingFormat { get; }
    public virtual MonoTouch.Foundation.NSUrl Url { get; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual bool ReadIntoBuffer (AVAudioPcmBuffer buffer, out MonoTouch.Foundation.NSError outError);
    public virtual bool ReadIntoBuffer (AVAudioPcmBuffer buffer, uint frames, out MonoTouch.Foundation.NSError outError);
    public virtual bool WriteFromBuffer (AVAudioPcmBuffer buffer, out MonoTouch.Foundation.NSError outError);
}

New Type MonoTouch.AVFoundation.AVAudioFormat

public class AVAudioFormat : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioFormat ();
    public AVAudioFormat (MonoTouch.Foundation.NSDictionary settings);
    public AVAudioFormat (AVAudioCommonFormat format, double sampleRate, bool interleaved, AVAudioChannelLayout layout);
    public AVAudioFormat (AVAudioCommonFormat format, double sampleRate, uint channels, bool interleaved);
    public AVAudioFormat (double sampleRate, AVAudioChannelLayout layout);
    public AVAudioFormat (double sampleRate, uint channels);
    public AVAudioFormat (ref MonoTouch.AudioToolbox.AudioStreamBasicDescription description, AVAudioChannelLayout layout);
    public AVAudioFormat (ref MonoTouch.AudioToolbox.AudioStreamBasicDescription description);
    public AVAudioFormat (System.IntPtr handle);
    public AVAudioFormat (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioFormat (MonoTouch.Foundation.NSCoder coder);
    public AVAudioFormat (AudioSettings settings);
    // properties
    public virtual uint ChannelCount { get; }
    public virtual AVAudioChannelLayout ChannelLayout { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioCommonFormat CommonFormat { get; }
    public virtual bool Interleaved { get; }
    public virtual double SampleRate { get; }
    public AudioSettings Settings { get; }
    public virtual bool Standard { get; }
    public virtual MonoTouch.AudioToolbox.AudioStreamBasicDescription StreamDescription { get; }
    public virtual MonoTouch.Foundation.NSDictionary WeakSettings { get; }
    // methods
    protected override void Dispose (bool disposing);
    public override bool Equals (object obj);
    public override int GetHashCode ();
    public static bool op_Equality (AVAudioFormat a, AVAudioFormat b);
    public static bool op_Inequality (AVAudioFormat a, AVAudioFormat b);
}

New Type MonoTouch.AVFoundation.AVAudioInputNode

public class AVAudioInputNode : MonoTouch.AVFoundation.AVAudioIONode, IAVAudio3DMixing, IAVAudioMixing, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioInputNode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioInputNode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioInputNode (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual float Pan { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
    public virtual float Volume { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioIONode

public class AVAudioIONode : MonoTouch.AVFoundation.AVAudioNode, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioIONode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioIONode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioIONode (System.IntPtr handle);
    // properties
    public virtual MonoTouch.AudioUnit.AudioUnit AudioUnit { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual double PresentationLatency { get; }
}

New Type MonoTouch.AVFoundation.AVAudioMixerNode

public class AVAudioMixerNode : MonoTouch.AVFoundation.AVAudioNode, IAVAudio3DMixing, IAVAudioMixing, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioMixerNode ();
    public AVAudioMixerNode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioMixerNode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioMixerNode (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual uint NextAvailableInputBus { get; }
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual float OutputVolume { get; set; }
    public virtual float Pan { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
    public virtual float Volume { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioMixing_Extensions

public static class AVAudioMixing_Extensions {
}

New Type MonoTouch.AVFoundation.AVAudioNode

public class AVAudioNode : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioNode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioNode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioNode (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioEngine Engine { get; }
    public virtual AVAudioTime LastRenderTime { get; }
    public virtual uint NumberOfInputs { get; }
    public virtual uint NumberOfOutputs { get; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual AVAudioFormat GetBusInputFormat (uint bus);
    public virtual AVAudioFormat GetBusOutputFormat (uint bus);
    public virtual string GetNameForInputBus (uint bus);
    public virtual string GetNameForOutputBus (uint bus);
    public virtual void InstallTapOnBus (uint bus, uint bufferSize, AVAudioFormat format, AVAudioNodeTapBlock tapBlock);
    public virtual void RemoveTapOnBus (uint bus);
    public virtual void Reset ();
}

New Type MonoTouch.AVFoundation.AVAudioNodeTapBlock

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

New Type MonoTouch.AVFoundation.AVAudioOutputNode

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

New Type MonoTouch.AVFoundation.AVAudioPcmBuffer

public class AVAudioPcmBuffer : MonoTouch.AVFoundation.AVAudioBuffer, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSMutableCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioPcmBuffer (MonoTouch.Foundation.NSCoder coder);
    public AVAudioPcmBuffer (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioPcmBuffer (System.IntPtr handle);
    public AVAudioPcmBuffer (AVAudioFormat format, uint frameCapacity);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual System.IntPtr FloatChannelData { get; }
    public virtual uint FrameCapacity { get; }
    public virtual uint FrameLength { get; set; }
    public virtual System.IntPtr Int16ChannelData { get; }
    public virtual System.IntPtr Int32ChannelData { get; }
    public virtual uint Stride { get; }
}

New Type MonoTouch.AVFoundation.AVAudioPlayerNode

public class AVAudioPlayerNode : MonoTouch.AVFoundation.AVAudioNode, IAVAudio3DMixing, IAVAudioMixing, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioPlayerNode ();
    public AVAudioPlayerNode (MonoTouch.Foundation.NSCoder coder);
    public AVAudioPlayerNode (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioPlayerNode (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual float Pan { get; set; }
    public virtual bool Playing { get; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
    public virtual float Volume { get; set; }
    // methods
    public virtual AVAudioTime GetNodeTimeFromPlayerTime (AVAudioTime playerTime);
    public virtual AVAudioTime GetPlayerTimeFromNodeTime (AVAudioTime nodeTime);
    public virtual void Pause ();
    public virtual void Play ();
    public virtual void PlayAtTime (AVAudioTime when);
    public virtual void PrepareWithFrameCount (uint frameCount);
    public virtual void ScheduleBuffer (AVAudioPcmBuffer buffer, System.Action completionHandler);
    public virtual void ScheduleBuffer (AVAudioPcmBuffer buffer, AVAudioTime when, AVAudioPlayerNodeBufferOptions options, System.Action completionHandler);
    public virtual void ScheduleFile (AVAudioFile file, AVAudioTime when, System.Action completionHandler);
    public virtual void ScheduleSegment (AVAudioFile file, long startFrame, uint numberFrames, AVAudioTime when, System.Action completionHandler);
    public virtual void Stop ();
}

New Type MonoTouch.AVFoundation.AVAudioPlayerNodeBufferOptions

[Serializable]
[Flags]
public enum AVAudioPlayerNodeBufferOptions {
    Interrupts = 2,
    InterruptsAtLoop = 4,
    Loops = 1,
}

New Type MonoTouch.AVFoundation.AVAudioSessionRecordPermission

[Serializable]
public enum AVAudioSessionRecordPermission {
    Denied = 1684369017,
    Granted = 1735552628,
    Undetermined = 1970168948,
}

New Type MonoTouch.AVFoundation.AVAudioSessionSecondaryAudioHintEventArgs

public class AVAudioSessionSecondaryAudioHintEventArgs : MonoTouch.Foundation.NSNotificationEventArgs {
    // constructors
    public AVAudioSessionSecondaryAudioHintEventArgs (MonoTouch.Foundation.NSNotification notification);
    // properties
    public AVAudioSessionSilenceSecondaryAudioHintType Hint { get; }
}

New Type MonoTouch.AVFoundation.AVAudioSessionSilenceSecondaryAudioHintType

[Serializable]
public enum AVAudioSessionSilenceSecondaryAudioHintType {
    Begin = 1,
    End = 0,
}

New Type MonoTouch.AVFoundation.AVAudioStereoMixing

public abstract class AVAudioStereoMixing : MonoTouch.Foundation.NSObject, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioStereoMixing ();
    public AVAudioStereoMixing (MonoTouch.Foundation.NSCoder coder);
    public AVAudioStereoMixing (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioStereoMixing (System.IntPtr handle);
    // properties
    public virtual float Pan { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioStereoMixing_Extensions

public static class AVAudioStereoMixing_Extensions {
}

New Type MonoTouch.AVFoundation.AVAudioTime

public class AVAudioTime : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioTime ();
    public AVAudioTime (long sampleTime, double sampleRate);
    public AVAudioTime (ulong hostTime);
    public AVAudioTime (ref MonoTouch.AudioToolbox.AudioTimeStamp timestamp, double sampleRate);
    public AVAudioTime (System.IntPtr handle);
    public AVAudioTime (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioTime (MonoTouch.Foundation.NSCoder coder);
    public AVAudioTime (ulong hostTime, long sampleTime, double sampleRate);
    // properties
    public virtual MonoTouch.AudioToolbox.AudioTimeStamp AudioTimeStamp { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual ulong HostTime { get; }
    public virtual bool HostTimeValid { get; }
    public virtual double SampleRate { get; }
    public virtual long SampleTime { get; }
    public virtual bool SampleTimeValid { get; }
    // methods
    public virtual AVAudioTime ExtrapolateTimeFromAnchor (AVAudioTime anchorTime);
    public static AVAudioTime FromAudioTimeStamp (ref MonoTouch.AudioToolbox.AudioTimeStamp timestamp, double sampleRate);
    public static AVAudioTime FromHostTime (ulong hostTime);
    public static AVAudioTime FromHostTime (ulong hostTime, long sampleTime, double sampleRate);
    public static AVAudioTime FromSampleTime (long sampleTime, double sampleRate);
    public static ulong HostTimeForSeconds (double seconds);
    public static double SecondsForHostTime (ulong hostTime);
}

New Type MonoTouch.AVFoundation.AVAudioUnit

public class AVAudioUnit : MonoTouch.AVFoundation.AVAudioNode, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnit (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnit (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnit (System.IntPtr handle);
    // properties
    public virtual MonoTouch.AudioUnit.AudioUnit AudioUnit { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual string ManufacturerName { get; }
    public virtual string Name { get; }
    public virtual uint Version { get; }
    // methods
    public virtual bool LoadAudioUnitPreset (MonoTouch.Foundation.NSUrl url, out MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.AVFoundation.AVAudioUnitDelay

public class AVAudioUnitDelay : MonoTouch.AVFoundation.AVAudioUnitEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitDelay ();
    public AVAudioUnitDelay (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitDelay (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitDelay (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual double DelayTime { get; set; }
    public virtual float Feedback { get; set; }
    public virtual float LowPassCutoff { get; set; }
    public virtual float WetDryMix { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitDistortion

public class AVAudioUnitDistortion : MonoTouch.AVFoundation.AVAudioUnitEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitDistortion ();
    public AVAudioUnitDistortion (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitDistortion (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitDistortion (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float PreGain { get; set; }
    public virtual float WetDryMix { get; set; }
    // methods
    public virtual void LoadFactoryPreset (AVAudioUnitDistortionPreset preset);
}

New Type MonoTouch.AVFoundation.AVAudioUnitDistortionPreset

[Serializable]
public enum AVAudioUnitDistortionPreset {
    DrumsBitBrush = 0,
    DrumsBufferBeats = 1,
    DrumsLoFi = 2,
    MultiBrokenSpeaker = 3,
    MultiCellphoneConcert = 4,
    MultiDecimated1 = 5,
    MultiDecimated2 = 6,
    MultiDecimated3 = 7,
    MultiDecimated4 = 8,
    MultiDistortedCubed = 10,
    MultiDistortedFunk = 9,
    MultiDistortedSquared = 11,
    MultiEcho1 = 12,
    MultiEcho2 = 13,
    MultiEchoTight1 = 14,
    MultiEchoTight2 = 15,
    MultiEverythingIsBroken = 16,
    SpeechAlienChatter = 17,
    SpeechCosmicInterference = 18,
    SpeechGoldenPi = 19,
    SpeechRadioTower = 20,
    SpeechWaves = 21,
}

New Type MonoTouch.AVFoundation.AVAudioUnitEffect

public class AVAudioUnitEffect : MonoTouch.AVFoundation.AVAudioUnit, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitEffect (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitEffect (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitEffect (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitEffect (System.IntPtr handle);
    // properties
    public virtual bool Bypass { get; set; }
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitEQ

public class AVAudioUnitEQ : MonoTouch.AVFoundation.AVAudioUnitEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitEQ ();
    public AVAudioUnitEQ (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitEQ (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitEQ (System.IntPtr handle);
    public AVAudioUnitEQ (uint numberOfBands);
    // properties
    public virtual AVAudioUnitEQFilterParameters[] Bands { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual float GlobalGain { get; set; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.AVFoundation.AVAudioUnitEQFilterParameters

public class AVAudioUnitEQFilterParameters : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitEQFilterParameters (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitEQFilterParameters (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitEQFilterParameters (System.IntPtr handle);
    // properties
    public virtual float Bandwidth { get; set; }
    public virtual bool Bypass { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual AVAudioUnitEQFilterType FilterType { get; set; }
    public virtual float Frequency { get; set; }
    public virtual float Gain { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitEQFilterType

[Serializable]
public enum AVAudioUnitEQFilterType {
    BandPass = 5,
    BandStop = 6,
    HighPass = 2,
    HighShelf = 8,
    LowPass = 1,
    LowShelf = 7,
    Parametric = 0,
    ResonantHighPass = 4,
    ResonantHighShelf = 10,
    ResonantLowPass = 3,
    ResonantLowShelf = 9,
}

New Type MonoTouch.AVFoundation.AVAudioUnitGenerator

public class AVAudioUnitGenerator : MonoTouch.AVFoundation.AVAudioUnit, IAVAudio3DMixing, IAVAudioMixing, IAVAudioStereoMixing, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitGenerator (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitGenerator (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitGenerator (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitGenerator (System.IntPtr handle);
    // properties
    public virtual bool Bypass { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual float Pan { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
    public virtual float Volume { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitMidiInstrument

public class AVAudioUnitMidiInstrument : MonoTouch.AVFoundation.AVAudioUnit, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitMidiInstrument (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitMidiInstrument (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitMidiInstrument (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitMidiInstrument (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    // methods
    public virtual void SendController (byte controller, byte value, byte channel);
    public virtual void SendMidiEvent (byte midiStatus, byte data1, byte data2);
    public virtual void SendMidiEvent (byte midiStatus, byte data1);
    public virtual void SendMidiSysExEvent (MonoTouch.Foundation.NSData midiData);
    public virtual void SendPitchBend (ushort pitchbend, byte channel);
    public virtual void SendPressure (byte pressure, byte channel);
    public virtual void SendPressureForKey (byte key, byte value, byte channel);
    public virtual void SendProgramChange (byte program, byte channel);
    public virtual void SendProgramChange (byte program, byte bankMSB, byte bankLSB, byte channel);
    public virtual void StartNote (byte note, byte velocity, byte channel);
    public virtual void StopNote (byte note, byte channel);
}

New Type MonoTouch.AVFoundation.AVAudioUnitReverb

public class AVAudioUnitReverb : MonoTouch.AVFoundation.AVAudioUnitEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitReverb ();
    public AVAudioUnitReverb (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitReverb (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitReverb (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float WetDryMix { get; set; }
    // methods
    public virtual void LoadFactoryPreset (AVAudioUnitReverbPreset preset);
}

New Type MonoTouch.AVFoundation.AVAudioUnitReverbPreset

[Serializable]
public enum AVAudioUnitReverbPreset {
    Cathedral = 8,
    LargeChamber = 7,
    LargeHall = 4,
    LargeHall2 = 12,
    LargeRoom = 2,
    LargeRoom2 = 9,
    MediumChamber = 6,
    MediumHall = 3,
    MediumHall2 = 10,
    MediumHall3 = 11,
    MediumRoom = 1,
    Plate = 5,
    SmallRoom = 0,
}

New Type MonoTouch.AVFoundation.AVAudioUnitSampler

public class AVAudioUnitSampler : MonoTouch.AVFoundation.AVAudioUnitMidiInstrument, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitSampler ();
    public AVAudioUnitSampler (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitSampler (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitSampler (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float GlobalTuning { get; set; }
    public virtual float MasterGain { get; set; }
    public virtual float StereoPan { get; set; }
    // methods
    public virtual bool LoadAudioFiles (MonoTouch.Foundation.NSUrl[] audioFiles, out MonoTouch.Foundation.NSError outError);
    public virtual bool LoadInstrument (MonoTouch.Foundation.NSUrl instrumentUrl, out MonoTouch.Foundation.NSError outError);
    public virtual bool LoadSoundBank (MonoTouch.Foundation.NSUrl bankUrl, byte program, byte bankMSB, byte bankLSB, out MonoTouch.Foundation.NSError outError);
}

New Type MonoTouch.AVFoundation.AVAudioUnitTimeEffect

public class AVAudioUnitTimeEffect : MonoTouch.AVFoundation.AVAudioUnit, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitTimeEffect (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitTimeEffect (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitTimeEffect (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitTimeEffect (System.IntPtr handle);
    // properties
    public virtual bool Bypass { get; set; }
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitTimePitch

public class AVAudioUnitTimePitch : MonoTouch.AVFoundation.AVAudioUnitTimeEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitTimePitch (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitTimePitch ();
    public AVAudioUnitTimePitch (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitTimePitch (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitTimePitch (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float Overlap { get; set; }
    public virtual float Pitch { get; set; }
    public virtual float Rate { get; set; }
}

New Type MonoTouch.AVFoundation.AVAudioUnitVarispeed

public class AVAudioUnitVarispeed : MonoTouch.AVFoundation.AVAudioUnitTimeEffect, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVAudioUnitVarispeed (MonoTouch.AudioUnit.AudioComponentDescription desc);
    public AVAudioUnitVarispeed ();
    public AVAudioUnitVarispeed (MonoTouch.Foundation.NSCoder coder);
    public AVAudioUnitVarispeed (MonoTouch.Foundation.NSObjectFlag t);
    public AVAudioUnitVarispeed (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float Rate { get; set; }
}

New Type MonoTouch.AVFoundation.AVCaptureAutoExposureBracketedStillImageSettings

public class AVCaptureAutoExposureBracketedStillImageSettings : MonoTouch.AVFoundation.AVCaptureBracketedStillImageSettings, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVCaptureAutoExposureBracketedStillImageSettings ();
    public AVCaptureAutoExposureBracketedStillImageSettings (MonoTouch.Foundation.NSCoder coder);
    public AVCaptureAutoExposureBracketedStillImageSettings (MonoTouch.Foundation.NSObjectFlag t);
    public AVCaptureAutoExposureBracketedStillImageSettings (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual float ExposureTargetBias { get; }
    // methods
    public static AVCaptureAutoExposureBracketedStillImageSettings Create (float exposureTargetBias);
}

New Type MonoTouch.AVFoundation.AVCaptureAutoFocusSystem

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

New Type MonoTouch.AVFoundation.AVCaptureBracketedStillImageSettings

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

New Type MonoTouch.AVFoundation.AVCaptureManualExposureBracketedStillImageSettings

public class AVCaptureManualExposureBracketedStillImageSettings : MonoTouch.AVFoundation.AVCaptureBracketedStillImageSettings, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVCaptureManualExposureBracketedStillImageSettings ();
    public AVCaptureManualExposureBracketedStillImageSettings (MonoTouch.Foundation.NSCoder coder);
    public AVCaptureManualExposureBracketedStillImageSettings (MonoTouch.Foundation.NSObjectFlag t);
    public AVCaptureManualExposureBracketedStillImageSettings (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.CoreMedia.CMTime ExposureDuration { get; }
    public virtual float ISO { get; }
    // methods
    public static AVCaptureManualExposureBracketedStillImageSettings Create (MonoTouch.CoreMedia.CMTime duration, float ISO);
}

New Type MonoTouch.AVFoundation.AVCaptureVideoStabilizationMode

[Serializable]
public enum AVCaptureVideoStabilizationMode {
    Auto = 3,
    Cinematic = 2,
    Off = 0,
    Standard = 1,
}

New Type MonoTouch.AVFoundation.AVCaptureWhiteBalanceChromaticityValues

public struct AVCaptureWhiteBalanceChromaticityValues {
    // constructors
    public AVCaptureWhiteBalanceChromaticityValues (float x, float y);
    // fields
    public float X;
    public float Y;
    // methods
    public override string ToString ();
}

New Type MonoTouch.AVFoundation.AVCaptureWhiteBalanceGains

public struct AVCaptureWhiteBalanceGains {
    // constructors
    public AVCaptureWhiteBalanceGains (float redGain, float greenGain, float blueGain);
    // fields
    public float BlueGain;
    public float GreenGain;
    public float RedGain;
    // methods
    public override string ToString ();
}

New Type MonoTouch.AVFoundation.AVCaptureWhiteBalanceTemperatureAndTintValues

public struct AVCaptureWhiteBalanceTemperatureAndTintValues {
    // constructors
    public AVCaptureWhiteBalanceTemperatureAndTintValues (float temperature, float tint);
    // fields
    public float Temperature;
    public float Tint;
    // methods
    public override string ToString ();
}

New Type MonoTouch.AVFoundation.AVMetadataIdentifiers

public static class AVMetadataIdentifiers {

    // inner types
    public static class CommonIdentifier {
        // properties
        public static MonoTouch.Foundation.NSString AlbumName { get; }
        public static MonoTouch.Foundation.NSString Artist { get; }
        public static MonoTouch.Foundation.NSString Artwork { get; }
        public static MonoTouch.Foundation.NSString AssetIdentifier { get; }
        public static MonoTouch.Foundation.NSString Author { get; }
        public static MonoTouch.Foundation.NSString Contributor { get; }
        public static MonoTouch.Foundation.NSString Copyrights { get; }
        public static MonoTouch.Foundation.NSString CreationDate { get; }
        public static MonoTouch.Foundation.NSString Creator { get; }
        public static MonoTouch.Foundation.NSString Description { get; }
        public static MonoTouch.Foundation.NSString Format { get; }
        public static MonoTouch.Foundation.NSString Language { get; }
        public static MonoTouch.Foundation.NSString LastModifiedDate { get; }
        public static MonoTouch.Foundation.NSString Location { get; }
        public static MonoTouch.Foundation.NSString Make { get; }
        public static MonoTouch.Foundation.NSString Model { get; }
        public static MonoTouch.Foundation.NSString Publisher { get; }
        public static MonoTouch.Foundation.NSString Relation { get; }
        public static MonoTouch.Foundation.NSString Software { get; }
        public static MonoTouch.Foundation.NSString Source { get; }
        public static MonoTouch.Foundation.NSString Subject { get; }
        public static MonoTouch.Foundation.NSString Title { get; }
        public static MonoTouch.Foundation.NSString Type { get; }
    }
    public static class QuickTime {
        // properties
        public static MonoTouch.Foundation.NSString UserDataAlbum { get; }
        public static MonoTouch.Foundation.NSString UserDataArranger { get; }
        public static MonoTouch.Foundation.NSString UserDataArtist { get; }
        public static MonoTouch.Foundation.NSString UserDataAuthor { get; }
        public static MonoTouch.Foundation.NSString UserDataChapter { get; }
        public static MonoTouch.Foundation.NSString UserDataComment { get; }
        public static MonoTouch.Foundation.NSString UserDataComposer { get; }
        public static MonoTouch.Foundation.NSString UserDataCopyright { get; }
        public static MonoTouch.Foundation.NSString UserDataCreationDate { get; }
        public static MonoTouch.Foundation.NSString UserDataCredits { get; }
        public static MonoTouch.Foundation.NSString UserDataDescription { get; }
        public static MonoTouch.Foundation.NSString UserDataDirector { get; }
        public static MonoTouch.Foundation.NSString UserDataDisclaimer { get; }
        public static MonoTouch.Foundation.NSString UserDataEncodedBy { get; }
        public static MonoTouch.Foundation.NSString UserDataFullName { get; }
        public static MonoTouch.Foundation.NSString UserDataGenre { get; }
        public static MonoTouch.Foundation.NSString UserDataHostComputer { get; }
        public static MonoTouch.Foundation.NSString UserDataInformation { get; }
        public static MonoTouch.Foundation.NSString UserDataKeywords { get; }
        public static MonoTouch.Foundation.NSString UserDataLocationISO6709 { get; }
        public static MonoTouch.Foundation.NSString UserDataMake { get; }
        public static MonoTouch.Foundation.NSString UserDataModel { get; }
        public static MonoTouch.Foundation.NSString UserDataOriginalArtist { get; }
        public static MonoTouch.Foundation.NSString UserDataOriginalFormat { get; }
        public static MonoTouch.Foundation.NSString UserDataOriginalSource { get; }
        public static MonoTouch.Foundation.NSString UserDataPerformers { get; }
        public static MonoTouch.Foundation.NSString UserDataPhonogramRights { get; }
        public static MonoTouch.Foundation.NSString UserDataProducer { get; }
        public static MonoTouch.Foundation.NSString UserDataProduct { get; }
        public static MonoTouch.Foundation.NSString UserDataPublisher { get; }
        public static MonoTouch.Foundation.NSString UserDataSoftware { get; }
        public static MonoTouch.Foundation.NSString UserDataSpecialPlaybackRequirements { get; }
        public static MonoTouch.Foundation.NSString UserDataTaggedCharacteristic { get; }
        public static MonoTouch.Foundation.NSString UserDataTrack { get; }
        public static MonoTouch.Foundation.NSString UserDataTrackName { get; }
        public static MonoTouch.Foundation.NSString UserDataUrlLink { get; }
        public static MonoTouch.Foundation.NSString UserDataWarning { get; }
        public static MonoTouch.Foundation.NSString UserDataWriter { get; }
    }
    public static class Iso {
        // properties
        public static MonoTouch.Foundation.NSString UserDataCopyright { get; }
        public static MonoTouch.Foundation.NSString UserDataTaggedCharacteristic { get; }
    }
    public static class ThreeGP {
        // properties
        public static MonoTouch.Foundation.NSString UserDataAlbumAndTrack { get; }
        public static MonoTouch.Foundation.NSString UserDataAuthor { get; }
        public static MonoTouch.Foundation.NSString UserDataCollection { get; }
        public static MonoTouch.Foundation.NSString UserDataCopyright { get; }
        public static MonoTouch.Foundation.NSString UserDataDescription { get; }
        public static MonoTouch.Foundation.NSString UserDataGenre { get; }
        public static MonoTouch.Foundation.NSString UserDataKeywordList { get; }
        public static MonoTouch.Foundation.NSString UserDataLocation { get; }
        public static MonoTouch.Foundation.NSString UserDataMediaClassification { get; }
        public static MonoTouch.Foundation.NSString UserDataMediaRating { get; }
        public static MonoTouch.Foundation.NSString UserDataPerformer { get; }
        public static MonoTouch.Foundation.NSString UserDataRecordingYear { get; }
        public static MonoTouch.Foundation.NSString UserDataThumbnail { get; }
        public static MonoTouch.Foundation.NSString UserDataTitle { get; }
        public static MonoTouch.Foundation.NSString UserDataUserRating { get; }
    }
    public static class QuickTimeMetadata {
        // properties
        public static MonoTouch.Foundation.NSString Album { get; }
        public static MonoTouch.Foundation.NSString Arranger { get; }
        public static MonoTouch.Foundation.NSString Artist { get; }
        public static MonoTouch.Foundation.NSString Artwork { get; }
        public static MonoTouch.Foundation.NSString Author { get; }
        public static MonoTouch.Foundation.NSString CameraFrameReadoutTime { get; }
        public static MonoTouch.Foundation.NSString CameraIdentifier { get; }
        public static MonoTouch.Foundation.NSString CollectionUser { get; }
        public static MonoTouch.Foundation.NSString Comment { get; }
        public static MonoTouch.Foundation.NSString Composer { get; }
        public static MonoTouch.Foundation.NSString Copyright { get; }
        public static MonoTouch.Foundation.NSString CreationDate { get; }
        public static MonoTouch.Foundation.NSString Credits { get; }
        public static MonoTouch.Foundation.NSString Description { get; }
        public static MonoTouch.Foundation.NSString DirectionFacing { get; }
        public static MonoTouch.Foundation.NSString DirectionMotion { get; }
        public static MonoTouch.Foundation.NSString Director { get; }
        public static MonoTouch.Foundation.NSString DisplayName { get; }
        public static MonoTouch.Foundation.NSString EncodedBy { get; }
        public static MonoTouch.Foundation.NSString Genre { get; }
        public static MonoTouch.Foundation.NSString Information { get; }
        public static MonoTouch.Foundation.NSString iXML { get; }
        public static MonoTouch.Foundation.NSString Keywords { get; }
        public static MonoTouch.Foundation.NSString LocationBody { get; }
        public static MonoTouch.Foundation.NSString LocationDate { get; }
        public static MonoTouch.Foundation.NSString LocationISO6709 { get; }
        public static MonoTouch.Foundation.NSString LocationName { get; }
        public static MonoTouch.Foundation.NSString LocationNote { get; }
        public static MonoTouch.Foundation.NSString LocationRole { get; }
        public static MonoTouch.Foundation.NSString Make { get; }
        public static MonoTouch.Foundation.NSString Model { get; }
        public static MonoTouch.Foundation.NSString OriginalArtist { get; }
        public static MonoTouch.Foundation.NSString Performer { get; }
        public static MonoTouch.Foundation.NSString PhonogramRights { get; }
        public static MonoTouch.Foundation.NSString PreferredAffineTransform { get; }
        public static MonoTouch.Foundation.NSString Producer { get; }
        public static MonoTouch.Foundation.NSString Publisher { get; }
        public static MonoTouch.Foundation.NSString RatingUser { get; }
        public static MonoTouch.Foundation.NSString Software { get; }
        public static MonoTouch.Foundation.NSString Title { get; }
        public static MonoTouch.Foundation.NSString Year { get; }
    }
    public static class iTunesMetadata {
        // properties
        public static MonoTouch.Foundation.NSString AccountKind { get; }
        public static MonoTouch.Foundation.NSString Acknowledgement { get; }
        public static MonoTouch.Foundation.NSString Album { get; }
        public static MonoTouch.Foundation.NSString AlbumArtist { get; }
        public static MonoTouch.Foundation.NSString AppleID { get; }
        public static MonoTouch.Foundation.NSString Arranger { get; }
        public static MonoTouch.Foundation.NSString ArtDirector { get; }
        public static MonoTouch.Foundation.NSString Artist { get; }
        public static MonoTouch.Foundation.NSString ArtistID { get; }
        public static MonoTouch.Foundation.NSString Author { get; }
        public static MonoTouch.Foundation.NSString BeatsPerMin { get; }
        public static MonoTouch.Foundation.NSString Composer { get; }
        public static MonoTouch.Foundation.NSString Conductor { get; }
        public static MonoTouch.Foundation.NSString ContentRating { get; }
        public static MonoTouch.Foundation.NSString Copyright { get; }
        public static MonoTouch.Foundation.NSString CoverArt { get; }
        public static MonoTouch.Foundation.NSString Credits { get; }
        public static MonoTouch.Foundation.NSString Description { get; }
        public static MonoTouch.Foundation.NSString Director { get; }
        public static MonoTouch.Foundation.NSString DiscCompilation { get; }
        public static MonoTouch.Foundation.NSString DiscNumber { get; }
        public static MonoTouch.Foundation.NSString EncodedBy { get; }
        public static MonoTouch.Foundation.NSString EncodingTool { get; }
        public static MonoTouch.Foundation.NSString EQ { get; }
        public static MonoTouch.Foundation.NSString ExecProducer { get; }
        public static MonoTouch.Foundation.NSString GenreID { get; }
        public static MonoTouch.Foundation.NSString Grouping { get; }
        public static MonoTouch.Foundation.NSString LinerNotes { get; }
        public static MonoTouch.Foundation.NSString Lyrics { get; }
        public static MonoTouch.Foundation.NSString OnlineExtras { get; }
        public static MonoTouch.Foundation.NSString OriginalArtist { get; }
        public static MonoTouch.Foundation.NSString Performer { get; }
        public static MonoTouch.Foundation.NSString PhonogramRights { get; }
        public static MonoTouch.Foundation.NSString PlaylistID { get; }
        public static MonoTouch.Foundation.NSString PredefinedGenre { get; }
        public static MonoTouch.Foundation.NSString Producer { get; }
        public static MonoTouch.Foundation.NSString Publisher { get; }
        public static MonoTouch.Foundation.NSString RecordCompany { get; }
        public static MonoTouch.Foundation.NSString ReleaseDate { get; }
        public static MonoTouch.Foundation.NSString Soloist { get; }
        public static MonoTouch.Foundation.NSString SongID { get; }
        public static MonoTouch.Foundation.NSString SongName { get; }
        public static MonoTouch.Foundation.NSString SoundEngineer { get; }
        public static MonoTouch.Foundation.NSString Thanks { get; }
        public static MonoTouch.Foundation.NSString TrackNumber { get; }
        public static MonoTouch.Foundation.NSString TrackSubTitle { get; }
        public static MonoTouch.Foundation.NSString UserComment { get; }
        public static MonoTouch.Foundation.NSString UserGenre { get; }
    }
    public static class ID3Metadata {
        // properties
        public static MonoTouch.Foundation.NSString AlbumSortOrder { get; }
        public static MonoTouch.Foundation.NSString AlbumTitle { get; }
        public static MonoTouch.Foundation.NSString AttachedPicture { get; }
        public static MonoTouch.Foundation.NSString AudioEncryption { get; }
        public static MonoTouch.Foundation.NSString AudioSeekPointIndex { get; }
        public static MonoTouch.Foundation.NSString Band { get; }
        public static MonoTouch.Foundation.NSString BeatsPerMinute { get; }
        public static MonoTouch.Foundation.NSString Comments { get; }
        public static MonoTouch.Foundation.NSString CommercialInformation { get; }
        public static MonoTouch.Foundation.NSString Commerical { get; }
        public static MonoTouch.Foundation.NSString Composer { get; }
        public static MonoTouch.Foundation.NSString Conductor { get; }
        public static MonoTouch.Foundation.NSString ContentGroupDescription { get; }
        public static MonoTouch.Foundation.NSString ContentType { get; }
        public static MonoTouch.Foundation.NSString Copyright { get; }
        public static MonoTouch.Foundation.NSString CopyrightInformation { get; }
        public static MonoTouch.Foundation.NSString Date { get; }
        public static MonoTouch.Foundation.NSString EncodedBy { get; }
        public static MonoTouch.Foundation.NSString EncodedWith { get; }
        public static MonoTouch.Foundation.NSString EncodingTime { get; }
        public static MonoTouch.Foundation.NSString Encryption { get; }
        public static MonoTouch.Foundation.NSString Equalization { get; }
        public static MonoTouch.Foundation.NSString Equalization2 { get; }
        public static MonoTouch.Foundation.NSString EventTimingCodes { get; }
        public static MonoTouch.Foundation.NSString FileOwner { get; }
        public static MonoTouch.Foundation.NSString FileType { get; }
        public static MonoTouch.Foundation.NSString GeneralEncapsulatedObject { get; }
        public static MonoTouch.Foundation.NSString GroupIdentifier { get; }
        public static MonoTouch.Foundation.NSString InitialKey { get; }
        public static MonoTouch.Foundation.NSString InternationalStandardRecordingCode { get; }
        public static MonoTouch.Foundation.NSString InternetRadioStationName { get; }
        public static MonoTouch.Foundation.NSString InternetRadioStationOwner { get; }
        public static MonoTouch.Foundation.NSString InvolvedPeopleList_v23 { get; }
        public static MonoTouch.Foundation.NSString InvolvedPeopleList_v24 { get; }
        public static MonoTouch.Foundation.NSString Language { get; }
        public static MonoTouch.Foundation.NSString LeadPerformer { get; }
        public static MonoTouch.Foundation.NSString Length { get; }
        public static MonoTouch.Foundation.NSString Link { get; }
        public static MonoTouch.Foundation.NSString Lyricist { get; }
        public static MonoTouch.Foundation.NSString MediaType { get; }
        public static MonoTouch.Foundation.NSString ModifiedBy { get; }
        public static MonoTouch.Foundation.NSString Mood { get; }
        public static MonoTouch.Foundation.NSString MpegLocationLookupTable { get; }
        public static MonoTouch.Foundation.NSString MusicCDIdentifier { get; }
        public static MonoTouch.Foundation.NSString MusicianCreditsList { get; }
        public static MonoTouch.Foundation.NSString OfficialArtistWebpage { get; }
        public static MonoTouch.Foundation.NSString OfficialAudioFileWebpage { get; }
        public static MonoTouch.Foundation.NSString OfficialAudioSourceWebpage { get; }
        public static MonoTouch.Foundation.NSString OfficialInternetRadioStationHomepage { get; }
        public static MonoTouch.Foundation.NSString OfficialPublisherWebpage { get; }
        public static MonoTouch.Foundation.NSString OriginalAlbumTitle { get; }
        public static MonoTouch.Foundation.NSString OriginalArtist { get; }
        public static MonoTouch.Foundation.NSString OriginalFilename { get; }
        public static MonoTouch.Foundation.NSString OriginalLyricist { get; }
        public static MonoTouch.Foundation.NSString OriginalReleaseTime { get; }
        public static MonoTouch.Foundation.NSString OriginalReleaseYear { get; }
        public static MonoTouch.Foundation.NSString Ownership { get; }
        public static MonoTouch.Foundation.NSString PartOfASet { get; }
        public static MonoTouch.Foundation.NSString Payment { get; }
        public static MonoTouch.Foundation.NSString PerformerSortOrder { get; }
        public static MonoTouch.Foundation.NSString PlayCounter { get; }
        public static MonoTouch.Foundation.NSString PlaylistDelay { get; }
        public static MonoTouch.Foundation.NSString Popularimeter { get; }
        public static MonoTouch.Foundation.NSString PositionSynchronization { get; }
        public static MonoTouch.Foundation.NSString Private { get; }
        public static MonoTouch.Foundation.NSString ProducedNotice { get; }
        public static MonoTouch.Foundation.NSString Publisher { get; }
        public static MonoTouch.Foundation.NSString RecommendedBufferSize { get; }
        public static MonoTouch.Foundation.NSString RecordingDates { get; }
        public static MonoTouch.Foundation.NSString RecordingTime { get; }
        public static MonoTouch.Foundation.NSString RelativeVolumeAdjustment { get; }
        public static MonoTouch.Foundation.NSString RelativeVolumeAdjustment2 { get; }
        public static MonoTouch.Foundation.NSString ReleaseTime { get; }
        public static MonoTouch.Foundation.NSString Reverb { get; }
        public static MonoTouch.Foundation.NSString Seek { get; }
        public static MonoTouch.Foundation.NSString SetSubtitle { get; }
        public static MonoTouch.Foundation.NSString Signature { get; }
        public static MonoTouch.Foundation.NSString Size { get; }
        public static MonoTouch.Foundation.NSString SubTitle { get; }
        public static MonoTouch.Foundation.NSString SynchronizedLyric { get; }
        public static MonoTouch.Foundation.NSString SynchronizedTempoCodes { get; }
        public static MonoTouch.Foundation.NSString TaggingTime { get; }
        public static MonoTouch.Foundation.NSString TermsOfUse { get; }
        public static MonoTouch.Foundation.NSString Time { get; }
        public static MonoTouch.Foundation.NSString TitleDescription { get; }
        public static MonoTouch.Foundation.NSString TitleSortOrder { get; }
        public static MonoTouch.Foundation.NSString TrackNumber { get; }
        public static MonoTouch.Foundation.NSString UniqueFileIdentifier { get; }
        public static MonoTouch.Foundation.NSString UnsynchronizedLyric { get; }
        public static MonoTouch.Foundation.NSString UserText { get; }
        public static MonoTouch.Foundation.NSString UserUrl { get; }
        public static MonoTouch.Foundation.NSString Year { get; }
    }
    public static class IcyMetadata {
        // properties
        public static MonoTouch.Foundation.NSString StreamTitle { get; }
        public static MonoTouch.Foundation.NSString StreamUrl { get; }
    }
}

New Type MonoTouch.AVFoundation.AVMidiPlayer

public class AVMidiPlayer : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVMidiPlayer ();
    public AVMidiPlayer (MonoTouch.Foundation.NSCoder coder);
    public AVMidiPlayer (MonoTouch.Foundation.NSObjectFlag t);
    public AVMidiPlayer (System.IntPtr handle);
    public AVMidiPlayer (MonoTouch.Foundation.NSUrl contentsUrl, MonoTouch.Foundation.NSUrl soundBankUrl, out MonoTouch.Foundation.NSError outError);
    public AVMidiPlayer (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSUrl sounddBankUrl, out MonoTouch.Foundation.NSError outError);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual double CurrentPosition { get; set; }
    public virtual double Duration { get; }
    public virtual bool Playing { get; }
    public virtual float Rate { get; set; }
    // methods
    public virtual void Play (System.Action completionHandler);
    public virtual System.Threading.Tasks.Task PlayAsync ();
    public virtual void PrepareToPlay ();
    public virtual void Stop ();
}

New Type MonoTouch.AVFoundation.AVPlayerItemMetadataOutput

public class AVPlayerItemMetadataOutput : MonoTouch.AVFoundation.AVPlayerItemOutput, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVPlayerItemMetadataOutput ();
    public AVPlayerItemMetadataOutput (MonoTouch.Foundation.NSCoder coder);
    public AVPlayerItemMetadataOutput (MonoTouch.Foundation.NSObjectFlag t);
    public AVPlayerItemMetadataOutput (System.IntPtr handle);
    public AVPlayerItemMetadataOutput (MonoTouch.Foundation.NSString[] metadataIdentifiers);
    // properties
    public virtual double AdvanceIntervalForDelegateInvocation { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public AVPlayerItemMetadataOutputPushDelegate Delegate { get; }
    public virtual MonoTouch.CoreFoundation.DispatchQueue DelegateQueue { get; }
    public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual void SetDelegate (AVPlayerItemMetadataOutputPushDelegate pushDelegate, MonoTouch.CoreFoundation.DispatchQueue delegateQueue);
}

New Type MonoTouch.AVFoundation.AVPlayerItemMetadataOutputPushDelegate

public class AVPlayerItemMetadataOutputPushDelegate : MonoTouch.Foundation.NSObject, IAVPlayerItemMetadataOutputPushDelegate, IAVPlayerItemOutputPushDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVPlayerItemMetadataOutputPushDelegate ();
    public AVPlayerItemMetadataOutputPushDelegate (MonoTouch.Foundation.NSCoder coder);
    public AVPlayerItemMetadataOutputPushDelegate (MonoTouch.Foundation.NSObjectFlag t);
    public AVPlayerItemMetadataOutputPushDelegate (System.IntPtr handle);
    // methods
    public virtual void DidOutputTimedMetadataGroups (AVPlayerItemMetadataOutput output, AVTimedMetadataGroup[] groups, AVPlayerItemTrack track);
    public virtual void OutputSequenceWasFlushed (AVPlayerItemOutput output);
}

New Type MonoTouch.AVFoundation.AVPlayerItemMetadataOutputPushDelegate_Extensions

public static class AVPlayerItemMetadataOutputPushDelegate_Extensions {
    // methods
    public static void DidOutputTimedMetadataGroups (IAVPlayerItemMetadataOutputPushDelegate This, AVPlayerItemMetadataOutput output, AVTimedMetadataGroup[] groups, AVPlayerItemTrack track);
}

New Type MonoTouch.AVFoundation.AVQueuedSampleBufferRenderingStatus

[Serializable]
public enum AVQueuedSampleBufferRenderingStatus {
    Failed = 2,
    Rendering = 1,
    Unknown = 0,
}

New Type MonoTouch.AVFoundation.AVSampleBufferDisplayLayer

public class AVSampleBufferDisplayLayer : MonoTouch.CoreAnimation.CALayer, MonoTouch.CoreAnimation.ICAMediaTiming, MonoTouch.Foundation.INSCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVSampleBufferDisplayLayer ();
    public AVSampleBufferDisplayLayer (MonoTouch.Foundation.NSCoder coder);
    public AVSampleBufferDisplayLayer (MonoTouch.Foundation.NSObjectFlag t);
    public AVSampleBufferDisplayLayer (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.CoreMedia.CMTimebase ControlTimebase { get; set; }
    public virtual MonoTouch.Foundation.NSError Error { get; }
    public virtual bool ReadyForMoreMediaData { get; }
    public virtual AVQueuedSampleBufferRenderingStatus Status { get; }
    public virtual string VideoGravity { get; set; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual void EnqueueSampleBuffer (MonoTouch.CoreMedia.CMSampleBuffer sampleBuffer);
    public virtual void Flush ();
    public virtual void FlushAndRemoveImage ();
    public virtual void RequestMediaDataWhenReadyOnQueue (MonoTouch.CoreFoundation.DispatchQueue queue, System.Action enqueuer);
    public virtual void StopRequestingMediaData ();
}

New Type MonoTouch.AVFoundation.AVUtilities

public static class AVUtilities {
    // methods
    public static System.Drawing.RectangleF WithAspectRatio (System.Drawing.RectangleF self, System.Drawing.SizeF aspectRatio);
}

New Type MonoTouch.AVFoundation.IAVAudio3DMixing

public interface IAVAudio3DMixing : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual float Obstruction { get; set; }
    public virtual float Occlusion { get; set; }
    public virtual OpenTK.Vector3 Position { get; set; }
    public virtual float Rate { get; set; }
    public virtual AVAudio3DMixingRenderingAlgorithm RenderingAlgorithm { get; set; }
    public virtual float ReverbBlend { get; set; }
}

New Type MonoTouch.AVFoundation.IAVAudioMixing

public interface IAVAudioMixing : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IAVAudio3DMixing, IAVAudioStereoMixing {
    // properties
    public virtual float Volume { get; set; }
}

New Type MonoTouch.AVFoundation.IAVAudioStereoMixing

public interface IAVAudioStereoMixing : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual float Pan { get; set; }
}

New Type MonoTouch.AVFoundation.IAVPlayerItemMetadataOutputPushDelegate

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

Namespace MonoTouch.CoreAnimation

Type Changed: MonoTouch.CoreAnimation.CAKeyFrameAnimation

Added properties:

public virtual MonoTouch.Foundation.NSNumber[] BiasValues { get; set; }
    public virtual MonoTouch.Foundation.NSNumber[] ContinuityValues { get; set; }
    public virtual MonoTouch.Foundation.NSNumber[] TensionValues { get; set; }

Type Changed: MonoTouch.CoreAnimation.CALayer

Added properties:

public virtual MonoTouch.CoreImage.CIFilter[] BackgroundFilters { get; set; }
    public virtual MonoTouch.Foundation.NSObject CompositingFilter { get; set; }
    public virtual MonoTouch.CoreImage.CIFilter[] Filters { get; set; }
    public virtual float MinificationFilterBias { get; set; }
    public virtual MonoTouch.Foundation.NSDictionary Style { 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.SizeF 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);
    public virtual ICAMetalDrawable NextDrawable ();
}

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.CoreBluetooth

Type Changed: MonoTouch.CoreBluetooth.CBCentral

Removed property:

public virtual MonoTouch.Foundation.NSUuid Identifier { get; }

Removed method:

protected override void Dispose (bool disposing);

Type Changed: MonoTouch.CoreBluetooth.CBCharacteristic

Removed property:

public virtual CBUUID UUID { get; set; }

Type Changed: MonoTouch.CoreBluetooth.CBDescriptor

Removed property:

public virtual CBUUID UUID { get; }

Type Changed: MonoTouch.CoreBluetooth.CBPeripheral

Removed properties:

public virtual MonoTouch.Foundation.NSUuid Identifier { get; }

    [Obsolete ("Deprecated in iOS7")]
    public virtual System.IntPtr UUID { get; }

Type Changed: MonoTouch.CoreBluetooth.CBService

Removed property:

public virtual CBUUID UUID { get; }

New Type MonoTouch.CoreBluetooth.CBAttribute

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

New Type MonoTouch.CoreBluetooth.CBPeer

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

Namespace MonoTouch.CoreData

Type Changed: MonoTouch.CoreData.NSManagedObjectContext

Added property:

public virtual string Name { get; set; }

Added method:

public virtual NSPersistentStoreResult ExecuteRequest (NSPersistentStoreRequest request, out MonoTouch.Foundation.NSError error);

Type Changed: MonoTouch.CoreData.NSPersistentStoreCoordinator

Obsoleted constructor:

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

Added property:

public virtual string Name { get; set; }

Added methods:

public virtual void Perform (System.Action code);
    public virtual void PerformAndWait (System.Action code);

Type Changed: MonoTouch.CoreData.NSPersistentStoreRequestType

Added value:

BatchUpdate = 6,

New Type MonoTouch.CoreData.NSAsynchronousFetchRequest

public class NSAsynchronousFetchRequest : MonoTouch.CoreData.NSPersistentStoreRequest, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public NSAsynchronousFetchRequest ();
    public NSAsynchronousFetchRequest (MonoTouch.Foundation.NSCoder coder);
    public NSAsynchronousFetchRequest (MonoTouch.Foundation.NSObjectFlag t);
    public NSAsynchronousFetchRequest (System.IntPtr handle);
    public NSAsynchronousFetchRequest (NSFetchRequest request, System.Action<NSAsynchronousFetchResult> completion);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual int EstimatedResultCount { get; set; }
    public virtual NSFetchRequest FetchRequest { get; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreData.NSAsynchronousFetchResult

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

New Type MonoTouch.CoreData.NSBatchUpdateRequest

public class NSBatchUpdateRequest : MonoTouch.CoreData.NSPersistentStoreRequest, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public NSBatchUpdateRequest ();
    public NSBatchUpdateRequest (MonoTouch.Foundation.NSCoder coder);
    public NSBatchUpdateRequest (MonoTouch.Foundation.NSObjectFlag t);
    public NSBatchUpdateRequest (System.IntPtr handle);
    public NSBatchUpdateRequest (string entityName);
    public NSBatchUpdateRequest (NSEntityDescription entity);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual NSEntityDescription Entity { get; }
    public virtual string EntityName { get; }
    public virtual bool IncludesSubentities { get; set; }
    public virtual MonoTouch.Foundation.NSPredicate Predicate { get; set; }
    public virtual MonoTouch.Foundation.NSDictionary PropertiesToUpdate { get; set; }
    public virtual NSBatchUpdateRequestResultType ResultType { get; set; }
    // methods
    public static NSBatchUpdateRequest BatchUpdateRequestWithEntityName (string entityName);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreData.NSBatchUpdateRequestResultType

[Serializable]
public enum NSBatchUpdateRequestResultType {
    StatusOnly = 0,
    UpdatedObjectIDs = 1,
    UpdatedObjectsCount = 2,
}

New Type MonoTouch.CoreData.NSBatchUpdateResult

public class NSBatchUpdateResult : MonoTouch.CoreData.NSPersistentStoreResult, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public NSBatchUpdateResult ();
    public NSBatchUpdateResult (MonoTouch.Foundation.NSCoder coder);
    public NSBatchUpdateResult (MonoTouch.Foundation.NSObjectFlag t);
    public NSBatchUpdateResult (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.Foundation.NSObject Result { get; }
    public virtual NSBatchUpdateRequestResultType ResultType { get; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreData.NSPersistentStoreAsynchronousResult

public class NSPersistentStoreAsynchronousResult : MonoTouch.CoreData.NSPersistentStoreResult, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public NSPersistentStoreAsynchronousResult ();
    public NSPersistentStoreAsynchronousResult (MonoTouch.Foundation.NSCoder coder);
    public NSPersistentStoreAsynchronousResult (MonoTouch.Foundation.NSObjectFlag t);
    public NSPersistentStoreAsynchronousResult (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual NSManagedObjectContext ManagedObjectContext { get; }
    public virtual MonoTouch.Foundation.NSError OperationError { get; }
    public virtual MonoTouch.Foundation.NSProgress Progress { get; }
    // methods
    public virtual void Cancel ();
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.CoreData.NSPersistentStoreResult

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

Namespace MonoTouch.CoreFoundation

Type Changed: MonoTouch.CoreFoundation.CFStream

Type Changed: MonoTouch.CoreFoundation.CFStream.CFStreamCallback

Removed methods:

public virtual System.IAsyncResult BeginInvoke (System.IntPtr s, CFStreamEventType type, System.IntPtr info, System.AsyncCallback callback, object object);
    public virtual void Invoke (System.IntPtr s, CFStreamEventType type, System.IntPtr info);

Added methods:

public virtual System.IAsyncResult BeginInvoke (System.IntPtr s, int type, System.IntPtr info, System.AsyncCallback callback, object object);
    public virtual void Invoke (System.IntPtr s, int type, System.IntPtr info);

Namespace MonoTouch.CoreGraphics

Type Changed: MonoTouch.CoreGraphics.CGVector

Added method:

public static CGVector FromString (string s);

Namespace MonoTouch.CoreImage

Type Changed: MonoTouch.CoreImage.CIAutoAdjustmentFilterOptions

Added fields:

public bool? AutoAdjustCrop;
    public bool? AutoAdjustLevel;

Type Changed: MonoTouch.CoreImage.CIColor

Added property:

public float[] Components { get; }

Type Changed: MonoTouch.CoreImage.CIContextOptions

Added properties:

public int? CIImageFormat { get; set; }
    public bool? PriorityRequestLow { get; set; }

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 constructor:

protected 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 CreateByClampingToExtent ();
    public virtual CIImage CreateByCompositingOverImage (CIImage dest);
    public virtual CIImage CreateByFiltering (string filterName, MonoTouch.Foundation.NSDictionary inputParameters);
    public virtual CIImage CreateWithOrientation (CIImageOrientation orientation);
    public virtual MonoTouch.CoreGraphics.CGAffineTransform GetImageTransform (CIImageOrientation orientation);
    public static CIImage ImageWithTexture (uint glTextureName, System.Drawing.SizeF size, bool flipped, MonoTouch.CoreGraphics.CGColorSpace colorspace);

Type Changed: MonoTouch.CoreImage.CIVector

Added constructors:

public CIVector (MonoTouch.CoreGraphics.CGAffineTransform r);
    public CIVector (System.Drawing.RectangleF r);
    public CIVector (System.Drawing.PointF p);

New Type MonoTouch.CoreImage.CIAccordionFoldTransition

public class CIAccordionFoldTransition : MonoTouch.CoreImage.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIAccordionFoldTransition ();
    public CIAccordionFoldTransition (System.IntPtr handle);
    // properties
    public float BottomHeight { get; set; }
    public float FoldShadowAmount { get; set; }
    public int NumberOfFolds { get; set; }
    public CIImage TargetImage { get; set; }
    public float Time { get; set; }
}

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);
    // properties
    public bool CompactStyle { get; set; }
    public float CorrectionLevel { get; set; }
    public int Layers { get; set; }
    public MonoTouch.Foundation.NSData Message { get; set; }
}

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);
    // properties
    public MonoTouch.Foundation.NSData Message { get; set; }
    public float QuietSpace { get; set; }
}

New Type MonoTouch.CoreImage.CIColorKernel

public class CIColorKernel : MonoTouch.CoreImage.CIKernel, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIColorKernel (MonoTouch.Foundation.NSCoder coder);
    public CIColorKernel (MonoTouch.Foundation.NSObjectFlag t);
    public CIColorKernel (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    // methods
    public virtual CIImage ApplyWithExtent (System.Drawing.RectangleF extent, MonoTouch.Foundation.NSObject[] args);
}

New Type MonoTouch.CoreImage.CIDivideBlendMode

public class CIDivideBlendMode : MonoTouch.CoreImage.CIBlendFilter, 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.CIFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIGlassDistortion ();
    public CIGlassDistortion (System.IntPtr handle);
    // properties
    public CIVector Center { get; set; }
    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.CIKernel

public class CIKernel : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIKernel (MonoTouch.Foundation.NSCoder coder);
    public CIKernel (MonoTouch.Foundation.NSObjectFlag t);
    public CIKernel (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual string Name { get; }
    // methods
    public virtual CIImage ApplyWithExtent (System.Drawing.RectangleF extent, CIKernelRoiCallback callback, MonoTouch.Foundation.NSObject[] args);
    public static CIKernel FromProgram (string coreImageShaderProgram);
    public static CIKernel[] FromPrograms (string coreImageShaderProgram);
}

New Type MonoTouch.CoreImage.CIKernelRoiCallback

public sealed delegate CIKernelRoiCallback : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public CIKernelRoiCallback (object object, System.IntPtr method);
    // methods
    public virtual System.IAsyncResult BeginInvoke (int index, System.Drawing.RectangleF rect, System.AsyncCallback callback, object object);
    public virtual System.Drawing.RectangleF EndInvoke (System.IAsyncResult result);
    public virtual System.Drawing.RectangleF Invoke (int index, System.Drawing.RectangleF rect);
}

New Type MonoTouch.CoreImage.CILinearBurnBlendMode

public class CILinearBurnBlendMode : MonoTouch.CoreImage.CIBlendFilter, 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.CIBlendFilter, 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.CIPerspectiveTransform, 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.CIBlendFilter, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIPinLightBlendMode ();
    public CIPinLightBlendMode (System.IntPtr handle);
}

New Type MonoTouch.CoreImage.CIQRCodeFeature

public class CIQRCodeFeature : MonoTouch.CoreImage.CIFeature, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIQRCodeFeature ();
    public CIQRCodeFeature (MonoTouch.Foundation.NSCoder coder);
    public CIQRCodeFeature (MonoTouch.Foundation.NSObjectFlag t);
    public CIQRCodeFeature (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 string MessageString { get; }
    public virtual System.Drawing.PointF TopLeft { get; }
    public virtual System.Drawing.PointF TopRight { get; }
}

New Type MonoTouch.CoreImage.CIRectangleFeature

public class CIRectangleFeature : MonoTouch.CoreImage.CIFeature, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIRectangleFeature ();
    public CIRectangleFeature (MonoTouch.Foundation.NSCoder coder);
    public CIRectangleFeature (MonoTouch.Foundation.NSObjectFlag t);
    public CIRectangleFeature (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 System.Drawing.PointF TopLeft { get; }
    public virtual System.Drawing.PointF TopRight { get; }
}

New Type MonoTouch.CoreImage.CISubtractBlendMode

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

New Type MonoTouch.CoreImage.CIWarpKernel

public class CIWarpKernel : MonoTouch.CoreImage.CIKernel, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CIWarpKernel (MonoTouch.Foundation.NSCoder coder);
    public CIWarpKernel (MonoTouch.Foundation.NSObjectFlag t);
    public CIWarpKernel (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    // methods
    public virtual CIImage ApplyWithExtent (System.Drawing.RectangleF extent, CIKernelRoiCallback callback, CIImage image, MonoTouch.Foundation.NSObject[] args);
}

Namespace MonoTouch.CoreLocation

Type Changed: MonoTouch.CoreLocation.CLAuthorizationStatus

Added values:

AuthorizedAlways = 3,
    AuthorizedWhenInUse = 4,

Obsoleted field:

[Obsolete ("Value obsoleted, use AuthorizedAlways instead")]
    Authorized = 3,

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 property:

public static bool IsRangingAvailable { get; }

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);

Type Changed: MonoTouch.CoreLocation.CLLocationManagerDelegate_Extensions

Added method:

public static void DidVisit (ICLLocationManagerDelegate This, 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 int 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.CoreMedia

Type Changed: MonoTouch.CoreMedia.CMFormatDescription

Added method:

public MonoTouch.Foundation.NSObject GetExtension (string extensionKey);

Type Changed: MonoTouch.CoreMedia.CMSampleBuffer

Added methods:

public CMSampleBufferError CallForEachSample (System.Func<CMSampleBuffer,System.Int32,MonoTouch.CoreMedia.CMSampleBufferError> callback);
    public static CMSampleBuffer CreateReady (CMBlockBuffer dataBuffer, CMFormatDescription formatDescription, int samplesCount, CMSampleTimingInfo[] sampleTimingArray, uint[] sampleSizeArray, out CMSampleBufferError error);
    public static CMSampleBuffer CreateReadyWithImageBuffer (MonoTouch.CoreVideo.CVImageBuffer imageBuffer, CMFormatDescription formatDescription, CMSampleTimingInfo[] sampleTiming, out CMSampleBufferError error);
    public static CMSampleBuffer CreateReadyWithPacketDescriptions (CMBlockBuffer dataBuffer, CMFormatDescription formatDescription, int samplesCount, CMTime sampleTimestamp, MonoTouch.AudioToolbox.AudioStreamPacketDescription[] packetDescriptions, out CMSampleBufferError error);
    public CMSampleBufferError SetInvalidateCallback (System.Action<CMSampleBuffer> invalidateHandler);

Type Changed: MonoTouch.CoreMedia.CMTime

Added properties:

public bool HasBeenRounded { get; }
    public bool IsNumeric { get; }

Namespace MonoTouch.CoreMotion

Type Changed: MonoTouch.CoreMotion.CMMotionActivity

Added property:

public virtual bool Cycling { get; }

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 Pressure { 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.CoreText

Type Changed: MonoTouch.CoreText.CTLineBoundsOptions

Added value:

IncludeLanguageExtents = 32,

Namespace MonoTouch.CoreVideo

Type Changed: MonoTouch.CoreVideo.CVImageBuffer

Added field:

public static MonoTouch.Foundation.NSString AlphaChannelIsOpaque;

Type Changed: MonoTouch.CoreVideo.CVPixelBuffer

Added field:

public static MonoTouch.Foundation.NSString MetalCompatibilityKey;

Type Changed: MonoTouch.CoreVideo.CVPixelBufferAttributes

Added properties:

public bool? AllocateWithIOSurface { get; set; }
    public bool? MetalCompatibility { get; set; }

Type Changed: MonoTouch.CoreVideo.CVPixelFormatDescription

Added fields:

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

Type Changed: MonoTouch.CoreVideo.CVReturn

Added value:

PixelBufferNotMetalCompatible = -6684,

New Type MonoTouch.CoreVideo.CVMetalTexture

public class CVMetalTexture : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual System.IntPtr Handle { get; }
    public bool IsFlipped { get; }
    public MonoTouch.Metal.IMTLTexture Texture { get; }
    // methods
    protected override void ~CVMetalTexture ();
    public virtual void Dispose ();
    protected virtual void Dispose (bool disposing);
    public void GetCleanTexCoords (out float[] lowerLeft, out float[] lowerRight, out float[] upperRight, out float[] upperLeft);
}

New Type MonoTouch.CoreVideo.CVMetalTextureCache

public class CVMetalTextureCache : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CVMetalTextureCache (MonoTouch.Metal.IMTLDevice metalDevice);
    // properties
    public virtual System.IntPtr Handle { get; }
    // methods
    protected override void ~CVMetalTextureCache ();
    public virtual void Dispose ();
    protected virtual void Dispose (bool disposing);
    public void Flush (CVOptionFlags flags);
    public static CVMetalTextureCache FromDevice (MonoTouch.Metal.IMTLDevice metalDevice);
    public CVMetalTexture TextureFromImage (CVImageBuffer imageBuffer, MonoTouch.Metal.MTLPixelFormat format, int width, int height, int planeIndex, out CVReturn errorCode);
}

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

Added methods:

public static EKEventEditViewController.EKEventEditViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static EKEventEditViewController.EKEventEditViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

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, EAWiFiUnconfiguredAccessoryConfigurationStatus status);
    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, EAWiFiUnconfiguredAccessoryConfigurationStatus status);
    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.EAWiFiUnconfiguredAccessoryConfigurationStatus

[Serializable]
public enum EAWiFiUnconfiguredAccessoryConfigurationStatus {
    Failed = 2,
    Success = 0,
    UserCancelledConfiguration = 1,
}

New Type MonoTouch.ExternalAccessory.EAWiFiUnconfiguredAccessoryDidFinishEventArgs

public class EAWiFiUnconfiguredAccessoryDidFinishEventArgs : System.EventArgs {
    // constructors
    public EAWiFiUnconfiguredAccessoryDidFinishEventArgs (EAWiFiUnconfiguredAccessory accessory, EAWiFiUnconfiguredAccessoryConfigurationStatus status);
    // properties
    public EAWiFiUnconfiguredAccessory Accessory { get; set; }
    public EAWiFiUnconfiguredAccessoryConfigurationStatus Status { 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]
[Flags]
public enum EAWiFiUnconfiguredAccessoryProperties {
    SupportsAirPlay = 1,
    SupportsAirPrint = 2,
    SupportsHomeKit = 4,
}

New Type MonoTouch.ExternalAccessory.IEAWiFiUnconfiguredAccessoryBrowserDelegate

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

Namespace MonoTouch.Foundation

Type Changed: MonoTouch.Foundation.DictionaryContainer

Added methods:

protected uint? GetUInt32Value (NSString key);
    protected void SetArrayValue<T> (NSString key, T[] values);

Type Changed: MonoTouch.Foundation.INSMachPortDelegate

Added interface:

INSPortDelegate

Type Changed: MonoTouch.Foundation.INSUrlConnectionDownloadDelegate

Added interface:

INSUrlConnectionDelegate

Type Changed: MonoTouch.Foundation.INSUrlSessionDataDelegate

Added interfaces:

INSUrlSessionTaskDelegate
    INSUrlSessionDelegate

Type Changed: MonoTouch.Foundation.INSUrlSessionDownloadDelegate

Added interfaces:

INSUrlSessionTaskDelegate
    INSUrlSessionDelegate

Type Changed: MonoTouch.Foundation.INSUrlSessionTaskDelegate

Added interface:

INSUrlSessionDelegate

Type Changed: MonoTouch.Foundation.NSAttributedString

Added interface:

INSSecureCoding

Type Changed: MonoTouch.Foundation.NSByteCountFormatter

Added property:

public virtual NSFormattingContext FormattingContext { get; set; }

Type Changed: MonoTouch.Foundation.NSCachedUrlResponse

Added interface:

INSSecureCoding

Type Changed: MonoTouch.Foundation.NSCalendar

Added properties:

public virtual string AMSymbol { get; }
    public static NSString DayChangedNotification { 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.NSComparisonPredicate

Removed methods:

public static NSPredicate Create (NSExpression leftExpression, NSExpression rightExpression, NSComparisonPredicateModifier comparisonModifier, NSPredicateOperatorType operatorType, NSComparisonPredicateOptions comparisonOptions);
    public static NSPredicate FromSelector (NSExpression leftExpression, NSExpression rightExpression, MonoTouch.ObjCRuntime.Selector selector);

Added methods:

public static NSComparisonPredicate Create (NSExpression leftExpression, NSExpression rightExpression, NSComparisonPredicateModifier comparisonModifier, NSPredicateOperatorType operatorType, NSComparisonPredicateOptions comparisonOptions);
    public static NSComparisonPredicate FromSelector (NSExpression leftExpression, NSExpression rightExpression, MonoTouch.ObjCRuntime.Selector selector);

Type Changed: MonoTouch.Foundation.NSCompoundPredicate

Removed methods:

public static NSPredicate CreateAndPredicate (NSPredicate[] subpredicates);
    public static NSPredicate CreateNotPredicate (NSPredicate predicate);
    public static NSPredicate CreateOrPredicate (NSPredicate[] subpredicates);

Added methods:

public static NSCompoundPredicate CreateAndPredicate (NSPredicate[] subpredicates);
    public static NSCompoundPredicate CreateNotPredicate (NSPredicate predicate);
    public static NSCompoundPredicate CreateOrPredicate (NSPredicate[] subpredicates);

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.NSDateFormatter

Added method:

public virtual void SetLocalizedDateFormatFromTemplate (string dateFormatTemplate);

Type Changed: MonoTouch.Foundation.NSError

Added properties:

public static NSString CoreLocationErrorDomain { get; }
    public static NSString CoreMotionErrorDomain { get; }
    public static NSString EABluetoothAccessoryPickerErrorDomain { get; }
    public virtual string HelpAnchor { get; }
    public virtual string LocalizedFailureReason { get; }
    public virtual string[] LocalizedRecoveryOptions { get; }
    public virtual string LocalizedRecoverySuggestion { get; }
    public static NSString MapKitErrorDomain { get; }
    public static NSString NSNetServicesErrorDomain { get; }
    public static NSString NSStreamSocketSSLErrorDomain { get; }
    public static NSString NSStreamSOCKSErrorDomain { get; }

Type Changed: MonoTouch.Foundation.NSFileCoordinator

Added property:

public virtual string PurposeIdentifier { get; set; }

Added method:

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

Type Changed: MonoTouch.Foundation.NSFileCoordinatorReadingOptions

Added values:

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

Type Changed: MonoTouch.Foundation.NSFileManager

Added methods:

public virtual bool GetRelationship (out NSURLRelationship outRelationship, NSUrl directoryURL, NSUrl otherURL, out NSError error);
    public virtual bool GetRelationship (out NSURLRelationship outRelationship, NSSearchPathDirectory directory, NSSearchPathDomain domain, NSUrl toItemAtUrl, out NSError error);

Type Changed: MonoTouch.Foundation.NSFilePresenter

Added methods:

public virtual void AccommodatePresentedItemDeletion (System.Action<NSError> completionHandler);
    public virtual void AccommodatePresentedSubitemDeletion (NSUrl url, System.Action<NSError> completionHandler);
    public virtual void RelinquishPresentedItemToReader (MonoTouch.UIKit.NSFilePresenterReacquirer readerAction);
    public virtual void RelinquishPresentedItemToWriter (MonoTouch.UIKit.NSFilePresenterReacquirer writerAction);
    public virtual void SavePresentedItemChanges (System.Action<NSError> completionHandler);

Type Changed: MonoTouch.Foundation.NSFilePresenter_Extensions

Added methods:

public static void AccommodatePresentedItemDeletion (INSFilePresenter This, System.Action<NSError> completionHandler);
    public static void AccommodatePresentedSubitemDeletion (INSFilePresenter This, NSUrl url, System.Action<NSError> completionHandler);
    public static void RelinquishPresentedItemToReader (INSFilePresenter This, MonoTouch.UIKit.NSFilePresenterReacquirer readerAction);
    public static void RelinquishPresentedItemToWriter (INSFilePresenter This, MonoTouch.UIKit.NSFilePresenterReacquirer writerAction);
    public static void SavePresentedItemChanges (INSFilePresenter This, System.Action<NSError> completionHandler);

Type Changed: MonoTouch.Foundation.NSHttpCookieStorage

Added methods:

public virtual void GetCookiesForTask (NSUrlSessionTask task, System.Action<NSHttpCookie[]> completionHandler);
    public virtual void RemoveCookiesSinceDate (NSDate date);
    public virtual void StoreCookies (NSHttpCookie[] cookies, NSUrlSessionTask task);

Type Changed: MonoTouch.Foundation.NSIndexPath

Added interface:

INSSecureCoding

Type Changed: MonoTouch.Foundation.NSIndexSet

Added interface:

INSSecureCoding

Added methods:

public virtual void EnumerateIndexes (NSRange range, NSEnumerationOptions opts, EnumerateIndexSetCallback enumeratorCallback);
    public virtual void EnumerateIndexes (NSEnumerationOptions opts, EnumerateIndexSetCallback enumeratorCallback);
    public virtual void EnumerateIndexes (EnumerateIndexSetCallback enumeratorCallback);

Type Changed: MonoTouch.Foundation.NSMachPort

Added constructors:

public NSMachPort (uint machPort);
    public NSMachPort (uint machPort, NSMachPortRights options);

Type Changed: MonoTouch.Foundation.NSMetadataQuery

Added properties:

public static NSString AccessibleUbiquitousExternalDocumentsScope { get; }
    public static NSString ContentTypeKey { get; }
    public static NSString ContentTypeTreeKey { get; }
    public static NSString UbiquitousDataScope { get; }
    public static NSString UbiquitousDocumentsScope { get; }
    public static NSString UbiquitousItemContainerDisplayNameKey { get; }
    public static NSString UbiquitousItemDownloadRequestedKey { get; }
    public static NSString UbiquitousItemIsExternalDocumentKey { get; }
    public static NSString UbiquitousItemURLInLocalContainerKey { get; }

Type Changed: MonoTouch.Foundation.NSMethodSignature

Added property:

public virtual System.IntPtr MethodReturnType { get; }

Added methods:

public static NSMethodSignature FromObjcTypes (System.IntPtr utf8objctypes);
    public virtual System.IntPtr GetArgumentType (uint index);

Type Changed: MonoTouch.Foundation.NSMutableArray

Added methods:

public static NSMutableArray FromFile (string path);
    public static NSMutableArray FromUrl (NSUrl url);

Type Changed: MonoTouch.Foundation.NSMutableAttributedString

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 FromBitmapRepresentation (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

Added methods:

public virtual void AddIndexesInRange (NSRange range);
    public virtual void RemoveIndexesInRange (NSRange range);

Type Changed: MonoTouch.Foundation.NSObject

Added methods:

public System.IDisposable AddObserver (string key, NSKeyValueObservingOptions options, System.Action<NSObservedChange> observer);
    public System.IDisposable AddObserver (NSString key, NSKeyValueObservingOptions options, System.Action<NSObservedChange> observer);
    public void AddObserver (NSObject observer, string keyPath, NSKeyValueObservingOptions options, System.IntPtr context);
    public void RemoveObserver (NSObject observer, string keyPath, System.IntPtr context);
    public void RemoveObserver (NSObject observer, string keyPath);
    public virtual void RemoveObserver (NSObject observer, NSString keyPath, System.IntPtr context);

Type Changed: MonoTouch.Foundation.NSOperation

Added properties:

public virtual bool Asynchronous { get; }
    public virtual string Name { get; set; }
    public virtual NSQualityOfService QualityOfService { get; set; }

Type Changed: MonoTouch.Foundation.NSOperationQueue

Added properties:

public virtual NSQualityOfService QualityOfService { get; set; }
    public virtual MonoTouch.CoreFoundation.DispatchQueue UnderlyingQueue { get; set; }

Type Changed: MonoTouch.Foundation.NSPort

Added methods:

public virtual void RemoveFromRunLoop (NSRunLoop runLoop, NSString runLoopMode);
    public virtual void ScheduleInRunLoop (NSRunLoop runLoop, NSString runLoopMode);
    public virtual bool SendBeforeDate (NSDate limitDate, NSMutableArray components, NSPort receivePort, uint headerSpaceReserved);
    public virtual bool SendBeforeDate (NSDate limitDate, uint msgID, NSMutableArray components, NSPort receivePort, uint headerSpaceReserved);

Type Changed: MonoTouch.Foundation.NSProcessInfo

Added property:

public virtual NSOperatingSystemVersion OperatingSystemVersion { get; }

Added method:

public virtual bool IsOperatingSystemAtLeastVersion (NSOperatingSystemVersion version);

Type Changed: MonoTouch.Foundation.NSSet

Added method:

public virtual NSObject LookupMember (NSObject probe);

Type Changed: MonoTouch.Foundation.NSStream

Added methods:

public static void GetBoundStreams (uint bufferSize, out NSInputStream inputStream, out NSOutputStream outputStream);
    public static void GetStreamsToHost (string hostname, int port, out NSInputStream inputStream, out NSOutputStream outputStream);

Type Changed: MonoTouch.Foundation.NSString

Added methods:

public virtual bool Contains (NSString str);
    public static uint DetectStringEncoding (NSData rawData, NSDictionary options, out string convertedString, out bool usedLossyConversion);
    public static uint DetectStringEncoding (NSData rawData, EncodingDetectionOptions options, out string convertedString, out bool usedLossyConversion);
    public virtual void GetLineStart (out uint startPtr, out uint lineEndPtr, out uint contentsEndPtr, NSRange range);
    public virtual NSRange LineRangeForRange (NSRange range);
    public virtual bool LocalizedCaseInsensitiveContains (NSString str);

Type Changed: MonoTouch.Foundation.NSThread

Added property:

public virtual NSQualityOfService QualityOfService { get; set; }

Type Changed: MonoTouch.Foundation.NSUrl

Added properties:

public static NSString AddedToDirectoryDateKey { get; }
    public static NSString DocumentIdentifierKey { get; }
    public static NSString GenerationIdentifierKey { get; }
    public virtual string LastPathComponent { get; }
    public virtual string[] PathComponents { get; }
    public static NSString ThumbnailDictionaryKey { get; }
    public static NSString UbiquitousItemContainerDisplayNameKey { get; }
    public static NSString UbiquitousItemDownloadRequestedKey { get; }

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 bool SetResource (NSString nsUrlResourceKey, NSObject value, out NSError error);
    public bool SetResource (NSString nsUrlResourceKey, NSObject value);
    public virtual bool StartAccessingSecurityScopedResource ();
    public virtual void StopAccessingSecurityScopedResource ();
    public bool TryGetResource (NSString nsUrlResourceKey, out NSObject value);
    public bool TryGetResource (NSString nsUrlResourceKey, out NSObject value, out NSError error);

Type Changed: MonoTouch.Foundation.NSUrlCache

Added methods:

public virtual void GetCachedResponse (NSUrlSessionDataTask dataTask, System.Action<NSCachedUrlResponse> completionHandler);
    public virtual System.Threading.Tasks.Task<NSCachedUrlResponse> GetCachedResponseAsync (NSUrlSessionDataTask dataTask);
    public virtual void RemoveCachedResponse (NSUrlSessionDataTask dataTask);
    public virtual void RemoveCachedResponsesSinceDate (NSDate date);
    public virtual void StoreCachedResponse (NSCachedUrlResponse cachedResponse, NSUrlSessionDataTask dataTask);

Type Changed: MonoTouch.Foundation.NSUrlComponents

Added property:

public virtual NSUrlQueryItem[] QueryItems { get; set; }

Added method:

public virtual string AsString ();

Type Changed: MonoTouch.Foundation.NSUrlCredentialStorage

Added methods:

public virtual void GetCredentials (NSUrlProtectionSpace protectionSpace, NSUrlSessionTask task, System.Action<NSDictionary> completionHandler);
    public virtual void GetDefaultCredential (NSUrlProtectionSpace space, NSUrlSessionTask task, System.Action<NSUrlCredential> completionHandler);
    public virtual void RemoveCredential (NSUrlCredential credential, NSUrlProtectionSpace protectionSpace, NSDictionary options, NSUrlSessionTask task);
    public virtual void SetCredential (NSUrlCredential credential, NSUrlProtectionSpace protectionSpace, NSUrlSessionTask task);
    public virtual void SetDefaultCredential (NSUrlCredential credential, NSUrlProtectionSpace protectionSpace, NSUrlSessionTask task);

Type Changed: MonoTouch.Foundation.NSUrlError

Added values:

BackgroundSessionInUseByAnotherProcess = -996,
    BackgroundSessionRequiresSharedContainer = -995,
    BackgroundSessionWasDisconnected = -997,

Type Changed: MonoTouch.Foundation.NSUrlErrorCancelledReason

Added value:

InsufficientSystemResources = 2,

Type Changed: MonoTouch.Foundation.NSUrlSessionConfiguration

Added property:

public virtual string SharedContainerIdentifier { get; set; }

Added method:

public static NSUrlSessionConfiguration CreateBackgroundSessionConfiguration (string identifier);

Obsoleted method:

[Obsolete ("Starting with iOS 8, use CreateBackgroundSessionConfiguration")]
    public static NSUrlSessionConfiguration BackgroundSessionConfiguration (string identifier);

Type Changed: MonoTouch.Foundation.NSUrlSessionDataTask

Removed interface:

INSCoding

Type Changed: MonoTouch.Foundation.NSUrlSessionDownloadTask

Removed interface:

INSCoding

Type Changed: MonoTouch.Foundation.NSUrlSessionTask

Removed interface:

INSCoding

Added property:

public virtual float Priority { get; set; }

Type Changed: MonoTouch.Foundation.NSUrlSessionUploadTask

Removed interface:

INSCoding

Type Changed: MonoTouch.Foundation.NSValue

Added properties:

public virtual MonoTouch.CoreGraphics.CGVector CGVectorValue { get; }
    public virtual MonoTouch.SceneKit.SCNMatrix4 SCNMatrix4Value { 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 FromSCNMatrix4 (MonoTouch.SceneKit.SCNMatrix4 matrix);
    public static NSValue FromVector (MonoTouch.SceneKit.SCNVector3 vector);
    public static NSValue FromVector (MonoTouch.SceneKit.SCNVector4 vector);

New Type MonoTouch.Foundation.EncodingDetectionOptions

public class EncodingDetectionOptions : MonoTouch.Foundation.DictionaryContainer {
    // constructors
    public EncodingDetectionOptions ();
    public EncodingDetectionOptions (NSDictionary dictionary);
    // properties
    public bool? EncodingDetectionAllowLossy { get; set; }
    public NSStringEncoding[] EncodingDetectionDisallowedEncodings { get; set; }
    public bool? EncodingDetectionFromWindows { get; set; }
    public NSString EncodingDetectionLikelyLanguage { get; set; }
    public NSString EncodingDetectionLossySubstitution { get; set; }
    public NSStringEncoding[] EncodingDetectionSuggestedEncodings { get; set; }
    public bool? EncodingDetectionUseOnlySuggestedEncodings { get; set; }
}

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.EnumerateIndexSetCallback

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

New Type MonoTouch.Foundation.INSUserActivityDelegate

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

New Type MonoTouch.Foundation.NSCocoaError

[Serializable]
public enum NSCocoaError {
    ExecutableArchitectureMismatch = 3585,
    ExecutableErrorMaximum = 3839,
    ExecutableErrorMinimum = 3584,
    ExecutableLink = 3588,
    ExecutableLoad = 3587,
    ExecutableNotLoadable = 3584,
    ExecutableRuntimeMismatch = 3586,
    FeatureUnsupported = 3328,
    FileErrorMaximum = 1023,
    FileErrorMinimum = 0,
    FileLocking = 255,
    FileNoSuchFile = 4,
    FileReadCorruptFile = 259,
    FileReadInapplicableStringEncoding = 261,
    FileReadInvalidFileName = 258,
    FileReadNoPermission = 257,
    FileReadNoSuchFile = 260,
    FileReadTooLarge = 263,
    FileReadUnknown = 256,
    FileReadUnknownStringEncoding = 264,
    FileReadUnsupportedScheme = 262,
    FileWriteFileExists = 516,
    FileWriteInapplicableStringEncoding = 517,
    FileWriteInvalidFileName = 514,
    FileWriteNoPermission = 513,
    FileWriteOutOfSpace = 640,
    FileWriteUnknown = 512,
    FileWriteUnsupportedScheme = 518,
    FileWriteVolumeReadOnly = 642,
    Formatting = 2048,
    FormattingErrorMaximum = 2559,
    FormattingErrorMinimum = 2048,
    KeyValueValidation = 1024,
    None = 0,
    PropertyListErrorMaximum = 4095,
    PropertyListErrorMinimum = 3840,
    PropertyListReadCorrupt = 3840,
    PropertyListReadStream = 3842,
    PropertyListReadUnknownVersion = 3841,
    PropertyListWriteInvalid = 3852,
    PropertyListWriteStream = 3851,
    UbiquitousFileErrorMaximum = 4607,
    UbiquitousFileErrorMinimum = 4352,
    UbiquitousFileNotUploadedDueToQuota = 4354,
    UbiquitousFileUbiquityServerNotAvailable = 4355,
    UbiquitousFileUnavailable = 4353,
    UserCancelled = 3072,
    ValidationErrorMaximum = 2047,
    ValidationErrorMinimum = 1024,
    XpcConnectionErrorMaximum = 4224,
    XpcConnectionErrorMinimum = 4096,
    XpcConnectionInterrupted = 4097,
    XpcConnectionInvalid = 4099,
    XpcConnectionReplyInvalid = 4101,
}

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.NSExtension

public class NSExtension {
    // methods
    public static void Initialize ();
}

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 abstract 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 {
}

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
    public static NSFileAccessIntent CreateReadingIntent (NSUrl url, NSFileCoordinatorReadingOptions options);
    public static NSFileAccessIntent CreateWritingIntent (NSUrl url, NSFileCoordinatorWritingOptions options);
    protected override void Dispose (bool disposing);
}

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 HasItemConformingTo (string typeIdentifier);
    public virtual void LoadItem (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.NSLengthFormatter

public class NSLengthFormatter : MonoTouch.Foundation.NSFormatter, INSCoding, INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public NSLengthFormatter ();
    public NSLengthFormatter (NSCoder coder);
    public NSLengthFormatter (NSObjectFlag t);
    public NSLengthFormatter (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual bool ForPersonHeightUse { 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 StringFromMeters (double numberInMeters);
    public virtual string StringFromValue (double value, NSLengthFormatterUnit unit);
    public virtual string UnitStringFromMeters (double numberInMeters, ref NSLengthFormatterUnit unitp);
    public virtual string UnitStringFromValue (double value, NSLengthFormatterUnit unit);
}

New Type MonoTouch.Foundation.NSLengthFormatterUnit

[Serializable]
public enum NSLengthFormatterUnit {
    Centimeter = 9,
    Foot = 1282,
    Inch = 1281,
    Kilometer = 14,
    Meter = 11,
    Mile = 1284,
    Millimeter = 8,
    Yard = 1283,
}

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, ref 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.NSObservedChange

public class NSObservedChange {
    // properties
    public NSKeyValueChange Change { get; }
    public NSIndexSet Indexes { get; }
    public bool IsPrior { get; }
    public NSObject NewValue { get; }
    public NSObject OldValue { get; }
}

New Type MonoTouch.Foundation.NSOperatingSystemVersion

public struct NSOperatingSystemVersion {
    // constructors
    public NSOperatingSystemVersion (int major, int minor, int patchVersion);
    // fields
    public int Major;
    public int Minor;
    public int PatchVersion;
    // methods
    public override string ToString ();
}

New Type MonoTouch.Foundation.NSQualityOfService

[Serializable]
public enum NSQualityOfService {
    Background = 9,
    Default = -1,
    UserInitiated = 25,
    UserInteractive = 33,
    Utility = 17,
}

New Type MonoTouch.Foundation.NSUrl_PromisedItems

public static class NSUrl_PromisedItems {
    // methods
    public static bool CheckPromisedItemIsReachable (NSUrl This, out NSError error);
    public static bool GetPromisedItemResourceValue (NSUrl This, NSObject value, NSString key, out NSError error);
    public static NSDictionary GetPromisedItemResourceValues (NSUrl This, NSString[] keys, out NSError error);
}

New Type MonoTouch.Foundation.NSUrlQueryItem

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

New Type MonoTouch.Foundation.NSURLRelationship

[Serializable]
public enum NSURLRelationship {
    Contains = 0,
    Other = 2,
    Same = 1,
}

New Type MonoTouch.Foundation.NSURLSessionTaskPriority

public static class NSURLSessionTaskPriority {
    // properties
    public static float Default { get; }
    public static float High { get; }
    public static float Low { get; }
}

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 (NSString 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);
}

New Type MonoTouch.Foundation.NSUserActivityType

public static class NSUserActivityType {
    // properties
    public static NSString BrowsingWeb { get; }
}

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.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 pressed, System.AsyncCallback callback, object object);
    public virtual void EndInvoke (System.IAsyncResult result);
    public virtual void Invoke (GCControllerButtonInput button, float buttonValue, bool pressed);
}

New Type MonoTouch.GameController.GCMotion

public class GCMotion : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public GCMotion (MonoTouch.Foundation.NSCoder coder);
    public GCMotion (MonoTouch.Foundation.NSObjectFlag t);
    public GCMotion (System.IntPtr handle);
    // properties
    public virtual OpenTK.Quaterniond Attitude { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual GCController Controller { get; }
    public virtual OpenTK.Vector3d Gravity { get; }
    public virtual OpenTK.Vector3d RotationRate { get; }
    public virtual OpenTK.Vector3d UserAcceleration { get; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual void SetValueChangedHandler (System.Action<GCMotion> handler);
}

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.GKAchievementDescription

Obsoleted property:

[Obsolete ("Deprecated in iOS 7.0")]
    public virtual MonoTouch.UIKit.UIImage Image { get; }

Type Changed: MonoTouch.GameKit.GKAchievementViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static GKAchievementViewController.GKAchievementViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static GKAchievementViewController.GKAchievementViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

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 methods:

public virtual void AddRecipientPlayers (GKPlayer[] players);
    public static GKFriendRequestComposeViewController.GKFriendRequestComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static GKFriendRequestComposeViewController.GKFriendRequestComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.GameKit.GKGameCenterViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.GameKit.GKInvite

Added property:

public virtual GKPlayer Sender { get; }

Added method:

protected override void Dispose (bool disposing);

Type Changed: MonoTouch.GameKit.GKInviteEventListener

Added method:

public virtual void DidRequestMatch (GKPlayer player, GKPlayer[] recipientPlayers);

Type Changed: MonoTouch.GameKit.GKInviteEventListener_Extensions

Added method:

public static void DidRequestMatch (IGKInviteEventListener This, GKPlayer player, GKPlayer[] recipientPlayers);

Type Changed: MonoTouch.GameKit.GKLeaderboard

Added constructor:

public GKLeaderboard (GKPlayer[] players);

Type Changed: MonoTouch.GameKit.GKLeaderboardViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static GKLeaderboardViewController.GKLeaderboardViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static GKLeaderboardViewController.GKLeaderboardViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.GameKit.GKLocalPlayer

Added methods:

public virtual void DeleteSavedGames (string name, System.Action<MonoTouch.Foundation.NSError> handler);
    public virtual void FetchSavedGames (System.Action<GKSavedGame[],MonoTouch.Foundation.NSError> handler);
    public virtual void LoadFriendPlayers (System.Action<GKPlayer[],MonoTouch.Foundation.NSError> completionHandler);
    public virtual System.Threading.Tasks.Task<GKPlayer[]> LoadFriendPlayersAsync ();
    public virtual void ResolveConflictingSavedGames (GKSavedGame[] conflictingSavedGames, MonoTouch.Foundation.NSData data, System.Action<GKSavedGame[],MonoTouch.Foundation.NSError> handler);
    public virtual void SaveGameData (MonoTouch.Foundation.NSData data, string name, System.Action<GKSavedGame,MonoTouch.Foundation.NSError> handler);

Type Changed: MonoTouch.GameKit.GKLocalPlayerListener

Added interface:

IGKSavedGameListener

Added methods:

public virtual void DidModifySavedGame (GKPlayer player, GKSavedGame savedGame);
    public virtual void DidRequestMatch (GKPlayer player, GKPlayer[] recipientPlayers);
    public virtual void DidRequestMatchWithOtherPlayers (GKPlayer player, GKPlayer[] playersToInvite);
    public virtual void HasConflictingSavedGames (GKPlayer player, GKSavedGame[] savedGames);

Type Changed: MonoTouch.GameKit.GKMatch

Added properties:

public virtual GKPlayer[] Players { get; }
    public GKMatchReinvitationForDisconnectedPlayer ShouldReinviteDisconnectedPlayer { get; set; }

Added events:

public event System.EventHandler<GKMatchReceivedDataFromRemotePlayerEventArgs> DataReceivedFromPlayer;
    public event System.EventHandler<GKMatchConnectionChangedEventArgs> StateChangedForPlayer;

Removed method:

public virtual bool SendDataToAllPlayers (MonoTouch.Foundation.NSData data, GKMatchSendDataMode mode, System.IntPtr ptrToNSErrorHandle);

Added methods:

public virtual void ChooseBestHostingPlayer (System.Action<GKPlayer> completionHandler);
    public virtual bool SendData (MonoTouch.Foundation.NSData data, string[] players, GKMatchSendDataMode mode, out MonoTouch.Foundation.NSError error);
    public virtual bool SendData (MonoTouch.Foundation.NSData data, GKPlayer[] players, GKMatchSendDataMode mode, out MonoTouch.Foundation.NSError error);
    public virtual bool SendDataToAllPlayer (MonoTouch.Foundation.NSData data, GKMatchSendDataMode mode, out MonoTouch.Foundation.NSError error);

Type Changed: MonoTouch.GameKit.GKMatchDelegate

Added methods:

public virtual void DataReceivedFromPlayer (GKMatch match, MonoTouch.Foundation.NSData data, GKPlayer player);
    public virtual bool ShouldReinviteDisconnectedPlayer (GKMatch match, GKPlayer player);
    public virtual void StateChangedForPlayer (GKMatch match, GKPlayer player, GKPlayerConnectionState state);

Type Changed: MonoTouch.GameKit.GKMatchDelegate_Extensions

Added methods:

public static void DataReceived (IGKMatchDelegate This, GKMatch match, MonoTouch.Foundation.NSData data, string playerId);
    public static void DataReceivedFromPlayer (IGKMatchDelegate This, GKMatch match, MonoTouch.Foundation.NSData data, GKPlayer player);
    public static bool ShouldReinviteDisconnectedPlayer (IGKMatchDelegate This, GKMatch match, GKPlayer player);
    public static void StateChangedForPlayer (IGKMatchDelegate This, GKMatch match, GKPlayer player, GKPlayerConnectionState state);

Type Changed: MonoTouch.GameKit.GKMatchmaker

Added methods:

public virtual void CancelPendingInvite (GKPlayer player);
    public virtual void FindPlayersForHostedRequest (GKMatchRequest request, System.Action<GKPlayer[],MonoTouch.Foundation.NSError> completionHandler);
    public virtual System.Threading.Tasks.Task<GKPlayer[]> FindPlayersForHostedRequestAsync (GKMatchRequest request);
    public virtual void StartBrowsingForNearbyPlayers (System.Action<GKPlayer,System.Boolean> handler);

Type Changed: MonoTouch.GameKit.GKMatchmakerViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added events:

public event System.EventHandler<GKMatchmakingPlayersEventArgs> DidFindHostedPlayers;
    public event System.EventHandler<GKMatchmakingPlayerEventArgs> HostedPlayerDidAccept;

Added method:

public virtual void SetHostedPlayerConnected (GKPlayer playerID, bool connected);

Type Changed: MonoTouch.GameKit.GKMatchmakerViewControllerDelegate

Added methods:

public virtual void DidFindHostedPlayers (GKMatchmakerViewController viewController, GKPlayer[] playerIDs);
    public virtual void HostedPlayerDidAccept (GKMatchmakerViewController viewController, GKPlayer playerID);

Type Changed: MonoTouch.GameKit.GKMatchmakerViewControllerDelegate_Extensions

Added method:

public static void HostedPlayerDidAccept (IGKMatchmakerViewControllerDelegate This, GKMatchmakerViewController viewController, GKPlayer playerID);

Type Changed: MonoTouch.GameKit.GKMatchRequest

Added property:

public virtual GKPlayer[] Recipients { get; set; }

Added methods:

protected override void Dispose (bool disposing);
    public virtual void SetRecipientResponseHandler (System.Action<GKPlayer,MonoTouch.GameKit.GKInviteRecipientResponse> handler);

Type Changed: MonoTouch.GameKit.GKScore

Added constructor:

public GKScore (string identifier, GKPlayer player);

Added property:

public virtual GKPlayer GamePlayer { get; }

Added method:

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

Type Changed: MonoTouch.GameKit.GKTurnBasedEventListener

Added method:

public virtual void DidRequestMatchWithOtherPlayers (GKPlayer player, GKPlayer[] playersToInvite);

Type Changed: MonoTouch.GameKit.GKTurnBasedEventListener_Extensions

Added method:

public static void DidRequestMatchWithOtherPlayers (IGKTurnBasedEventListener This, GKPlayer player, GKPlayer[] playersToInvite);

Type Changed: MonoTouch.GameKit.GKTurnBasedExchangeReply

Added property:

public virtual MonoTouch.Foundation.NSDate ReplyDate { get; }

Type Changed: MonoTouch.GameKit.GKTurnBasedMatchmakerViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static GKTurnBasedMatchmakerViewController.GKTurnBasedMatchmakerViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static GKTurnBasedMatchmakerViewController.GKTurnBasedMatchmakerViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.GameKit.GKTurnBasedParticipant

Added property:

public virtual GKPlayer Player { get; }

Type Changed: MonoTouch.GameKit.GKVoiceChat

Added property:

public virtual GKPlayer[] Players { get; }

Added methods:

protected override void Dispose (bool disposing);
    public virtual void SetMuteStatus (GKPlayer player, bool isMuted);
    public virtual void SetPlayerVoiceChatStateChangeHandler (System.Action<GKPlayer,MonoTouch.GameKit.GKVoiceChatPlayerState> handler);

Type Changed: MonoTouch.GameKit.IGKLocalPlayerListener

Added interface:

IGKSavedGameListener

Type Changed: MonoTouch.GameKit.IGKMatchDelegate

Removed method:

public virtual void DataReceived (GKMatch match, MonoTouch.Foundation.NSData data, string playerId);

Type Changed: MonoTouch.GameKit.IGKMatchmakerViewControllerDelegate

Added method:

public virtual void DidFindHostedPlayers (GKMatchmakerViewController viewController, GKPlayer[] playerIDs);

New Type MonoTouch.GameKit.GKInviteRecipientResponse

[Serializable]
public enum GKInviteRecipientResponse {
    Accepted = 0,
    Declined = 1,
    Failed = 2,
    Incompatible = 3,
    NoAnswer = 5,
    UnableToConnect = 4,
}

New Type MonoTouch.GameKit.GKMatchConnectionChangedEventArgs

public class GKMatchConnectionChangedEventArgs : System.EventArgs {
    // constructors
    public GKMatchConnectionChangedEventArgs (GKPlayer player, GKPlayerConnectionState state);
    // properties
    public GKPlayer Player { get; set; }
    public GKPlayerConnectionState State { get; set; }
}

New Type MonoTouch.GameKit.GKMatchmakingPlayerEventArgs

public class GKMatchmakingPlayerEventArgs : System.EventArgs {
    // constructors
    public GKMatchmakingPlayerEventArgs (GKPlayer playerID);
    // properties
    public GKPlayer PlayerID { get; set; }
}

New Type MonoTouch.GameKit.GKMatchmakingPlayersEventArgs

public class GKMatchmakingPlayersEventArgs : System.EventArgs {
    // constructors
    public GKMatchmakingPlayersEventArgs (GKPlayer[] playerIDs);
    // properties
    public GKPlayer[] PlayerIDs { get; set; }
}

New Type MonoTouch.GameKit.GKMatchReceivedDataFromRemotePlayerEventArgs

public class GKMatchReceivedDataFromRemotePlayerEventArgs : System.EventArgs {
    // constructors
    public GKMatchReceivedDataFromRemotePlayerEventArgs (MonoTouch.Foundation.NSData data, GKPlayer player);
    // properties
    public MonoTouch.Foundation.NSData Data { get; set; }
    public GKPlayer Player { get; set; }
}

New Type MonoTouch.GameKit.GKMatchReinvitationForDisconnectedPlayer

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

New Type MonoTouch.GameKit.GKSavedGame

public class GKSavedGame : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public GKSavedGame ();
    public GKSavedGame (MonoTouch.Foundation.NSCoder coder);
    public GKSavedGame (MonoTouch.Foundation.NSObjectFlag t);
    public GKSavedGame (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual string DeviceName { get; }
    public virtual MonoTouch.Foundation.NSDate ModificationDate { get; }
    public virtual string Name { get; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    protected override void Dispose (bool disposing);
    public virtual void LoadData (System.Action<MonoTouch.Foundation.NSData,MonoTouch.Foundation.NSError> handler);
    public virtual System.Threading.Tasks.Task<MonoTouch.Foundation.NSData> LoadDataAsync ();
}

New Type MonoTouch.GameKit.GKSavedGameListener

public class GKSavedGameListener : MonoTouch.Foundation.NSObject, IGKSavedGameListener, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public GKSavedGameListener ();
    public GKSavedGameListener (MonoTouch.Foundation.NSCoder coder);
    public GKSavedGameListener (MonoTouch.Foundation.NSObjectFlag t);
    public GKSavedGameListener (System.IntPtr handle);
    // methods
    public virtual void DidModifySavedGame (GKPlayer player, GKSavedGame savedGame);
    public virtual void HasConflictingSavedGames (GKPlayer player, GKSavedGame[] savedGames);
}

New Type MonoTouch.GameKit.GKSavedGameListener_Extensions

public static class GKSavedGameListener_Extensions {
    // methods
    public static void DidModifySavedGame (IGKSavedGameListener This, GKPlayer player, GKSavedGame savedGame);
    public static void HasConflictingSavedGames (IGKSavedGameListener This, GKPlayer player, GKSavedGame[] savedGames);
}

New Type MonoTouch.GameKit.IGKSavedGameListener

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

Namespace MonoTouch.GLKit

Type Changed: MonoTouch.GLKit.GLKView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static GLKView.GLKViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static GLKView.GLKViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.GLKit.GLKViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.iAd

Type Changed: MonoTouch.iAd.ADBannerView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static ADBannerView.ADBannerViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static ADBannerView.ADBannerViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.iAd.ADClient

Added methods:

public virtual void AddClientToSegments (string[] segmentIdentifiers, bool replaceExisting);
    public virtual void LookupAdConversionDetails (ADConversionDetails onCompleted);
    public virtual System.Threading.Tasks.Task<ADClientConversionDetailsResult> LookupAdConversionDetailsAsync ();

Type Changed: MonoTouch.iAd.IAdPreroll

Added method:

public static void CancelPreroll (MonoTouch.MediaPlayer.MPMoviePlayerController This);

New Type MonoTouch.iAd.ADClientConversionDetailsResult

public class ADClientConversionDetailsResult {
    // constructors
    public ADClientConversionDetailsResult (MonoTouch.Foundation.NSDate appPurchaseDate, MonoTouch.Foundation.NSDate iAdImpressionDate);
    // properties
    public MonoTouch.Foundation.NSDate AppPurchaseDate { get; set; }
    public MonoTouch.Foundation.NSDate IAdImpressionDate { get; set; }
}

New Type MonoTouch.iAd.ADConversionDetails

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

New Type MonoTouch.iAd.iAdPreroll_AVPlayerViewController

public static class iAdPreroll_AVPlayerViewController {
    // methods
    public static void CancelPreroll (MonoTouch.AVKit.AVPlayerViewController This);
    public static void PlayPrerollAd (MonoTouch.AVKit.AVPlayerViewController This, System.Action<MonoTouch.Foundation.NSError> completionHandler);
    public static void PreparePrerollAds (MonoTouch.AVKit.AVPlayerViewController This);
}

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 GPSHPositioningError { get; }
    public static MonoTouch.Foundation.NSString PNGDelayTime { get; }
    public static MonoTouch.Foundation.NSString PNGLoopCount { get; }
    public static MonoTouch.Foundation.NSString PNGUnclampedDelayTime { get; }

New Type MonoTouch.ImageIO.CGImagePropertyOrientation

[Serializable]
public enum CGImagePropertyOrientation {
    Down = 3,
    DownMirrored = 4,
    Left = 8,
    LeftMirrored = 5,
    Right = 6,
    RightMirrored = 7,
    Up = 1,
    UpMirrored = 2,
}

Namespace MonoTouch.JavaScriptCore

Type Changed: MonoTouch.JavaScriptCore.JSContext

Added properties:

public static JSValue CurrentCallee { get; }
    public virtual System.IntPtr JSGlobalContextRefPtr { get; }
    public virtual string Name { get; set; }

Added methods:

public virtual JSValue EvaluateScript (string script, MonoTouch.Foundation.NSUrl sourceUrl);
    public static JSContext FromJSGlobalContextRef (System.IntPtr nativeJsGlobalContextRef);

Type Changed: MonoTouch.JavaScriptCore.JSManagedValue

Added method:

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

Type Changed: MonoTouch.JavaScriptCore.JSValue

Added property:

public virtual System.IntPtr JSValueRefPtr { get; }

Added method:

public static JSValue FromJSJSValueRef (System.IntPtr nativeJsValueRefvalue, JSContext context);

Namespace MonoTouch.MapKit

Type Changed: MonoTouch.MapKit.IMKOverlay

Added interface:

IMKAnnotation

Type Changed: MonoTouch.MapKit.MKAnnotationView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKAnnotationView.MKAnnotationViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKAnnotationView.MKAnnotationViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKCircleView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKCircleView.MKCircleViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKCircleView.MKCircleViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

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 interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKMapView.MKMapViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKMapView.MKMapViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKOverlayPathView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKOverlayPathView.MKOverlayPathViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKOverlayPathView.MKOverlayPathViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKOverlayView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKOverlayView.MKOverlayViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKOverlayView.MKOverlayViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKPinAnnotationView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKPinAnnotationView.MKPinAnnotationViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKPinAnnotationView.MKPinAnnotationViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKPlacemark

Added constructor:

public MKPlacemark (MonoTouch.CoreLocation.CLLocationCoordinate2D coordinate, MKPlacemarkAddress addressDictionary);

Type Changed: MonoTouch.MapKit.MKPolygonView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKPolygonView.MKPolygonViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKPolygonView.MKPolygonViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKPolylineView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MKPolylineView.MKPolylineViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKPolylineView.MKPolylineViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MapKit.MKTileOverlayRenderer

Obsoleted constructor:

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

Type Changed: MonoTouch.MapKit.MKUserTrackingBarButtonItem

Added methods:

public static MKUserTrackingBarButtonItem.MKUserTrackingBarButtonItemAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MKUserTrackingBarButtonItem.MKUserTrackingBarButtonItemAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

New Type MonoTouch.MapKit.MKPlacemarkAddress

public class MKPlacemarkAddress : MonoTouch.Foundation.DictionaryContainer {
    // constructors
    public MKPlacemarkAddress ();
    public MKPlacemarkAddress (MonoTouch.Foundation.NSDictionary dictionary);
    // properties
    public string City { get; set; }
    public string Country { get; set; }
    public string CountryCode { get; set; }
    public string State { get; set; }
    public string Street { get; set; }
    public string Zip { get; set; }
}

Namespace MonoTouch.MediaPlayer

Type Changed: MonoTouch.MediaPlayer.MPMediaPickerController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Type Changed: MonoTouch.MediaPlayer.MPMediaPlaylist

Added properties:

public virtual string Name { get; }
    public virtual ulong PersistentID { get; }
    public virtual MPMediaPlaylistAttribute PlaylistAttributes { get; }
    public virtual MPMediaItem[] SeedItems { get; }

Added method:

protected override void Dispose (bool disposing);

Type Changed: MonoTouch.MediaPlayer.MPMediaQuery

Added methods:

public MPMediaItemCollection GetCollection (int index);
    public MPMediaItem GetItem (int index);
    public MPMediaQuerySection GetSection (int index);

Type Changed: MonoTouch.MediaPlayer.MPMoviePlayerViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Removed methods:

public virtual MonoTouch.UIKit.UIInterfaceOrientationMask GetSupportedInterfaceOrientations ();
    public virtual bool ShouldAutorotate ();

Type Changed: MonoTouch.MediaPlayer.MPMusicPlayerController

Added property:

public static MPMusicPlayerController SystemMusicPlayer { get; }

Type Changed: MonoTouch.MediaPlayer.MPNowPlayingInfo

Added field:

public double? DefaultPlaybackRate;

Type Changed: MonoTouch.MediaPlayer.MPVolumeView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    MonoTouch.UIKit.IUITraitEnvironment

Removed method:

public virtual System.Drawing.SizeF SizeThatFits (System.Drawing.SizeF f);

Added methods:

public static MPVolumeView.MPVolumeViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);
    public static MPVolumeView.MPVolumeViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);

Namespace MonoTouch.MessageUI

Type Changed: MonoTouch.MessageUI.IMFMailComposeViewControllerDelegate

Added interface:

MonoTouch.UIKit.IUINavigationControllerDelegate

Type Changed: MonoTouch.MessageUI.MFMailComposeViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MFMailComposeViewController.MFMailComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MFMailComposeViewController.MFMailComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.MessageUI.MFMessageComposeViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added methods:

public static MFMessageComposeViewController.MFMessageComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static MFMessageComposeViewController.MFMessageComposeViewControllerAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);

Namespace MonoTouch.MobileCoreServices

Type Changed: MonoTouch.MobileCoreServices.UTType

Removed fields:

public static MonoTouch.Foundation.NSString AliasFile;
    public static MonoTouch.Foundation.NSString AliasRecord;
    public static MonoTouch.Foundation.NSString AppleICNS;
    public static MonoTouch.Foundation.NSString AppleProtectedMPEG4Audio;
    public static MonoTouch.Foundation.NSString Application;
    public static MonoTouch.Foundation.NSString ApplicationBundle;
    public static MonoTouch.Foundation.NSString ApplicationFile;
    public static MonoTouch.Foundation.NSString Archive;
    public static MonoTouch.Foundation.NSString Audio;
    public static MonoTouch.Foundation.NSString AudiovisualContent;
    public static MonoTouch.Foundation.NSString BMP;
    public static MonoTouch.Foundation.NSString Bundle;
    public static MonoTouch.Foundation.NSString CHeader;
    public static MonoTouch.Foundation.NSString CompositeContent;
    public static MonoTouch.Foundation.NSString ConformsToKey;
    public static MonoTouch.Foundation.NSString Contact;
    public static MonoTouch.Foundation.NSString Content;
    public static MonoTouch.Foundation.NSString CPlusPlusHeader;
    public static MonoTouch.Foundation.NSString CPlusPlusSource;
    public static MonoTouch.Foundation.NSString CSource;
    public static MonoTouch.Foundation.NSString Data;
    public static MonoTouch.Foundation.NSString DescriptionKey;
    public static MonoTouch.Foundation.NSString Directory;
    public static MonoTouch.Foundation.NSString DiskImage;
    public static MonoTouch.Foundation.NSString ExportedTypeDeclarationsKey;
    public static MonoTouch.Foundation.NSString FileURL;
    public static MonoTouch.Foundation.NSString FlatRTFD;
    public static MonoTouch.Foundation.NSString Folder;
    public static MonoTouch.Foundation.NSString Framework;
    public static MonoTouch.Foundation.NSString GIF;
    public static MonoTouch.Foundation.NSString HTML;
    public static MonoTouch.Foundation.NSString ICO;
    public static MonoTouch.Foundation.NSString IconFileKey;
    public static MonoTouch.Foundation.NSString IdentifierKey;
    public static MonoTouch.Foundation.NSString Image;
    public static MonoTouch.Foundation.NSString ImportedTypeDeclarationsKey;
    public static MonoTouch.Foundation.NSString InkText;
    public static MonoTouch.Foundation.NSString Item;
    public static MonoTouch.Foundation.NSString JavaSource;
    public static MonoTouch.Foundation.NSString JPEG;
    public static MonoTouch.Foundation.NSString JPEG2000;
    public static MonoTouch.Foundation.NSString Message;
    public static MonoTouch.Foundation.NSString MountPoint;
    public static MonoTouch.Foundation.NSString Movie;
    public static MonoTouch.Foundation.NSString MP3;
    public static MonoTouch.Foundation.NSString MPEG;
    public static MonoTouch.Foundation.NSString MPEG4;
    public static MonoTouch.Foundation.NSString MPEG4Audio;
    public static MonoTouch.Foundation.NSString ObjectiveCPlusPlusSource;
    public static MonoTouch.Foundation.NSString ObjectiveCSource;
    public static MonoTouch.Foundation.NSString Package;
    public static MonoTouch.Foundation.NSString PDF;
    public static MonoTouch.Foundation.NSString PICT;
    public static MonoTouch.Foundation.NSString PlainText;
    public static MonoTouch.Foundation.NSString PNG;
    public static MonoTouch.Foundation.NSString QuickTimeImage;
    public static MonoTouch.Foundation.NSString QuickTimeMovie;
    public static MonoTouch.Foundation.NSString ReferenceURLKey;
    public static MonoTouch.Foundation.NSString Resolvable;
    public static MonoTouch.Foundation.NSString RTF;
    public static MonoTouch.Foundation.NSString RTFD;
    public static MonoTouch.Foundation.NSString SourceCode;
    public static MonoTouch.Foundation.NSString SymLink;
    public static MonoTouch.Foundation.NSString TagClassFilenameExtension;
    public static MonoTouch.Foundation.NSString TagClassMIMEType;
    public static MonoTouch.Foundation.NSString TagSpecificationKey;
    public static MonoTouch.Foundation.NSString Text;
    public static MonoTouch.Foundation.NSString TIFF;
    public static MonoTouch.Foundation.NSString TXNTextAndMultimediaData;
    public static MonoTouch.Foundation.NSString URL;
    public static MonoTouch.Foundation.NSString UTF16ExternalPlainText;
    public static MonoTouch.Foundation.NSString UTF16PlainText;
    public static MonoTouch.Foundation.NSString UTF8PlainText;
    public static MonoTouch.Foundation.NSString VCard;
    public static MonoTouch.Foundation.NSString VersionKey;
    public static MonoTouch.Foundation.NSString Video;
    public static MonoTouch.Foundation.NSString Volume;
    public static MonoTouch.Foundation.NSString WebArchive;
    public static MonoTouch.Foundation.NSString XML;

Added properties:

public static MonoTouch.Foundation.NSString AliasFile { get; }
    public static MonoTouch.Foundation.NSString AliasRecord { get; }
    public static MonoTouch.Foundation.NSString AppleICNS { get; }
    public static MonoTouch.Foundation.NSString AppleProtectedMPEG4Audio { get; }
    public static MonoTouch.Foundation.NSString AppleProtectedMPEG4Video { get; }
    public static MonoTouch.Foundation.NSString AppleScript { get; }
    public static MonoTouch.Foundation.NSString Application { get; }
    public static MonoTouch.Foundation.NSString ApplicationBundle { get; }
    public static MonoTouch.Foundation.NSString ApplicationFile { get; }
    public static MonoTouch.Foundation.NSString Archive { get; }
    public static MonoTouch.Foundation.NSString AssemblyLanguageSource { get; }
    public static MonoTouch.Foundation.NSString Audio { get; }
    public static MonoTouch.Foundation.NSString AudioInterchangeFileFormat { get; }
    public static MonoTouch.Foundation.NSString AudiovisualContent { get; }
    public static MonoTouch.Foundation.NSString AVIMovie { get; }
    public static MonoTouch.Foundation.NSString BinaryPropertyList { get; }
    public static MonoTouch.Foundation.NSString BMP { get; }
    public static MonoTouch.Foundation.NSString Bookmark { get; }
    public static MonoTouch.Foundation.NSString Bundle { get; }
    public static MonoTouch.Foundation.NSString Bzip2Archive { get; }
    public static MonoTouch.Foundation.NSString CalendarEvent { get; }
    public static MonoTouch.Foundation.NSString CHeader { get; }
    public static MonoTouch.Foundation.NSString CommaSeparatedText { get; }
    public static MonoTouch.Foundation.NSString CompositeContent { get; }
    public static MonoTouch.Foundation.NSString ConformsToKey { get; }
    public static MonoTouch.Foundation.NSString Contact { get; }
    public static MonoTouch.Foundation.NSString Content { get; }
    public static MonoTouch.Foundation.NSString CPlusPlusHeader { get; }
    public static MonoTouch.Foundation.NSString CPlusPlusSource { get; }
    public static MonoTouch.Foundation.NSString CSource { get; }
    public static MonoTouch.Foundation.NSString Data { get; }
    public static MonoTouch.Foundation.NSString Database { get; }
    public static MonoTouch.Foundation.NSString DelimitedText { get; }
    public static MonoTouch.Foundation.NSString DescriptionKey { get; }
    public static MonoTouch.Foundation.NSString Directory { get; }
    public static MonoTouch.Foundation.NSString DiskImage { get; }
    public static MonoTouch.Foundation.NSString ElectronicPublication { get; }
    public static MonoTouch.Foundation.NSString EmailMessage { get; }
    public static MonoTouch.Foundation.NSString Executable { get; }
    public static MonoTouch.Foundation.NSString ExportedTypeDeclarationsKey { get; }
    public static MonoTouch.Foundation.NSString FileURL { get; }
    public static MonoTouch.Foundation.NSString FlatRTFD { get; }
    public static MonoTouch.Foundation.NSString Folder { get; }
    public static MonoTouch.Foundation.NSString Font { get; }
    public static MonoTouch.Foundation.NSString Framework { get; }
    public static MonoTouch.Foundation.NSString GIF { get; }
    public static MonoTouch.Foundation.NSString GNUZipArchive { get; }
    public static MonoTouch.Foundation.NSString HTML { get; }
    public static MonoTouch.Foundation.NSString ICO { get; }
    public static MonoTouch.Foundation.NSString IconFileKey { get; }
    public static MonoTouch.Foundation.NSString IdentifierKey { get; }
    public static MonoTouch.Foundation.NSString Image { get; }
    public static MonoTouch.Foundation.NSString ImportedTypeDeclarationsKey { get; }
    public static MonoTouch.Foundation.NSString InkText { get; }
    public static MonoTouch.Foundation.NSString InternetLocation { get; }
    public static MonoTouch.Foundation.NSString Item { get; }
    public static MonoTouch.Foundation.NSString JavaArchive { get; }
    public static MonoTouch.Foundation.NSString JavaClass { get; }
    public static MonoTouch.Foundation.NSString JavaScript { get; }
    public static MonoTouch.Foundation.NSString JavaSource { get; }
    public static MonoTouch.Foundation.NSString JPEG { get; }
    public static MonoTouch.Foundation.NSString JPEG2000 { get; }
    public static MonoTouch.Foundation.NSString JSON { get; }
    public static MonoTouch.Foundation.NSString Log { get; }
    public static MonoTouch.Foundation.NSString M3UPlaylist { get; }
    public static MonoTouch.Foundation.NSString Message { get; }
    public static MonoTouch.Foundation.NSString MIDIAudio { get; }
    public static MonoTouch.Foundation.NSString MountPoint { get; }
    public static MonoTouch.Foundation.NSString Movie { get; }
    public static MonoTouch.Foundation.NSString MP3 { get; }
    public static MonoTouch.Foundation.NSString MPEG { get; }
    public static MonoTouch.Foundation.NSString MPEG2TransportStream { get; }
    public static MonoTouch.Foundation.NSString MPEG2Video { get; }
    public static MonoTouch.Foundation.NSString MPEG4 { get; }
    public static MonoTouch.Foundation.NSString MPEG4Audio { get; }
    public static MonoTouch.Foundation.NSString ObjectiveCPlusPlusSource { get; }
    public static MonoTouch.Foundation.NSString ObjectiveCSource { get; }
    public static MonoTouch.Foundation.NSString OSAScript { get; }
    public static MonoTouch.Foundation.NSString OSAScriptBundle { get; }
    public static MonoTouch.Foundation.NSString Package { get; }
    public static MonoTouch.Foundation.NSString PDF { get; }
    public static MonoTouch.Foundation.NSString PerlScript { get; }
    public static MonoTouch.Foundation.NSString PHPScript { get; }
    public static MonoTouch.Foundation.NSString PICT { get; }
    public static MonoTouch.Foundation.NSString PKCS12 { get; }
    public static MonoTouch.Foundation.NSString PlainText { get; }
    public static MonoTouch.Foundation.NSString Playlist { get; }
    public static MonoTouch.Foundation.NSString PluginBundle { get; }
    public static MonoTouch.Foundation.NSString PNG { get; }
    public static MonoTouch.Foundation.NSString Presentation { get; }
    public static MonoTouch.Foundation.NSString PropertyList { get; }
    public static MonoTouch.Foundation.NSString PythonScript { get; }
    public static MonoTouch.Foundation.NSString QuickLookGenerator { get; }
    public static MonoTouch.Foundation.NSString QuickTimeImage { get; }
    public static MonoTouch.Foundation.NSString QuickTimeMovie { get; }
    public static MonoTouch.Foundation.NSString RawImage { get; }
    public static MonoTouch.Foundation.NSString ReferenceURLKey { get; }
    public static MonoTouch.Foundation.NSString Resolvable { get; }
    public static MonoTouch.Foundation.NSString RTF { get; }
    public static MonoTouch.Foundation.NSString RTFD { get; }
    public static MonoTouch.Foundation.NSString RubyScript { get; }
    public static MonoTouch.Foundation.NSString ScalableVectorGraphics { get; }
    public static MonoTouch.Foundation.NSString Script { get; }
    public static MonoTouch.Foundation.NSString ShellScript { get; }
    public static MonoTouch.Foundation.NSString SourceCode { get; }
    public static MonoTouch.Foundation.NSString SpotlightImporter { get; }
    public static MonoTouch.Foundation.NSString Spreadsheet { get; }
    public static MonoTouch.Foundation.NSString SymLink { get; }
    public static MonoTouch.Foundation.NSString SystemPreferencesPane { get; }
    public static MonoTouch.Foundation.NSString TabSeparatedText { get; }
    public static MonoTouch.Foundation.NSString TagClassFilenameExtension { get; }
    public static MonoTouch.Foundation.NSString TagClassMIMEType { get; }
    public static MonoTouch.Foundation.NSString TagSpecificationKey { get; }
    public static MonoTouch.Foundation.NSString Text { get; }
    public static MonoTouch.Foundation.NSString ThreeDContent { get; }
    public static MonoTouch.Foundation.NSString TIFF { get; }
    public static MonoTouch.Foundation.NSString ToDoItem { get; }
    public static MonoTouch.Foundation.NSString TXNTextAndMultimediaData { get; }
    public static MonoTouch.Foundation.NSString UnixExecutable { get; }
    public static MonoTouch.Foundation.NSString URL { get; }
    public static MonoTouch.Foundation.NSString URLBookmarkData { get; }
    public static MonoTouch.Foundation.NSString UTF16ExternalPlainText { get; }
    public static MonoTouch.Foundation.NSString UTF16PlainText { get; }
    public static MonoTouch.Foundation.NSString UTF8PlainText { get; }
    public static MonoTouch.Foundation.NSString UTF8TabSeparatedText { get; }
    public static MonoTouch.Foundation.NSString VCard { get; }
    public static MonoTouch.Foundation.NSString VersionKey { get; }
    public static MonoTouch.Foundation.NSString Video { get; }
    public static MonoTouch.Foundation.NSString Volume { get; }
    public static MonoTouch.Foundation.NSString WaveformAudio { get; }
    public static MonoTouch.Foundation.NSString WebArchive { get; }
    public static MonoTouch.Foundation.NSString WindowsExecutable { get; }
    public static MonoTouch.Foundation.NSString X509Certificate { get; }
    public static MonoTouch.Foundation.NSString XML { get; }
    public static MonoTouch.Foundation.NSString XMLPropertyList { get; }
    public static MonoTouch.Foundation.NSString XPCService { get; }
    public static MonoTouch.Foundation.NSString ZipArchive { get; }

Added methods:

public bool ConformsTo (string uti, string conformsToUti);
    public string[] CopyAllTags (string uti, string tagClass);
    public string[] CreateAllIdentifiers (string tagClass, string tag, string conformingToUti);
    public static string CreatePreferredIdentifier (string tagClass, string tag, string conformingToUti);
    public string GetDescription (string uti);
    public static bool IsDeclared (string utType);
    public static bool IsDynamic (string utType);

Namespace MonoTouch.MultipeerConnectivity

Type Changed: MonoTouch.MultipeerConnectivity.MCBrowserViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.PassKit

Type Changed: MonoTouch.PassKit.PKAddPassesViewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Added property:

public static bool CanAddPasses { get; }

Type Changed: MonoTouch.PassKit.PKPass

Added properties:

public virtual PKPassType PassType { get; }
    public virtual PKPaymentPass PaymentPass { get; }

Type Changed: MonoTouch.PassKit.PKPassKitErrorCode

Added value:

NotEntitled = 4,

Type Changed: MonoTouch.PassKit.PKPassLibrary

Added property:

public static bool IsPaymentPassActivationAvailable { get; }

Added methods:

public virtual void ActivatePaymentPass (PKPaymentPass paymentPass, MonoTouch.Foundation.NSData activationData, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
    public virtual void ActivatePaymentPass (PKPaymentPass paymentPass, string activationCode, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
    public virtual PKPass[] GetPasses (PKPassType passType);

New Type MonoTouch.PassKit.IPKPaymentAuthorizationViewControllerDelegate

public interface IPKPaymentAuthorizationViewControllerDelegate : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // methods
    public virtual void DidAuthorizePayment (PKPaymentAuthorizationViewController controller, PKPayment payment, PKPaymentAuthorizationHandler completion);
    public virtual void PaymentAuthorizationViewControllerDidFinish (PKPaymentAuthorizationViewController controller);
}

New Type MonoTouch.PassKit.PKAddressField

[Serializable]
[Flags]
public enum PKAddressField {
    All = 7,
    Email = 4,
    None = 0,
    Phone = 2,
    PostalAddress = 1,
}

New Type MonoTouch.PassKit.PKMerchantCapability

[Serializable]
public enum PKMerchantCapability {
    EMV = 2,
    ThreeDS = 1,
}

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);
}

New Type MonoTouch.PassKit.PKPassType

[Serializable]
public enum PKPassType {
    Barcode = 0,
    Payment = 1,
}

New Type MonoTouch.PassKit.PKPayment

public class PKPayment : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPayment ();
    public PKPayment (MonoTouch.Foundation.NSCoder coder);
    public PKPayment (MonoTouch.Foundation.NSObjectFlag t);
    public PKPayment (System.IntPtr handle);
    // properties
    public virtual MonoTouch.AddressBook.ABRecord BillingAddress { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.AddressBook.ABRecord ShippingAddress { get; }
    public virtual PKShippingMethod ShippingMethod { get; }
    public virtual PKPaymentToken Token { get; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.PassKit.PKPaymentAuthorizationEventArgs

public class PKPaymentAuthorizationEventArgs : System.EventArgs {
    // constructors
    public PKPaymentAuthorizationEventArgs (PKPayment payment, PKPaymentAuthorizationHandler completion);
    // properties
    public PKPaymentAuthorizationHandler Completion { get; set; }
    public PKPayment Payment { get; set; }
}

New Type MonoTouch.PassKit.PKPaymentAuthorizationHandler

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

New Type MonoTouch.PassKit.PKPaymentAuthorizationStatus

[Serializable]
public enum PKPaymentAuthorizationStatus {
    Failure = 1,
    InvalidBillingPostalAddress = 2,
    InvalidShippingContact = 4,
    InvalidShippingPostalAddress = 3,
    Success = 0,
}

New Type MonoTouch.PassKit.PKPaymentAuthorizationViewController

public class PKPaymentAuthorizationViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIContentContainer, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPaymentAuthorizationViewController ();
    public PKPaymentAuthorizationViewController (MonoTouch.Foundation.NSCoder coder);
    public PKPaymentAuthorizationViewController (MonoTouch.Foundation.NSObjectFlag t);
    public PKPaymentAuthorizationViewController (System.IntPtr handle);
    public PKPaymentAuthorizationViewController (PKPaymentRequest request);
    // properties
    public static bool CanMakePayments { get; }
    public override System.IntPtr ClassHandle { get; }
    public PKPaymentAuthorizationViewControllerDelegate Delegate { get; set; }
    public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
    // events
    public event System.EventHandler<PKPaymentAuthorizationEventArgs> DidAuthorizePayment;
    public event System.EventHandler<PKPaymentShippingAddressSelectedEventArgs> DidSelectShippingAddress;
    public event System.EventHandler<PKPaymentShippingMethodSelectedEventArgs> DidSelectShippingMethod;
    public event System.EventHandler PaymentAuthorizationViewControllerDidFinish;
    // methods
    public static bool CanMakePaymentsUsingNetworks (MonoTouch.Foundation.NSString[] paymentNetworks);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.PassKit.PKPaymentAuthorizationViewControllerDelegate

public abstract class PKPaymentAuthorizationViewControllerDelegate : MonoTouch.Foundation.NSObject, IPKPaymentAuthorizationViewControllerDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPaymentAuthorizationViewControllerDelegate ();
    public PKPaymentAuthorizationViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
    public PKPaymentAuthorizationViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
    public PKPaymentAuthorizationViewControllerDelegate (System.IntPtr handle);
    // methods
    public virtual void DidAuthorizePayment (PKPaymentAuthorizationViewController controller, PKPayment payment, PKPaymentAuthorizationHandler completion);
    public virtual void DidSelectShippingAddress (PKPaymentAuthorizationViewController controller, MonoTouch.AddressBook.ABRecord address, PKPaymentShippingAddressSelected completion);
    public virtual void DidSelectShippingMethod (PKPaymentAuthorizationViewController controller, PKShippingMethod shippingMethod, PKPaymentShippingMethodSelected completion);
    public virtual void PaymentAuthorizationViewControllerDidFinish (PKPaymentAuthorizationViewController controller);
}

New Type MonoTouch.PassKit.PKPaymentAuthorizationViewControllerDelegate_Extensions

public static class PKPaymentAuthorizationViewControllerDelegate_Extensions {
    // methods
    public static void DidSelectShippingAddress (IPKPaymentAuthorizationViewControllerDelegate This, PKPaymentAuthorizationViewController controller, MonoTouch.AddressBook.ABRecord address, PKPaymentShippingAddressSelected completion);
    public static void DidSelectShippingMethod (IPKPaymentAuthorizationViewControllerDelegate This, PKPaymentAuthorizationViewController controller, PKShippingMethod shippingMethod, PKPaymentShippingMethodSelected completion);
}

New Type MonoTouch.PassKit.PKPaymentNetwork

public static class PKPaymentNetwork {
    // properties
    public static MonoTouch.Foundation.NSString Amex { get; }
    public static MonoTouch.Foundation.NSString MasterCard { get; }
    public static MonoTouch.Foundation.NSString Visa { get; }
}

New Type MonoTouch.PassKit.PKPaymentPass

public class PKPaymentPass : MonoTouch.PassKit.PKPass, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSCopying, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPaymentPass ();
    public PKPaymentPass (MonoTouch.Foundation.NSCoder coder);
    public PKPaymentPass (MonoTouch.Foundation.NSObjectFlag t);
    public PKPaymentPass (System.IntPtr handle);
    // properties
    public virtual PKPaymentPassActivationState ActivationState { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual string DeviceAccountIdentifier { get; }
    public virtual string DeviceAccountNumberSuffix { get; }
    public virtual string PrimaryAccountIdentifier { get; }
    public virtual string PrimaryAccountNumberSuffix { get; }
}

New Type MonoTouch.PassKit.PKPaymentPassActivationState

[Serializable]
public enum PKPaymentPassActivationState {
    Activated = 0,
    Activating = 2,
    Deactivated = 4,
    RequiresActivation = 1,
    Suspended = 3,
}

New Type MonoTouch.PassKit.PKPaymentRequest

public class PKPaymentRequest : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPaymentRequest ();
    public PKPaymentRequest (MonoTouch.Foundation.NSCoder coder);
    public PKPaymentRequest (MonoTouch.Foundation.NSObjectFlag t);
    public PKPaymentRequest (System.IntPtr handle);
    // properties
    public virtual MonoTouch.Foundation.NSData ApplicationData { get; set; }
    public virtual MonoTouch.AddressBook.ABRecord BillingAddress { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual string CountryCode { get; set; }
    public virtual string CurrencyCode { get; set; }
    public virtual PKMerchantCapability MerchantCapabilities { get; set; }
    public virtual string MerchantIdentifier { get; set; }
    public virtual PKPaymentSummaryItem[] PaymentSummaryItems { get; set; }
    public virtual PKAddressField RequiredBillingAddressFields { get; set; }
    public virtual PKAddressField RequiredShippingAddressFields { get; set; }
    public virtual MonoTouch.AddressBook.ABRecord ShippingAddress { get; set; }
    public virtual PKShippingMethod[] ShippingMethods { get; set; }
    public virtual MonoTouch.Foundation.NSString[] SupportedNetworks { get; set; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.PassKit.PKPaymentShippingAddressSelected

public sealed delegate PKPaymentShippingAddressSelected : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public PKPaymentShippingAddressSelected (object object, System.IntPtr method);
    // methods
    public virtual System.IAsyncResult BeginInvoke (PKPaymentAuthorizationStatus status, PKShippingMethod[] shippingMethods, PKPaymentSummaryItem[] summaryItems, System.AsyncCallback callback, object object);
    public virtual void EndInvoke (System.IAsyncResult result);
    public virtual void Invoke (PKPaymentAuthorizationStatus status, PKShippingMethod[] shippingMethods, PKPaymentSummaryItem[] summaryItems);
}

New Type MonoTouch.PassKit.PKPaymentShippingAddressSelectedEventArgs

public class PKPaymentShippingAddressSelectedEventArgs : System.EventArgs {
    // constructors
    public PKPaymentShippingAddressSelectedEventArgs (MonoTouch.AddressBook.ABRecord address, PKPaymentShippingAddressSelected completion);
    // properties
    public MonoTouch.AddressBook.ABRecord Address { get; set; }
    public PKPaymentShippingAddressSelected Completion { get; set; }
}

New Type MonoTouch.PassKit.PKPaymentShippingMethodSelected

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

New Type MonoTouch.PassKit.PKPaymentShippingMethodSelectedEventArgs

public class PKPaymentShippingMethodSelectedEventArgs : System.EventArgs {
    // constructors
    public PKPaymentShippingMethodSelectedEventArgs (PKShippingMethod shippingMethod, PKPaymentShippingMethodSelected completion);
    // properties
    public PKPaymentShippingMethodSelected Completion { get; set; }
    public PKShippingMethod ShippingMethod { get; set; }
}

New Type MonoTouch.PassKit.PKPaymentSummaryItem

public class PKPaymentSummaryItem : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKPaymentSummaryItem ();
    public PKPaymentSummaryItem (MonoTouch.Foundation.NSCoder coder);
    public PKPaymentSummaryItem (MonoTouch.Foundation.NSObjectFlag t);
    public PKPaymentSummaryItem (System.IntPtr handle);
    // properties
    public virtual MonoTouch.Foundation.NSDecimalNumber Amount { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual string Label { get; set; }
    // methods
    public static PKPaymentSummaryItem Create (string label, MonoTouch.Foundation.NSDecimalNumber amount);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.PassKit.PKPaymentToken

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

New Type MonoTouch.PassKit.PKShippingMethod

public class PKShippingMethod : MonoTouch.PassKit.PKPaymentSummaryItem, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public PKShippingMethod ();
    public PKShippingMethod (MonoTouch.Foundation.NSCoder coder);
    public PKShippingMethod (MonoTouch.Foundation.NSObjectFlag t);
    public PKShippingMethod (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual string Detail { get; set; }
    public virtual string Identifier { get; set; }
}

Namespace MonoTouch.QuickLook

Type Changed: MonoTouch.QuickLook.QLPreviewController

Added interfaces:

MonoTouch.UIKit.IUIContentContainer
    MonoTouch.UIKit.IUITraitEnvironment

Namespace MonoTouch.Security

Type Changed: MonoTouch.Security.SecAccessible

Added value:

WhenPasscodeSetThisDeviceOnly = 6,

Type Changed: MonoTouch.Security.SecRecord

Added properties:

public SecAccessControl AccessControl { get; set; }
    public bool UseNoAuthenticationUI { get; set; }
    public string UseOperationPrompt { get; set; }

New Type MonoTouch.Security.SecAccessControl

public class SecAccessControl {
    // constructors
    public SecAccessControl (SecAccessible accessible, SecAccessControlCreateFlags flags);
    // properties
    public SecAccessible Accessible { get; }
    public SecAccessControlCreateFlags Flags { get; }
}

New Type MonoTouch.Security.SecAccessControlCreateFlags

[Serializable]
[Flags]
public enum SecAccessControlCreateFlags {
    UserPresence = 1,
}

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 Falloff (float to, double duration);
    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, double secs);
    public static SKAction ReachTo (System.Drawing.PointF position, SKNode rootNode, float velocity);
    public static SKAction ReachToNode (SKNode node, SKNode rootNode, float velocity);
    public static SKAction ReachToNode (SKNode node, SKNode rootNode, double sec);
    public static SKAction Run (System.Action block, MonoTouch.CoreFoundation.DispatchQueue queue);
    public static SKAction Run (System.Action block);
    public virtual void SetTimingFunction (SKActionTimingFunction timingFunction);
    public static SKAction StrengthBy (float strength, double sec);
    public static SKAction StrengthTo (float strength, double sec);
    public static SKAction Unhide ();

Obsoleted methods:

[Obsolete ("Use Run(Action) instead")]
    public static SKAction RunBlock (System.Action block);

    [Obsolete ("Use Run(Action,DispatchQueue) instead")]
    public static SKAction RunBlock (System.Action block, MonoTouch.CoreFoundation.DispatchQueue queue);

Type Changed: MonoTouch.SpriteKit.SKCropNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Type Changed: MonoTouch.SpriteKit.SKEffectNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Added property:

public virtual SKShader Shader { get; set; }

Type Changed: MonoTouch.SpriteKit.SKEmitterNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

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 interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Added method:

public static SKLabelNode FromText (string text);

Type Changed: MonoTouch.SpriteKit.SKNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Added properties:

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

Added methods:

public void Add (SKNode node);
    public void AddNodes (SKNode[] nodes);
    public static T FromFile<T> (string file);
    public virtual System.Collections.Generic.IEnumerator<SKNode> GetEnumerator ();
    public virtual SKNode GetObjectsMatching (string nameExpression);

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 method:

public virtual OpenTK.Vector3 SampleFields (OpenTK.Vector3 position);

Type Changed: MonoTouch.SpriteKit.SKScene

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Added properties:

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

Added methods:

public virtual void DidApplyConstraints ();
    public virtual void DidFinishUpdate ();

Type Changed: MonoTouch.SpriteKit.SKShapeNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Added properties:

public virtual SKShader FillShader { get; set; }
    public virtual SKTexture FillTexture { get; set; }
    public virtual MonoTouch.CoreGraphics.CGLineCap LineCap { get; set; }
    public virtual MonoTouch.CoreGraphics.CGLineJoin LineJoin { get; set; }
    public virtual float LineLength { get; }
    public virtual float MiterLimit { 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 interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

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.SKVideoNode

Added interfaces:

System.Collections.IEnumerable
    System.Collections.Generic.IEnumerable<SKNode>

Type Changed: MonoTouch.SpriteKit.SKView

Added interfaces:

MonoTouch.UIKit.IUICoordinateSpace
    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 methods:

public static SKView.SKViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static SKView.SKViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);
    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, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable<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.SKActionTimingFunction

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

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.Vector4 position, OpenTK.Vector4 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.Vector4 position, OpenTK.Vector4 velocity, float mass, float charge, double time);
}

New Type MonoTouch.SpriteKit.SKFieldNode

public class SKFieldNode : MonoTouch.SpriteKit.SKNode, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable<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.Vector4 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 CreateElectricField ();
    public static SKFieldNode CreateLinearGravityField (OpenTK.Vector4 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.Vector4 direction);
    public static SKFieldNode CreateVelocityField (SKTexture velocityTexture);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.SpriteKit.SKLightNode

public class SKLightNode : MonoTouch.SpriteKit.SKNode, System.Collections.IEnumerable, System.Collections.Generic.IEnumerable<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);
    public SKMutableTexture (System.Drawing.SizeF size, MonoTouch.CoreVideo.CVPixelFormatType pixelFormat);
    // 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 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.Matrix2 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.Matrix2 FloatMatrix2Value { get; set; }
    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.ISKProductsRequestDelegate

Added interface:

ISKRequestDelegate

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.IUICollectionViewDelegateFlowLayout

Added interfaces:

IUICollectionViewDelegate
    IUIScrollViewDelegate

Type Changed: MonoTouch.UIKit.IUIImagePickerControllerDelegate

Added interface:

IUINavigationControllerDelegate

Type Changed: MonoTouch.UIKit.IUINavigationBarDelegate

Added interface:

IUIBarPositioningDelegate

Type Changed: MonoTouch.UIKit.IUISearchBarDelegate

Added interface:

IUIBarPositioningDelegate

Type Changed: MonoTouch.UIKit.IUITableViewDelegate

Added interface:

IUIScrollViewDelegate

Type Changed: MonoTouch.UIKit.IUITextInputTraits

Added interfaces:

MonoTouch.ObjCRuntime.INativeObject
    System.IDisposable

Added property:

public virtual UITextSpellCheckingType SpellCheckingType { get; set; }

Type Changed: MonoTouch.UIKit.IUITextViewDelegate

Added interface:

IUIScrollViewDelegate

Type Changed: MonoTouch.UIKit.IUIToolbarDelegate

Added interface:

IUIBarPositioningDelegate

Type Changed: MonoTouch.UIKit.IUIVideoEditorControllerDelegate

Added interface:

IUINavigationControllerDelegate

Type Changed: MonoTouch.UIKit.NSLayoutAttribute

Added values:

BottomMargin = 16,
    CenterXWithinMargins = 19,
    CenterYWithinMargins = 20,
    FirstBaseline = 12,
    LastBaseline = 11,
    LeadingMargin = 17,
    LeftMargin = 13,
    RightMargin = 14,
    TopMargin = 15,
    TrailingMargin = 18,

Type Changed: MonoTouch.UIKit.NSLayoutConstraint

Added property:

public virtual bool Active { get; set; }

Added methods:

public static void ActivateConstraints (NSLayoutConstraint[] constraints);
    public static void DeactivateConstraints (NSLayoutConstraint[] constraints);
    public static NSLayoutConstraint[] FromVisualFormat (string format, NSLayoutFormatOptions formatOptions, object[] viewsAndMetrics);

Type Changed: MonoTouch.UIKit.NSLayoutFormatOptions

Added values:

AlignAllFirstBaseline = 4096,
    AlignAllLastBaseline = 2048,

Type Changed: MonoTouch.UIKit.NSTextStorage

Added interface:

MonoTouch.Foundation.INSSecureCoding

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 IsSpeakScreenEnabled { get; }
    public static bool IsSpeakSelectionEnabled { get; }
    public static bool IsSwitchControlRunning { get; }

Type Changed: MonoTouch.UIKit.UIActionSheet

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIActionSheet.UIActionSheetAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIActionSheet.UIActionSheetAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIActivityIndicatorView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIActivityIndicatorView.UIActivityIndicatorViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIActivityIndicatorView.UIActivityIndicatorViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIActivityViewController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Added method:

public virtual void SetCompletionHandler (UIActivityViewControllerCompletion completionHandler);

Type Changed: MonoTouch.UIKit.UIAlertView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIAlertView.UIAlertViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIAlertView.UIAlertViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIAppearance

Added methods:

public static System.IntPtr GetAppearance (System.IntPtr class_ptr, UITraitCollection traits, System.Type[] whenFoundIn);
    public static System.IntPtr GetAppearance (System.IntPtr class_ptr, UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UIApplication

Added properties:

public virtual UIUserNotificationSettings CurrentUserNotificationSettings { get; }
    public virtual bool IsRegisteredForRemoteNotifications { get; }
    public static MonoTouch.Foundation.NSString LaunchOptionsUserActivityDictionaryKey { get; }
    public static MonoTouch.Foundation.NSString LaunchOptionsUserActivityTypeKey { 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 ShouldAllowExtensionPointIdentifier (UIApplication application, MonoTouch.Foundation.NSString extensionPointIdentifier);
    public virtual void UserActivityUpdated (MonoTouch.Foundation.NSUserActivity userActivity);
    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, MonoTouch.Foundation.NSDictionary remoteNotificationInfo, System.Action completionHandler);
    public static void HandleAction (IUIApplicationDelegate This, UIApplication application, string actionIdentifier, UILocalNotification localNotification, System.Action completionHandler);
    public static bool ShouldAllowExtensionPointIdentifier (IUIApplicationDelegate This, UIApplication application, MonoTouch.Foundation.NSString extensionPointIdentifier);
    public static void UserActivityUpdated (IUIApplicationDelegate This, MonoTouch.Foundation.NSUserActivity userActivity);
    public static bool WillContinueUserActivity (IUIApplicationDelegate This, UIApplication application, string userActivityType);

Type Changed: MonoTouch.UIKit.UIBarButtonItem

Added methods:

public static UIBarButtonItem.UIBarButtonItemAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UIBarButtonItem.UIBarButtonItemAppearance GetAppearance<T> (UITraitCollection traits);

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 properties:

public virtual UIAccessibilityNavigationStyle AccessibilityNavigationStyle { get; set; }
    public static MonoTouch.Foundation.NSString BoldTextStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString NotificationSwitchControlIdentifier { get; }
    public static int PauseAssistiveTechnologyNotification { get; }
    public static MonoTouch.Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
    public static int ResumeAssistiveTechnologyNotification { get; }
    public static MonoTouch.Foundation.NSString SpeakScreenStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString SpeakSelectionStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString SwitchControlStatusDidChangeNotification { get; }

Added methods:

public static UIBarItem.UIBarItemAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIBarItem.UIBarItemAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIBarItem.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 ObserveSpeakScreenStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
    public static MonoTouch.Foundation.NSObject ObserveSpeakSelectionStatusDidChange (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,

Obsoleted fields:

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

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

Type Changed: MonoTouch.UIKit.UIButton

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIButton.UIButtonAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UIButton.UIButtonAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UICollectionReusableView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UICollectionReusableView.UICollectionReusableViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UICollectionReusableView.UICollectionReusableViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public virtual UICollectionViewLayoutAttributes PreferredLayoutAttributesFittingAttributes (UICollectionViewLayoutAttributes layoutAttributes);

Type Changed: MonoTouch.UIKit.UICollectionView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UICollectionView.UICollectionViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UICollectionView.UICollectionViewAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UICollectionViewCell

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UICollectionViewCell.UICollectionViewCellAppearance GetAppearance<T> (UITraitCollection traits);
    public static UICollectionViewCell.UICollectionViewCellAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

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.UIColor

Added property:

public virtual MonoTouch.CoreImage.CIColor CIColor { get; }

Added method:

protected override void Dispose (bool disposing);

Type Changed: MonoTouch.UIKit.UIControl

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIControl.UIControlAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIControl.UIControlAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIDatePicker

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIDatePicker.UIDatePickerAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIDatePicker.UIDatePickerAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIDocument

Added interface:

MonoTouch.Foundation.INSFilePresenter

Added properties:

public virtual MonoTouch.Foundation.NSOperationQueue PesentedItemOperationQueue { get; }
    public virtual MonoTouch.Foundation.NSUrl PresentedItemURL { get; }
    public virtual MonoTouch.Foundation.NSUserActivity UserActivity { get; set; }

Added methods:

public virtual void AccommodatePresentedItemDeletion (System.Action<MonoTouch.Foundation.NSError> completionHandler);
    public virtual void AccommodatePresentedSubitemDeletion (MonoTouch.Foundation.NSUrl url, System.Action<MonoTouch.Foundation.NSError> completionHandler);
    public virtual void PresentedItemChanged ();
    public virtual void PresentedItemGainedVersion (MonoTouch.Foundation.NSFileVersion version);
    public virtual void PresentedItemLostVersion (MonoTouch.Foundation.NSFileVersion version);
    public virtual void PresentedItemMoved (MonoTouch.Foundation.NSUrl newURL);
    public virtual void PresentedItemResolveConflictVersion (MonoTouch.Foundation.NSFileVersion version);
    public virtual void PresentedSubitemAppeared (MonoTouch.Foundation.NSUrl atUrl);
    public virtual void PresentedSubitemChanged (MonoTouch.Foundation.NSUrl url);
    public virtual void PresentedSubitemGainedVersion (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSFileVersion version);
    public virtual void PresentedSubitemLostVersion (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSFileVersion version);
    public virtual void PresentedSubitemMoved (MonoTouch.Foundation.NSUrl oldURL, MonoTouch.Foundation.NSUrl newURL);
    public virtual void PresentedSubitemResolvedConflictVersion (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSFileVersion version);
    public virtual void RelinquishPresentedItemToReader (NSFilePresenterReacquirer readerAction);
    public virtual void RelinquishPresentedItemToWriter (NSFilePresenterReacquirer writerAction);
    public virtual void RestoreUserActivityState (MonoTouch.Foundation.NSUserActivity userActivity);
    public virtual void SavePresentedItemChanges (System.Action<MonoTouch.Foundation.NSError> completionHandler);
    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 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 AccessibilityLabel { get; set; }
    public virtual string AccessibilityLanguage { get; set; }
    public virtual UIAccessibilityNavigationStyle AccessibilityNavigationStyle { 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 virtual UIImageAsset ImageAsset { 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 int PauseAssistiveTechnologyNotification { get; }
    public static MonoTouch.Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
    public static int ResumeAssistiveTechnologyNotification { get; }
    public static int ScreenChangedNotification { get; }
    public virtual bool ShouldGroupAccessibilityChildren { get; set; }
    public static MonoTouch.Foundation.NSString SpeakScreenStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString SpeakSelectionStatusDidChangeNotification { get; }
    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 virtual UITraitCollection TraitCollection { 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 MonoTouch.Foundation.NSString VoiceOverStatusChanged { get; }

Added methods:

public virtual bool AccessibilityActivate ();
    public static UIImage FromBundle (string name, MonoTouch.Foundation.NSBundle bundle, UITraitCollection traitCollection);

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 ObserveSpeakScreenStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
    public static MonoTouch.Foundation.NSObject ObserveSpeakSelectionStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
    public static MonoTouch.Foundation.NSObject ObserveSwitchControlStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
}

Type Changed: MonoTouch.UIKit.UIImagePickerController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIImageView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIImageView.UIImageViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIImageView.UIImageViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIInputView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIInputView.UIInputViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIInputView.UIInputViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIInterfaceOrientation

Added value:

Unknown = 0,

Type Changed: MonoTouch.UIKit.UILabel

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UILabel.UILabelAppearance GetAppearance<T> (UITraitCollection traits);
    public static UILabel.UILabelAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

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.UIManagedDocument

Added interface:

MonoTouch.Foundation.INSFilePresenter

Type Changed: MonoTouch.UIKit.UIModalPresentationStyle

Added values:

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

Type Changed: MonoTouch.UIKit.UINavigationBar

Added interfaces:

IUIBarPositioning
    IUICoordinateSpace
    IUITraitEnvironment

Added properties:

public virtual UIBarPosition BarPosition { get; }
    public UIStringAttributes TitleTextAttributes { get; set; }

Added methods:

public static UINavigationBar.UINavigationBarAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UINavigationBar.UINavigationBarAppearance GetAppearance<T> (UITraitCollection traits);

Obsoleted methods:

[Obsolete ("Use TitleTextAttributes property with UIStringAttributes")]
    public UITextAttributes GetTitleTextAttributes ();

    [Obsolete ("Use TitleTextAttributes with UIStringAttributes")]
    public void SetTitleTextAttributes (UITextAttributes attributes);

Type Changed: MonoTouch.UIKit.UINavigationBar.UINavigationBarAppearance

Added property:

public UIStringAttributes TitleTextAttributes { get; set; }

Type Changed: MonoTouch.UIKit.UINavigationController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Added properties:

public virtual UIPanGestureRecognizer BarHideOnSwipeGestureRecognizer { get; }
    public virtual UITapGestureRecognizer BarHideOnTapGestureRecognizer { get; }
    public virtual bool HidesBarsOnSwipe { get; set; }
    public virtual bool HidesBarsOnTap { get; set; }
    public virtual bool HidesBarsWhenKeyboardAppears { get; set; }
    public virtual bool HidesBarsWhenVerticallyCompact { get; set; }

Added method:

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

Type Changed: MonoTouch.UIKit.UIPageControl

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIPageControl.UIPageControlAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIPageControl.UIPageControlAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIPageViewController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIPickerView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIPickerView.UIPickerViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UIPickerView.UIPickerViewAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UIPopoverBackgroundView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIPopoverBackgroundView.UIPopoverBackgroundViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIPopoverBackgroundView.UIPopoverBackgroundViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

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 interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIProgressView.UIProgressViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIProgressView.UIProgressViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIReferenceLibraryViewController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UIRefreshControl

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIRefreshControl.UIRefreshControlAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIRefreshControl.UIRefreshControlAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIResponder

Added properties:

public virtual UIAccessibilityCustomAction[] AccessibilityCustomActions { get; set; }
    public virtual UIInputViewController InputAccessoryViewController { get; }
    public virtual UIInputViewController InputViewController { get; }
    public virtual MonoTouch.Foundation.NSUserActivity UserActivity { get; set; }

Added methods:

public virtual void AccessibilityElementDidBecomeFocused ();
    public virtual void AccessibilityElementDidLoseFocus ();
    public virtual bool AccessibilityElementIsFocused ();
    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 IUICoordinateSpace CoordinateSpace { get; }
    public virtual IUICoordinateSpace FixedCoordinateSpace { get; }
    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 interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIScrollView.UIScrollViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIScrollView.UIScrollViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UISearchBar

Added interfaces:

IUIBarPositioning
    IUITextInputTraits
    IUICoordinateSpace
    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; }

Added methods:

public static UISearchBar.UISearchBarAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UISearchBar.UISearchBarAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UISegmentedControl

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UISegmentedControl.UISegmentedControlAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UISegmentedControl.UISegmentedControlAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UISlider

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UISlider.UISliderAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UISlider.UISliderAppearance GetAppearance<T> (UITraitCollection traits);

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> SupportedInterfaceOrientations { 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> GetPreferredInterfaceOrientationForPresentation { 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 SupportedInterfaceOrientations (UISplitViewController splitViewController);
    public virtual UISplitViewControllerDisplayMode GetTargetDisplayModeForAction (UISplitViewController svc);
    public virtual UIInterfaceOrientation GetPreferredInterfaceOrientationForPresentation (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 SupportedInterfaceOrientations (IUISplitViewControllerDelegate This, UISplitViewController splitViewController);
    public static UISplitViewControllerDisplayMode GetTargetDisplayModeForAction (IUISplitViewControllerDelegate This, UISplitViewController svc);
    public static UIInterfaceOrientation GetPreferredInterfaceOrientationForPresentation (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 interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIStepper.UIStepperAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIStepper.UIStepperAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UISwitch

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UISwitch.UISwitchAppearance GetAppearance<T> (UITraitCollection traits);
    public static UISwitch.UISwitchAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITabBar

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UITabBar.UITabBarAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITabBar.UITabBarAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITabBarController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Type Changed: MonoTouch.UIKit.UITabBarItem

Added methods:

public static UITabBarItem.UITabBarItemAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITabBarItem.UITabBarItemAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITableView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added property:

public virtual UIVisualEffect SeparatorEffect { get; set; }

Added methods:

public static UITableView.UITableViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITableView.UITableViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITableView.UITableViewAppearance

Added properties:

public virtual UIColor SeparatorColor { get; set; }
    public virtual UIVisualEffect SeparatorEffect { get; set; }

Type Changed: MonoTouch.UIKit.UITableViewCell

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UITableViewCell.UITableViewCellAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITableViewCell.UITableViewCellAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITableViewController

Added interfaces:

IUIContentContainer
    IUITraitEnvironment

Added method:

public virtual UITableViewRowAction[] EditActionsForRow (UITableView tableView, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UITableViewDelegate

Added method:

public virtual UITableViewRowAction[] EditActionsForRow (UITableView tableView, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UITableViewDelegate_Extensions

Added method:

public static UITableViewRowAction[] EditActionsForRow (IUITableViewDelegate This, UITableView tableView, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UITableViewHeaderFooterView

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UITableViewHeaderFooterView.UITableViewHeaderFooterViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITableViewHeaderFooterView.UITableViewHeaderFooterViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITableViewSource

Added method:

public virtual UITableViewRowAction[] EditActionsForRow (UITableView tableView, MonoTouch.Foundation.NSIndexPath indexPath);

Type Changed: MonoTouch.UIKit.UITextField

Added interfaces:

IUIKeyInput
    IUITextInput
    IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UITextField.UITextFieldAppearance GetAppearance<T> (UITraitCollection traits);
    public static UITextField.UITextFieldAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UITextRange

Added properties:

public UITextPosition End { get; }
    public UITextPosition Start { get; }

Obsoleted properties:

[Obsolete ("Use End instead")]
    public virtual UITextPosition end { get; }

    [Obsolete ("Use Start instead")]
    public virtual UITextPosition start { get; }

Type Changed: MonoTouch.UIKit.UITextView

Added interfaces:

IUIKeyInput
    IUITextInput
    IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UITextView.UITextViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public static UITextView.UITextViewAppearance GetAppearance<T> (UITraitCollection traits);

Type Changed: MonoTouch.UIKit.UIToolbar

Added interfaces:

IUIBarPositioning
    IUICoordinateSpace
    IUITraitEnvironment

Added property:

public virtual UIBarPosition BarPosition { get; }

Added methods:

public static UIToolbar.UIToolbarAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIToolbar.UIToolbarAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

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 interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added properties:

public virtual UIAccessibilityNavigationStyle AccessibilityNavigationStyle { get; set; }
    public static MonoTouch.Foundation.NSString BoldTextStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString DarkerSystemColorsStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString GrayscaleStatusDidChangeNotification { get; }
    public virtual UIEdgeInsets LayoutMargins { get; set; }
    public virtual UIView MaskView { get; set; }
    public static MonoTouch.Foundation.NSString NotificationSwitchControlIdentifier { get; }
    public static int PauseAssistiveTechnologyNotification { get; }
    public virtual bool PreservesSuperviewLayoutMargins { get; set; }
    public static MonoTouch.Foundation.NSString ReduceMotionStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString ReduceTransparencyStatusDidChangeNotification { get; }
    public static int ResumeAssistiveTechnologyNotification { get; }
    public static MonoTouch.Foundation.NSString SpeakScreenStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString SpeakSelectionStatusDidChangeNotification { get; }
    public static MonoTouch.Foundation.NSString SwitchControlStatusDidChangeNotification { get; }
    public virtual UITraitCollection TraitCollection { get; }

Added methods:

public virtual System.Drawing.PointF ConvertPointFromCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.PointF ConvertPointToCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectFromCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectToCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
    public static UIView.UIViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIView.UIViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);
    public virtual void LayoutMarginsDidChange ();
    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 ObserveSpeakScreenStatusDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
    public static MonoTouch.Foundation.NSObject ObserveSpeakSelectionStatusDidChange (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 UIPopoverPresentationController PopoverPresentationController { get; }
    public virtual UIPresentationController PresentationController { 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 property:

public virtual MonoTouch.CoreGraphics.CGAffineTransform TargetTransform { get; }

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 methods:

public static UIView GetTransitionViewController (IUIViewControllerTransitionCoordinatorContext This, UITransitionViewControllerKind kind);
    public static UIView GetTransitionViewControllerForKey (IUIViewControllerTransitionCoordinatorContext This, MonoTouch.Foundation.NSString key);
    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 interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIWebView.UIWebViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIWebView.UIWebViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

Type Changed: MonoTouch.UIKit.UIWindow

Added interfaces:

IUICoordinateSpace
    IUITraitEnvironment

Added methods:

public static UIWindow.UIWindowAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIWindow.UIWindowAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

New Type MonoTouch.UIKit.IUIAccessibilityContainer

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

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.IUICoordinateSpace

public interface IUICoordinateSpace : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual System.Drawing.RectangleF Bounds { get; }
    // methods
    public virtual System.Drawing.PointF ConvertPointFromCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.PointF ConvertPointToCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectFromCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectToCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
}

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.IUIKeyInput

public interface IUIKeyInput : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IUITextInputTraits {
    // properties
    public virtual bool HasText { get; }
    // methods
    public virtual void DeleteBackward ();
    public virtual void InsertText (string text);
}

New Type MonoTouch.UIKit.IUIPickerViewAccessibilityDelegate

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

New Type MonoTouch.UIKit.IUIPopoverPresentationControllerDelegate

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

New Type MonoTouch.UIKit.IUIPrinterPickerControllerDelegate

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

New Type MonoTouch.UIKit.IUIScrollViewAccessibilityDelegate

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

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, IUIKeyInput, IUITextInputTraits {
    // properties
    public virtual string DocumentContextAfterInput { get; }
    public virtual string DocumentContextBeforeInput { get; }
    // methods
    public virtual void AdjustTextPositionByCharacterOffset (int offset);
}

New Type MonoTouch.UIKit.IUITextInput

public interface IUITextInput : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IUIKeyInput, IUITextInputTraits {
    // properties
    public virtual UITextPosition BeginningOfDocument { get; }
    public virtual UITextPosition EndOfDocument { get; }
    public virtual UITextRange MarkedTextRange { get; }
    public virtual MonoTouch.Foundation.NSDictionary MarkedTextStyle { get; set; }
    public virtual UITextRange SelectedTextRange { get; set; }
    public virtual MonoTouch.Foundation.NSObject WeakInputDelegate { get; set; }
    public virtual MonoTouch.Foundation.NSObject WeakTokenizer { get; }
    // methods
    public virtual MonoTouch.Foundation.NSComparisonResult ComparePosition (UITextPosition first, UITextPosition second);
    public virtual UITextWritingDirection GetBaseWritingDirection (UITextPosition forPosition, UITextStorageDirection direction);
    public virtual System.Drawing.RectangleF GetCaretRectForPosition (UITextPosition position);
    public virtual UITextRange GetCharacterRange (UITextPosition byExtendingPosition, UITextLayoutDirection direction);
    public virtual UITextRange GetCharacterRangeAtPoint (System.Drawing.PointF point);
    public virtual UITextPosition GetClosestPositionToPoint (System.Drawing.PointF point);
    public virtual UITextPosition GetClosestPositionToPoint (System.Drawing.PointF point, UITextRange withinRange);
    public virtual System.Drawing.RectangleF GetFirstRectForRange (UITextRange range);
    public virtual int GetOffsetFromPosition (UITextPosition fromPosition, UITextPosition toPosition);
    public virtual UITextPosition GetPosition (UITextPosition fromPosition, UITextLayoutDirection inDirection, int offset);
    public virtual UITextPosition GetPosition (UITextPosition fromPosition, int offset);
    public virtual UITextPosition GetPositionWithinRange (UITextRange range, UITextLayoutDirection direction);
    public virtual UITextSelectionRect[] GetSelectionRects (UITextRange range);
    public virtual UITextRange GetTextRange (UITextPosition fromPosition, UITextPosition toPosition);
    public virtual void ReplaceText (UITextRange range, string text);
    public virtual void SetBaseWritingDirectionforRange (UITextWritingDirection writingDirection, UITextRange range);
    public virtual void SetMarkedText (string markedText, MonoTouch.Foundation.NSRange selectedRange);
    public virtual string TextInRange (UITextRange range);
    public virtual void UnmarkText ();
}

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.NSFilePresenterReacquirer

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

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.UIAccessibilityContainer_Extensions

public static class UIAccessibilityContainer_Extensions {
    // methods
    public static int AccessibilityElementCount (IUIAccessibilityContainer This);
    public static MonoTouch.Foundation.NSObject GetAccessibilityElementAt (IUIAccessibilityContainer This, int index);
    public static MonoTouch.Foundation.NSObject GetAccessibilityElements (IUIAccessibilityContainer This);
    public static int GetIndexOfAccessibilityElement (IUIAccessibilityContainer This, MonoTouch.Foundation.NSObject element);
    public static void SetAccessibilityElements (IUIAccessibilityContainer This, MonoTouch.Foundation.NSObject elements);
}

New Type MonoTouch.UIKit.UIAccessibilityCustomAction

public class UIAccessibilityCustomAction : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public UIAccessibilityCustomAction (string name, System.Func<UIAccessibilityCustomAction,System.Boolean> probe);
    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.UIAccessibilityElement

public class UIAccessibilityElement : MonoTouch.Foundation.NSObject, IUIAccessibilityIdentification, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public UIAccessibilityElement ();
    public UIAccessibilityElement (MonoTouch.Foundation.NSCoder coder);
    public UIAccessibilityElement (MonoTouch.Foundation.NSObjectFlag t);
    public UIAccessibilityElement (System.IntPtr handle);
    public UIAccessibilityElement (MonoTouch.Foundation.NSObject container);
    // properties
    public virtual MonoTouch.Foundation.NSObject AccessibilityContainer { 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 ulong AccessibilityTraits { get; set; }
    public virtual string AccessibilityValue { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual bool IsAccessibilityElement { 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.NSExtensionItem[] returnedItems, 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.NSExtensionItem[] returnedItems, 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);
}

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.UICoordinateSpace

public abstract class UICoordinateSpace : MonoTouch.Foundation.NSObject, IUICoordinateSpace, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public UICoordinateSpace ();
    public UICoordinateSpace (MonoTouch.Foundation.NSCoder coder);
    public UICoordinateSpace (MonoTouch.Foundation.NSObjectFlag t);
    public UICoordinateSpace (System.IntPtr handle);
    // properties
    public virtual System.Drawing.RectangleF Bounds { get; }
    // methods
    public virtual System.Drawing.PointF ConvertPointFromCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.PointF ConvertPointToCoordinateSpace (System.Drawing.PointF point, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectFromCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
    public virtual System.Drawing.RectangleF ConvertRectToCoordinateSpace (System.Drawing.RectangleF rect, IUICoordinateSpace coordinateSpace);
}

New Type MonoTouch.UIKit.UICoordinateSpace_Extensions

public static class UICoordinateSpace_Extensions {
}

New Type MonoTouch.UIKit.UIDeviceOrientationExtensions

public static class UIDeviceOrientationExtensions {
    // methods
    public static bool IsFlat (UIDeviceOrientation orientation);
    public static bool IsLandscape (UIDeviceOrientation orientation);
    public static bool IsPortrait (UIDeviceOrientation orientation);
}

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.UIExtensionPointIdentifier

public static class UIExtensionPointIdentifier {
    // properties
    public static MonoTouch.Foundation.NSString Keyboard { get; }
}

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);
    public UIInputViewController (string nibName, MonoTouch.Foundation.NSBundle bundle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual UIInputView InputView { get; set; }
    public virtual string PrimaryLanguage { 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.UIKeyInput_Extensions

public static class UIKeyInput_Extensions {
}

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.UIPickerViewAccessibilityDelegate

public class UIPickerViewAccessibilityDelegate : MonoTouch.UIKit.UIPickerViewDelegate, IUIPickerViewAccessibilityDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IUIPickerViewDelegate {
    // constructors
    public UIPickerViewAccessibilityDelegate ();
    public UIPickerViewAccessibilityDelegate (MonoTouch.Foundation.NSCoder coder);
    public UIPickerViewAccessibilityDelegate (MonoTouch.Foundation.NSObjectFlag t);
    public UIPickerViewAccessibilityDelegate (System.IntPtr handle);
    // methods
    public virtual string GetAccessibilityHint (UIPickerView pickerView, int component);
    public virtual string GetAccessibilityLabel (UIPickerView pickerView, int acessibilityLabelForComponent);
    public override MonoTouch.Foundation.NSAttributedString GetAttributedTitle (UIPickerView pickerView, int row, int component);
    public override float GetComponentWidth (UIPickerView pickerView, int component);
    public override float GetRowHeight (UIPickerView pickerView, int component);
    public override string GetTitle (UIPickerView pickerView, int row, int component);
    public override UIView GetView (UIPickerView pickerView, int row, int component, UIView view);
    public override void Selected (UIPickerView pickerView, int row, int component);
}

New Type MonoTouch.UIKit.UIPickerViewAccessibilityDelegate_Extensions

public static class UIPickerViewAccessibilityDelegate_Extensions {
    // methods
    public static string GetAccessibilityHint (IUIPickerViewAccessibilityDelegate This, UIPickerView pickerView, int component);
    public static string GetAccessibilityLabel (IUIPickerViewAccessibilityDelegate This, UIPickerView pickerView, int acessibilityLabelForComponent);
}

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 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 presentedViewController, UIViewController presentingViewController);
    // 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.UIScrollViewAccessibilityDelegate

public class UIScrollViewAccessibilityDelegate : MonoTouch.UIKit.UIScrollViewDelegate, IUIScrollViewAccessibilityDelegate, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IUIScrollViewDelegate {
    // constructors
    public UIScrollViewAccessibilityDelegate ();
    public UIScrollViewAccessibilityDelegate (MonoTouch.Foundation.NSCoder coder);
    public UIScrollViewAccessibilityDelegate (MonoTouch.Foundation.NSObjectFlag t);
    public UIScrollViewAccessibilityDelegate (System.IntPtr handle);
    // methods
    public override void DecelerationEnded (UIScrollView scrollView);
    public override void DecelerationStarted (UIScrollView scrollView);
    public override void DidZoom (UIScrollView scrollView);
    public override void DraggingEnded (UIScrollView scrollView, bool willDecelerate);
    public override void DraggingStarted (UIScrollView scrollView);
    public virtual string GetAccessibilityScrollStatus (UIScrollView scrollView);
    public override void ScrollAnimationEnded (UIScrollView scrollView);
    public override void Scrolled (UIScrollView scrollView);
    public override void ScrolledToTop (UIScrollView scrollView);
    public override bool ShouldScrollToTop (UIScrollView scrollView);
    public override UIView ViewForZoomingInScrollView (UIScrollView scrollView);
    public override void WillEndDragging (UIScrollView scrollView, System.Drawing.PointF velocity, ref System.Drawing.PointF targetContentOffset);
    public override void ZoomingEnded (UIScrollView scrollView, UIView withView, float atScale);
    public override void ZoomingStarted (UIScrollView scrollView, UIView view);
}

New Type MonoTouch.UIKit.UIScrollViewAccessibilityDelegate_Extensions

public static class UIScrollViewAccessibilityDelegate_Extensions {
    // methods
    public static string GetAccessibilityScrollStatus (IUIScrollViewAccessibilityDelegate This, UIScrollView scrollView);
}

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 UISearchResultsUpdating SearchResultsUpdater { get; set; }
    public virtual MonoTouch.Foundation.NSObject WeakDelegate { get; set; }
    public virtual MonoTouch.Foundation.NSObject WeakSearchResultsUpdater { 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 void SetSearchResultsUpdater (System.Action<UISearchController> updateSearchResults);
    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.UITableViewRowAction

public class UITableViewRowAction : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public UITableViewRowAction ();
    public UITableViewRowAction (MonoTouch.Foundation.NSCoder coder);
    public UITableViewRowAction (MonoTouch.Foundation.NSObjectFlag t);
    public UITableViewRowAction (System.IntPtr handle);
    // properties
    public virtual UIColor BackgroundColor { get; set; }
    public virtual UIVisualEffect BackgroundEffect { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual UITableViewRowActionStyle Style { get; }
    public virtual string Title { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    public static UITableViewRowAction Create (UITableViewRowActionStyle style, string title, System.Action<UITableViewRowAction,MonoTouch.Foundation.NSIndexPath> handler);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.UIKit.UITableViewRowActionStyle

[Serializable]
public enum UITableViewRowActionStyle {
    Default = 0,
    Destructive = 0,
    Normal = 1,
}

New Type MonoTouch.UIKit.UITextDocumentProxy

public abstract class UITextDocumentProxy : MonoTouch.Foundation.NSObject, IUITextDocumentProxy, IUIKeyInput, IUITextInputTraits, 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 AdjustTextPositionByCharacterOffset (int offset);
    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.UITextInput_Extensions

public static class UITextInput_Extensions {
    // methods
    public static void DictationRecognitionFailed (IUITextInput This);
    public static void DictationRecordingDidEnd (IUITextInput This);
    public static int GetCharacterOffsetOfPosition (IUITextInput This, UITextPosition position, UITextRange range);
    public static System.Drawing.RectangleF GetFrameForDictationResultPlaceholder (IUITextInput This, MonoTouch.Foundation.NSObject placeholder);
    public static UITextPosition GetPosition (IUITextInput This, UITextRange withinRange, int atCharacterOffset);
    public static MonoTouch.Foundation.NSDictionary GetTextStyling (IUITextInput This, UITextPosition atPosition, UITextStorageDirection inDirection);
    public static void InsertDictationResult (IUITextInput This, MonoTouch.Foundation.NSArray dictationResult);
    public static MonoTouch.Foundation.NSObject InsertDictationResultPlaceholder (IUITextInput This);
    public static void RemoveDictationResultPlaceholder (IUITextInput This, MonoTouch.Foundation.NSObject placeholder, bool willInsertResult);
    public static bool ShouldChangeTextInRange (IUITextInput This, UITextRange inRange, string replacementText);
}

New Type MonoTouch.UIKit.UITextInputTraits_Extensions

public static class UITextInputTraits_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 (UITraitCollection[] 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.UITransitionViewControllerKind

[Serializable]
public enum UITransitionViewControllerKind {
    FromView = 1,
    ToView = 0,
}

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, IUICoordinateSpace, 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> ();
    public static UIVisualEffectView.UIVisualEffectViewAppearance GetAppearance<T> (UITraitCollection traits);
    public static UIVisualEffectView.UIVisualEffectViewAppearance GetAppearance<T> (UITraitCollection traits, System.Type[] containers);

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

New Namespace MonoTouch.AVKit

New Type MonoTouch.AVKit.AVPlayerViewController

public class AVPlayerViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIContentContainer, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public AVPlayerViewController ();
    public AVPlayerViewController (MonoTouch.Foundation.NSCoder coder);
    public AVPlayerViewController (MonoTouch.Foundation.NSObjectFlag t);
    public AVPlayerViewController (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.UIKit.UIView ContentOverlayView { get; }
    public virtual MonoTouch.AVFoundation.AVPlayer Player { get; set; }
    public virtual bool ReadyForDisplay { get; }
    public virtual bool ShowsPlaybackControls { get; set; }
    public virtual System.Drawing.RectangleF VideoBounds { get; }
    public MonoTouch.AVFoundation.AVLayerVideoGravity VideoGravity { get; set; }
    public virtual MonoTouch.Foundation.NSString WeakVideoGravity { get; set; }
    // methods
    protected override void Dispose (bool disposing);
}

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]
[Flags]
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<CKSubscription[],MonoTouch.Foundation.NSError> completionHandler);
    public virtual System.Threading.Tasks.Task<CKSubscription[]> 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<CKRecord[],MonoTouch.Foundation.NSError> completionHandler);
    public virtual System.Threading.Tasks.Task<CKRecord[]> 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 (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; set; }
}

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,
    LimitExceeded = 27,
    MissingEntitlement = 8,
    NetworkFailure = 4,
    NetworkUnavailable = 3,
    None = 0,
    NotAuthenticated = 9,
    OperationCancelled = 20,
    PartialFailure = 2,
    PermissionFailure = 10,
    QuotaExceeded = 25,
    RequestRateLimited = 7,
    ResultsTruncated = 13,
    ServerRecordChanged = 14,
    ServerRejectedRequest = 15,
    ServiceUnavailable = 6,
    UnknownItem = 11,
    UserDeletedZone = 28,
    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 bool MoreComing { get; }
    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; }
}

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 virtual bool Atomic { get; set; }
    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 bool ShouldSendContentAvailable { 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,
}

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.CoreAudioKit

New Type MonoTouch.CoreAudioKit.CABTMidiCentralViewController

public class CABTMidiCentralViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIContentContainer, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CABTMidiCentralViewController ();
    public CABTMidiCentralViewController (MonoTouch.Foundation.NSCoder coder);
    public CABTMidiCentralViewController (MonoTouch.Foundation.NSObjectFlag t);
    public CABTMidiCentralViewController (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.CoreAudioKit.CABTMidiLocalPeripheralViewController

public class CABTMidiLocalPeripheralViewController : MonoTouch.UIKit.UIViewController, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIContentContainer, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CABTMidiLocalPeripheralViewController ();
    public CABTMidiLocalPeripheralViewController (MonoTouch.Foundation.NSCoder coder);
    public CABTMidiLocalPeripheralViewController (MonoTouch.Foundation.NSObjectFlag t);
    public CABTMidiLocalPeripheralViewController (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.CoreAudioKit.CAInterAppAudioSwitcherView

public class CAInterAppAudioSwitcherView : MonoTouch.UIKit.UIView, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIAccessibilityIdentification, MonoTouch.UIKit.IUICoordinateSpace, MonoTouch.UIKit.IUIDynamicItem, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CAInterAppAudioSwitcherView ();
    public CAInterAppAudioSwitcherView (MonoTouch.Foundation.NSCoder coder);
    public CAInterAppAudioSwitcherView (MonoTouch.Foundation.NSObjectFlag t);
    public CAInterAppAudioSwitcherView (System.IntPtr handle);
    public CAInterAppAudioSwitcherView (System.Drawing.RectangleF bounds);
    // properties
    public static CAInterAppAudioSwitcherView.CAInterAppAudioSwitcherViewAppearance Appearance { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual bool ShowingAppNames { get; set; }
    // methods
    public static CAInterAppAudioSwitcherView.CAInterAppAudioSwitcherViewAppearance AppearanceWhenContainedIn (System.Type[] containers);
    public virtual float ContentWidth ();
    public static CAInterAppAudioSwitcherView.CAInterAppAudioSwitcherViewAppearance GetAppearance<T> ();
    public static CAInterAppAudioSwitcherView.CAInterAppAudioSwitcherViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static CAInterAppAudioSwitcherView.CAInterAppAudioSwitcherViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);
    public virtual void SetOutputAudioUnit (MonoTouch.AudioUnit.AudioUnit audioUnit);

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

New Type MonoTouch.CoreAudioKit.CAInterAppAudioTransportView

public class CAInterAppAudioTransportView : MonoTouch.UIKit.UIView, System.Collections.IEnumerable, MonoTouch.Foundation.INSCoding, MonoTouch.UIKit.IUIAccessibilityIdentification, MonoTouch.UIKit.IUICoordinateSpace, MonoTouch.UIKit.IUIDynamicItem, MonoTouch.UIKit.IUITraitEnvironment, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public CAInterAppAudioTransportView ();
    public CAInterAppAudioTransportView (MonoTouch.Foundation.NSCoder coder);
    public CAInterAppAudioTransportView (MonoTouch.Foundation.NSObjectFlag t);
    public CAInterAppAudioTransportView (System.IntPtr handle);
    public CAInterAppAudioTransportView (System.Drawing.RectangleF bounds);
    // properties
    public static CAInterAppAudioTransportView.CAInterAppAudioTransportViewAppearance Appearance { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual bool Connected { get; }
    public virtual MonoTouch.UIKit.UIFont CurrentTimeLabelFont { get; set; }
    public virtual bool Enabled { get; set; }
    public virtual MonoTouch.UIKit.UIColor LabelColor { get; set; }
    public virtual MonoTouch.UIKit.UIColor PauseButtonColor { get; set; }
    public virtual MonoTouch.UIKit.UIColor PlayButtonColor { get; set; }
    public virtual bool Playing { get; }
    public virtual MonoTouch.UIKit.UIColor RecordButtonColor { get; set; }
    public virtual bool Recording { get; }
    public virtual MonoTouch.UIKit.UIColor RewindButtonColor { get; set; }
    // methods
    public static CAInterAppAudioTransportView.CAInterAppAudioTransportViewAppearance AppearanceWhenContainedIn (System.Type[] containers);
    protected override void Dispose (bool disposing);
    public static CAInterAppAudioTransportView.CAInterAppAudioTransportViewAppearance GetAppearance<T> ();
    public static CAInterAppAudioTransportView.CAInterAppAudioTransportViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits);
    public static CAInterAppAudioTransportView.CAInterAppAudioTransportViewAppearance GetAppearance<T> (MonoTouch.UIKit.UITraitCollection traits, System.Type[] containers);
    public virtual void SetOutputAudioUnit (MonoTouch.AudioUnit.AudioUnit audioUnit);

    // inner types
    public class CAInterAppAudioTransportViewAppearance : MonoTouch.UIKit.UIView+UIViewAppearance, MonoTouch.UIKit.IUIAppearance, 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, HKAnchoredObjectResultHandler completion);
    // properties
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKAnchoredObjectResultHandler

public sealed delegate HKAnchoredObjectResultHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public HKAnchoredObjectResultHandler (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 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, HKMetadata 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; }
    // methods
    public static HKCategoryType Create (HKCategoryTypeIdentifier kind);
}

New Type MonoTouch.HealthKit.HKCategoryTypeIdentifier

[Serializable]
public enum HKCategoryTypeIdentifier {
    SleepAnalysis = 0,
}

New Type MonoTouch.HealthKit.HKCategoryTypeIdentifierKey

public static class HKCategoryTypeIdentifierKey {
    // 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; }
    // methods
    public static HKCharacteristicType Create (HKCharacteristicTypeIdentifier kind);
}

New Type MonoTouch.HealthKit.HKCharacteristicTypeIdentifier

[Serializable]
public enum HKCharacteristicTypeIdentifier {
    BiologicalSex = 0,
    BloodType = 1,
    DateOfBirth = 2,
}

New Type MonoTouch.HealthKit.HKCharacteristicTypeIdentifierKey

public static class HKCharacteristicTypeIdentifierKey {
    // 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.HKSample, 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 HKCorrelationType CorrelationType { get; }
    public virtual MonoTouch.Foundation.NSSet Objects { get; }
    // methods
    public static HKCorrelation Create (HKCorrelationType correlationType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, MonoTouch.Foundation.NSSet objects, MonoTouch.Foundation.NSDictionary metadata);
    public static HKCorrelation Create (HKCorrelationType correlationType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, MonoTouch.Foundation.NSSet objects, HKMetadata metadata);
    public static HKCorrelation Create (HKCorrelationType correlationType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, MonoTouch.Foundation.NSSet objects);
    protected override void Dispose (bool disposing);
    public virtual MonoTouch.Foundation.NSSet GetObjects (HKObjectType objectType);
}

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 (HKCorrelationType correlationType, MonoTouch.Foundation.NSPredicate predicate, MonoTouch.Foundation.NSDictionary samplePredicates, HKCorrelationQueryResultHandler completion);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual HKCorrelationType CorrelationType { get; }
    public virtual MonoTouch.Foundation.NSDictionary SamplePredicates { get; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKCorrelationQueryResultHandler

public sealed delegate HKCorrelationQueryResultHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public HKCorrelationQueryResultHandler (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.HKCorrelationType

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

New Type MonoTouch.HealthKit.HKCorrelationTypeKey

public static class HKCorrelationTypeKey {
    // properties
    public static MonoTouch.Foundation.NSString IdentifierBloodPressure { get; }
    public static MonoTouch.Foundation.NSString IdentifierFood { get; }
}

New Type MonoTouch.HealthKit.HKErrorCode

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

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 void AddSamples (HKSample[] samples, HKWorkout workout, HKStoreSampleAddedCallback callback);
    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 void DisableBackgroundDelivery (HKObjectType type, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
    public virtual void EnableBackgroundDelivery (HKObjectType type, HKUpdateFrequency frequency, System.Action<System.Boolean,MonoTouch.Foundation.NSError> completion);
    public virtual void ExecuteQuery (HKQuery query);
    public virtual HKAuthorizationStatus GetAuthorizationStatus (HKObjectType type);
    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.HKMetadata

public class HKMetadata : MonoTouch.Foundation.DictionaryContainer {
    // constructors
    public HKMetadata ();
    public HKMetadata (MonoTouch.Foundation.NSDictionary dictionary);
    // properties
    public HKBodyTemperatureSensorLocation? BodyTemperatureSensorLocation { get; set; }
    public bool? CoachedWorkout { get; set; }
    public string DeviceManufacturerName { get; set; }
    public string DeviceName { get; set; }
    public string DeviceSerialNumber { get; set; }
    public string DigitalSignature { get; set; }
    public string ExternalUuid { get; set; }
    public string FoodType { get; set; }
    public bool? GroupFitness { get; set; }
    public HKHeartRateSensorLocation? HeartRateSensorLocation { get; set; }
    public bool? IndoorWorkout { get; set; }
    public MonoTouch.Foundation.NSNumber ReferenceRangeLowerLimit { get; set; }
    public MonoTouch.Foundation.NSNumber ReferenceRangeUpperLimit { get; set; }
    public MonoTouch.Foundation.NSTimeZone TimeZone { get; set; }
    public string UdiDeviceIdentifier { get; set; }
    public string UdiProductionIdentifier { get; set; }
    public bool? WasTakenInLab { get; set; }
    public bool? WasUserEntered { get; set; }
    public string WorkoutBrandName { get; set; }
}

New Type MonoTouch.HealthKit.HKMetadataKey

public static class HKMetadataKey {
    // properties
    public static MonoTouch.Foundation.NSString BodyTemperatureSensorLocation { get; }
    public static MonoTouch.Foundation.NSString CoachedWorkout { get; }
    public static MonoTouch.Foundation.NSString DeviceManufacturerName { get; }
    public static MonoTouch.Foundation.NSString DeviceName { get; }
    public static MonoTouch.Foundation.NSString DeviceSerialNumber { get; }
    public static MonoTouch.Foundation.NSString DigitalSignature { get; }
    public static MonoTouch.Foundation.NSString ExternalUuid { get; }
    public static MonoTouch.Foundation.NSString FoodType { get; }
    public static MonoTouch.Foundation.NSString GroupFitness { get; }
    public static MonoTouch.Foundation.NSString HeartRateSensorLocation { get; }
    public static MonoTouch.Foundation.NSString IndoorWorkout { get; }
    public static MonoTouch.Foundation.NSString ReferenceRangeLowerLimit { get; }
    public static MonoTouch.Foundation.NSString ReferenceRangeUpperLimit { get; }
    public static MonoTouch.Foundation.NSString TimeZone { get; }
    public static MonoTouch.Foundation.NSString UdiDeviceIdentifier { get; }
    public static MonoTouch.Foundation.NSString UdiProductionIdentifier { get; }
    public static MonoTouch.Foundation.NSString WasTakenInLab { get; }
    public static MonoTouch.Foundation.NSString WasUserEntered { get; }
    public static MonoTouch.Foundation.NSString WorkoutBrandName { 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 HKMetadata Metadata { get; }
    public virtual HKSource Source { get; }
    public virtual MonoTouch.Foundation.NSUuid Uuid { get; }
    public virtual MonoTouch.Foundation.NSDictionary WeakMetadata { 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 (MonoTouch.Foundation.NSString hkCategoryTypeIdentifier);
    public static HKCharacteristicType GetCharacteristicType (MonoTouch.Foundation.NSString hkCharacteristicTypeIdentifier);
    public static HKCorrelationType GetCorrelationType (MonoTouch.Foundation.NSString hkCorrelationTypeIdentifier);
    public static HKQuantityType GetQuantityType (MonoTouch.Foundation.NSString hkTypeIdentifier);
    public static HKWorkout WorkoutType ();
}

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 completion, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
    public virtual void EndInvoke (System.IAsyncResult result);
    public virtual void Invoke (HKObserverQuery query, HKObserverQueryCompletionHandler completion, MonoTouch.Foundation.NSError error);
}

New Type MonoTouch.HealthKit.HKPredicateKeyPath

public static class HKPredicateKeyPath {
    // properties
    public static MonoTouch.Foundation.NSString CategoryValue { get; }
    public static MonoTouch.Foundation.NSString Correlation { get; }
    public static MonoTouch.Foundation.NSString EndDate { get; }
    public static MonoTouch.Foundation.NSString Metadata { get; }
    public static MonoTouch.Foundation.NSString Quantity { get; }
    public static MonoTouch.Foundation.NSString Source { get; }
    public static MonoTouch.Foundation.NSString StartDate { get; }
    public static MonoTouch.Foundation.NSString Uuid { get; }
    public static MonoTouch.Foundation.NSString Workout { get; }
    public static MonoTouch.Foundation.NSString WorkoutDuration { get; }
    public static MonoTouch.Foundation.NSString WorkoutTotalDistance { get; }
    public static MonoTouch.Foundation.NSString WorkoutTotalEnergyBurned { get; }
    public static MonoTouch.Foundation.NSString WorkoutType { get; }
}

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 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);
    public static HKQuantitySample FromType (HKQuantityType quantityType, HKQuantity quantity, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, HKMetadata 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 static HKQuantityType Create (HKQuantityTypeIdentifier kind);
    public virtual bool IsCompatible (HKUnit unit);
}

New Type MonoTouch.HealthKit.HKQuantityTypeIdentifier

[Serializable]
public enum HKQuantityTypeIdentifier {
    ActiveEnergyBurned = 10,
    BasalEnergyBurned = 9,
    BloodAlcoholContent = 17,
    BloodGlucose = 14,
    BloodPressureDiastolic = 16,
    BloodPressureSystolic = 15,
    BodyFatPercentage = 1,
    BodyMass = 3,
    BodyMassIndex = 0,
    BodyTemperature = 25,
    DietaryBiotin = 50,
    DietaryCaffeine = 63,
    DietaryCalcium = 44,
    DietaryCarbohydrates = 32,
    DietaryChloride = 61,
    DietaryCholesterol = 30,
    DietaryChromium = 59,
    DietaryCopper = 57,
    DietaryEnergyConsumed = 35,
    DietaryFatMonounsaturated = 28,
    DietaryFatPolyunsaturated = 27,
    DietaryFatSaturated = 29,
    DietaryFatTotal = 26,
    DietaryFiber = 33,
    DietaryFolate = 49,
    DietaryIodine = 53,
    DietaryIron = 45,
    DietaryMagnesium = 54,
    DietaryManganese = 58,
    DietaryMolybdenum = 60,
    DietaryNiacin = 48,
    DietaryPantothenicAcid = 51,
    DietaryPhosphorus = 52,
    DietaryPotassium = 62,
    DietaryProtein = 36,
    DietaryRiboflavin = 47,
    DietarySelenium = 56,
    DietarySodium = 31,
    DietarySugar = 34,
    DietaryThiamin = 46,
    DietaryVitaminA = 37,
    DietaryVitaminB12 = 39,
    DietaryVitaminB6 = 38,
    DietaryVitaminC = 40,
    DietaryVitaminD = 41,
    DietaryVitaminE = 42,
    DietaryVitaminK = 43,
    DietaryZinc = 55,
    DistanceCycling = 8,
    DistanceWalkingRunning = 7,
    FlightsClimbed = 11,
    ForcedExpiratoryVolume1 = 20,
    ForcedVitalCapacity = 19,
    HeartRate = 5,
    Height = 2,
    InhalerUsage = 23,
    LeanBodyMass = 4,
    NikeFuel = 12,
    NumberOfTimesFallen = 22,
    OxygenSaturation = 13,
    PeakExpiratoryFlowRate = 21,
    PeripheralPerfusionIndex = 18,
    RespiratoryRate = 24,
    StepCount = 6,
}

New Type MonoTouch.HealthKit.HKQuantityTypeIdentifierKey

public static class HKQuantityTypeIdentifierKey {
    // properties
    public static MonoTouch.Foundation.NSString ActiveEnergyBurned { 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 DietaryBiotin { get; }
    public static MonoTouch.Foundation.NSString DietaryCaffeine { get; }
    public static MonoTouch.Foundation.NSString DietaryCalcium { get; }
    public static MonoTouch.Foundation.NSString DietaryCarbohydrates { get; }
    public static MonoTouch.Foundation.NSString DietaryChloride { get; }
    public static MonoTouch.Foundation.NSString DietaryCholesterol { get; }
    public static MonoTouch.Foundation.NSString DietaryChromium { get; }
    public static MonoTouch.Foundation.NSString DietaryCopper { get; }
    public static MonoTouch.Foundation.NSString DietaryEnergyConsumed { get; }
    public static MonoTouch.Foundation.NSString DietaryFatMonounsaturated { get; }
    public static MonoTouch.Foundation.NSString DietaryFatPolyunsaturated { get; }
    public static MonoTouch.Foundation.NSString DietaryFatSaturated { get; }
    public static MonoTouch.Foundation.NSString DietaryFatTotal { get; }
    public static MonoTouch.Foundation.NSString DietaryFiber { get; }
    public static MonoTouch.Foundation.NSString DietaryFolate { get; }
    public static MonoTouch.Foundation.NSString DietaryIodine { get; }
    public static MonoTouch.Foundation.NSString DietaryIron { get; }
    public static MonoTouch.Foundation.NSString DietaryMagnesium { get; }
    public static MonoTouch.Foundation.NSString DietaryManganese { get; }
    public static MonoTouch.Foundation.NSString DietaryMolybdenum { get; }
    public static MonoTouch.Foundation.NSString DietaryNiacin { get; }
    public static MonoTouch.Foundation.NSString DietaryPantothenicAcid { get; }
    public static MonoTouch.Foundation.NSString DietaryPhosphorus { get; }
    public static MonoTouch.Foundation.NSString DietaryPotassium { get; }
    public static MonoTouch.Foundation.NSString DietaryProtein { get; }
    public static MonoTouch.Foundation.NSString DietaryRiboflavin { get; }
    public static MonoTouch.Foundation.NSString DietarySelenium { get; }
    public static MonoTouch.Foundation.NSString DietarySodium { get; }
    public static MonoTouch.Foundation.NSString DietarySugar { get; }
    public static MonoTouch.Foundation.NSString DietaryThiamin { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminA { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminB12 { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminB6 { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminC { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminD { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminE { get; }
    public static MonoTouch.Foundation.NSString DietaryVitaminK { get; }
    public static MonoTouch.Foundation.NSString DietaryZinc { get; }
    public static MonoTouch.Foundation.NSString DistanceCycling { get; }
    public static MonoTouch.Foundation.NSString DistanceWalkingRunning { get; }
    public static MonoTouch.Foundation.NSString FlightsClimbed { get; }
    public static MonoTouch.Foundation.NSString ForcedExpiratoryVolume1 { get; }
    public static MonoTouch.Foundation.NSString ForcedVitalCapacity { get; }
    public static MonoTouch.Foundation.NSString HeartRate { 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 PeakExpiratoryFlowRate { get; }
    public static MonoTouch.Foundation.NSString PeripheralPerfusionIndex { get; }
    public static MonoTouch.Foundation.NSString RespiratoryRate { get; }
    public static MonoTouch.Foundation.NSString StepCount { 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 GetPredicateForCategorySamples (MonoTouch.Foundation.NSPredicateOperatorType operatorType, int value);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForDuration (MonoTouch.Foundation.NSPredicateOperatorType operatorType, double duration);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForMetadataKey (MonoTouch.Foundation.NSString metadataKey);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForMetadataKey (MonoTouch.Foundation.NSString metadataKey, MonoTouch.Foundation.NSObject[] allowedValues);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForMetadataKey (MonoTouch.Foundation.NSString metadataKey, MonoTouch.Foundation.NSPredicateOperatorType operatorType, MonoTouch.Foundation.NSObject value);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForObject (MonoTouch.Foundation.NSUuid objectUuid);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForObjects (MonoTouch.Foundation.NSSet objectUuids);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForObjectsFromSource (HKSource source);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForObjectsFromSources (MonoTouch.Foundation.NSSet sources);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForObjectsFromWorkout (HKWorkout workout);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForQuantitySamples (MonoTouch.Foundation.NSPredicateOperatorType operatorType, HKQuantity quantity);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForSamples (MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, HKQueryOptions options);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForTotalDistance (MonoTouch.Foundation.NSPredicateOperatorType operatorType, HKQuantity totalDistance);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForTotalEnergyBurned (MonoTouch.Foundation.NSPredicateOperatorType operatorType, HKQuantity totalEnergyBurned);
    public static MonoTouch.Foundation.NSPredicate GetPredicateForWorkouts (HKWorkoutActivityType workoutActivityType);
    public static MonoTouch.Foundation.NSPredicate PredicateForObjectsWithNoCorrelation ();
}

New Type MonoTouch.HealthKit.HKQueryOptions

[Serializable]
[Flags]
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 virtual HKSampleType SampleType { get; }
    public static MonoTouch.Foundation.NSString SortIdentifierEndDate { get; }
    public static MonoTouch.Foundation.NSString SortIdentifierStartDate { 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);
    // fields
    public static const int NoLimit;
    // 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, HKSample[] results, MonoTouch.Foundation.NSError error, System.AsyncCallback callback, object object);
    public virtual void EndInvoke (System.IAsyncResult result);
    public virtual void Invoke (HKSampleQuery query, HKSample[] 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 HKSource[] 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, HKStatisticsCollectionEnumerator handler);
    public virtual HKStatistics GetStatistics (MonoTouch.Foundation.NSDate date);
}

New Type MonoTouch.HealthKit.HKStatisticsCollectionEnumerator

public sealed delegate HKStatisticsCollectionEnumerator : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public HKStatisticsCollectionEnumerator (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]
[Flags]
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, HKStatisticsQueryHandler handler);
    // properties
    public override System.IntPtr ClassHandle { get; }
}

New Type MonoTouch.HealthKit.HKStatisticsQueryHandler

public sealed delegate HKStatisticsQueryHandler : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public HKStatisticsQueryHandler (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.HKStoreSampleAddedCallback

public sealed delegate HKStoreSampleAddedCallback : System.MulticastDelegate, System.ICloneable, System.Runtime.Serialization.ISerializable {
    // constructors
    public HKStoreSampleAddedCallback (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.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);
    // fields
    public static const double MolarMassBloodGlucose;
    // properties
    public static HKUnit Atmosphere { get; }
    public static HKUnit Calorie { get; }
    public static HKUnit CentimeterOfWater { get; }
    public override System.IntPtr ClassHandle { get; }
    public static HKUnit Count { get; }
    public static HKUnit Day { get; }
    public static HKUnit DegreeCelsius { get; }
    public static HKUnit DegreeFahrenheit { get; }
    public static HKUnit FluidOunceImperialUnit { get; }
    public static HKUnit FluidOunceUSUnit { get; }
    public static HKUnit Foot { get; }
    public static HKUnit Gram { get; }
    public static HKUnit Hour { get; }
    public static HKUnit Inch { get; }
    public virtual bool IsNull { get; }
    public static HKUnit Joule { get; }
    public static HKUnit Kelvin { get; }
    public static HKUnit Kilocalorie { get; }
    public static HKUnit Liter { get; }
    public static HKUnit Meter { get; }
    public static HKUnit Mile { get; }
    public static HKUnit MillimeterOfMercury { get; }
    public static HKUnit Minute { get; }
    public static HKUnit Ounce { get; }
    public static HKUnit Pascal { get; }
    public static HKUnit Percent { get; }
    public static HKUnit PintImperialUnit { get; }
    public static HKUnit PintUSUnit { get; }
    public static HKUnit Pound { get; }
    public static HKUnit Second { get; }
    public static HKUnit Siemen { get; }
    public static HKUnit Stone { get; }
    public virtual string UnitString { get; }
    // methods
    public static HKUnit CreateJouleUnit (HKMetricPrefix prefix);
    public static HKUnit CreateLiterUnit (HKMetricPrefix prefix);
    public static HKUnit CreateMeterUnit (HKMetricPrefix prefix);
    public static HKUnit CreateMoleUnit (double gramsPerMole);
    public static HKUnit CreateMoleUnit (HKMetricPrefix prefix, double gramsPerMole);
    public static HKUnit CreatePascalUnit (HKMetricPrefix prefix);
    public static HKUnit CreateSecondUnit (HKMetricPrefix prefix);
    public static HKUnit CreateSiemenUnit (HKMetricPrefix prefix);
    public static HKUnit FromEnergyFormatterUnit (MonoTouch.Foundation.NSEnergyFormatterUnit energyFormatterUnit);
    public static HKUnit FromGramUnit (HKMetricPrefix prefix);
    public static HKUnit FromLengthFormatterUnit (MonoTouch.Foundation.NSLengthFormatterUnit lengthFormatterUnit);
    public static HKUnit FromMassFormatterUnit (MonoTouch.Foundation.NSMassFormatterUnit massFormatterUnit);
    public static HKUnit FromString (string aString);
    public static MonoTouch.Foundation.NSEnergyFormatterUnit GetEnergyFormatterUnit (HKUnit unit);
    public static MonoTouch.Foundation.NSLengthFormatterUnit GetLengthFormatterUnit (HKUnit unit);
    public static MonoTouch.Foundation.NSMassFormatterUnit GetMassFormatterUnit (HKUnit unit);
    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 Type MonoTouch.HealthKit.HKWorkout

public class HKWorkout : MonoTouch.HealthKit.HKSample, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public HKWorkout (MonoTouch.Foundation.NSCoder coder);
    public HKWorkout (MonoTouch.Foundation.NSObjectFlag t);
    public HKWorkout (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual double Duration { get; }
    public static MonoTouch.Foundation.NSString SortIdentifierDuration { get; }
    public static MonoTouch.Foundation.NSString SortIdentifierTotalDistance { get; }
    public static MonoTouch.Foundation.NSString SortIdentifierTotalEnergyBurned { get; }
    public virtual HKQuantity TotalDistance { get; }
    public virtual HKQuantity TotalEnergyBurned { get; }
    public virtual HKWorkoutActivityType WorkoutActivityType { get; }
    public virtual HKWorkoutEvent[] WorkoutEvents { get; }
    // methods
    public static HKWorkout Create (HKWorkoutActivityType workoutActivityType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate);
    public static HKWorkout Create (HKWorkoutActivityType workoutActivityType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, HKWorkoutEvent[] workoutEvents, HKQuantity totalEnergyBurned, HKQuantity totalDistance, MonoTouch.Foundation.NSDictionary metadata);
    public static HKWorkout Create (HKWorkoutActivityType workoutActivityType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, HKWorkoutEvent[] workoutEvents, HKQuantity totalEnergyBurned, HKQuantity totalDistance, HKMetadata metadata);
    public static HKWorkout Create (HKWorkoutActivityType workoutActivityType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, double duration, HKQuantity totalEnergyBurned, HKQuantity totalDistance, MonoTouch.Foundation.NSDictionary metadata);
    public static HKWorkout Create (HKWorkoutActivityType workoutActivityType, MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, double duration, HKQuantity totalEnergyBurned, HKQuantity totalDistance, HKMetadata metadata);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKWorkoutActivityType

[Serializable]
public enum HKWorkoutActivityType {
    AmericanFootball = 1,
    Archery = 2,
    AustralianFootball = 3,
    Badminton = 4,
    Baseball = 5,
    Basketball = 6,
    Bowling = 7,
    Boxing = 8,
    Climbing = 9,
    Cricket = 10,
    CrossTraining = 11,
    Curling = 12,
    Cycling = 13,
    Dance = 14,
    DanceInspiredTraining = 15,
    Elliptical = 16,
    EquestrianSports = 17,
    Fencing = 18,
    Fishing = 19,
    FunctionalStrengthTraining = 20,
    Golf = 21,
    Gymnastics = 22,
    Handball = 23,
    Hiking = 24,
    Hockey = 25,
    Hunting = 26,
    Lacrosse = 27,
    MartialArts = 28,
    MindAndBody = 29,
    MixedMetabolicCardioTraining = 30,
    PaddleSports = 31,
    Play = 32,
    PreparationAndRecovery = 33,
    Racquetball = 34,
    Rowing = 35,
    Rugby = 36,
    Running = 37,
    Sailing = 38,
    SkatingSports = 39,
    SnowSports = 40,
    Soccer = 41,
    Softball = 42,
    Squash = 43,
    StairClimbing = 44,
    SurfingSports = 45,
    Swimming = 46,
    TableTennis = 47,
    Tennis = 48,
    TrackAndField = 49,
    TraditionalStrengthTraining = 50,
    Volleyball = 51,
    Walking = 52,
    WaterFitness = 53,
    WaterPolo = 54,
    WaterSports = 55,
    Wrestling = 56,
    Yoga = 57,
}

New Type MonoTouch.HealthKit.HKWorkoutEvent

public class HKWorkoutEvent : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCoding, MonoTouch.Foundation.INSSecureCoding, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public HKWorkoutEvent (MonoTouch.Foundation.NSCoder coder);
    public HKWorkoutEvent (MonoTouch.Foundation.NSObjectFlag t);
    public HKWorkoutEvent (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MonoTouch.Foundation.NSDate Date { get; }
    public virtual HKWorkoutEventType Type { get; }
    // methods
    public static HKWorkoutEvent Create (HKWorkoutEventType type, MonoTouch.Foundation.NSDate date);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.HealthKit.HKWorkoutEventType

[Serializable]
public enum HKWorkoutEventType {
    Pause = 1,
    Resume = 2,
}

New Type MonoTouch.HealthKit.HKWorkoutType

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

New Namespace MonoTouch.HomeKit

New Type MonoTouch.HomeKit.HMAccessory

public class HMAccessory : MonoTouch.Foundation.NSObject, 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 Blocked { get; }
    public virtual bool Bridged { get; }
    public override System.IntPtr ClassHandle { 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<HMAccessoryUpdateEventArgs> DidUpdateAssociatedServiceType;
    public event System.EventHandler DidUpdateName;
    public event System.EventHandler<HMAccessoryUpdateEventArgs> 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 Identify (System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task IdentifyAsync ();
    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.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 DidUpdateAssociatedServiceType (HMAccessory accessory, HMService service);
    public virtual void DidUpdateName (HMAccessory accessory);
    public virtual void DidUpdateNameForService (HMAccessory accessory, 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 DidUpdateAssociatedServiceType (IHMAccessoryDelegate This, HMAccessory accessory, HMService service);
    public static void DidUpdateName (IHMAccessoryDelegate This, HMAccessory accessory);
    public static void DidUpdateNameForService (IHMAccessoryDelegate This, HMAccessory accessory, 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.HMAccessoryUpdateEventArgs

public class HMAccessoryUpdateEventArgs : System.EventArgs {
    // constructors
    public HMAccessoryUpdateEventArgs (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.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 virtual bool Executing { 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.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 virtual MonoTouch.Foundation.NSString[] Properties { get; }
    public bool Readable { get; }
    public virtual HMService Service { get; }
    public bool SupportsEventNotification { get; }
    public virtual MonoTouch.Foundation.NSObject Value { get; }
    public bool Writable { get; }
    // methods
    protected override void Dispose (bool disposing);
    public virtual void EnableNotification (bool enable, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task EnableNotificationAsync (bool enable);
    public virtual void ReadValue (System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task ReadValueAsync ();
    public virtual void UpdateAuthorizationData (MonoTouch.Foundation.NSData data, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task UpdateAuthorizationDataAsync (MonoTouch.Foundation.NSData data);
    public virtual void WriteValue (MonoTouch.Foundation.NSObject value, System.Action<MonoTouch.Foundation.NSError> completion);
    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 HMCharacteristicMetadataFormat Format { get; }
    public virtual string ManufacturerDescription { get; }
    public virtual MonoTouch.Foundation.NSNumber MaximumValue { get; }
    public virtual MonoTouch.Foundation.NSNumber MaxLength { 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.HMCharacteristicMetadataFormat

[Serializable]
public enum HMCharacteristicMetadataFormat {
    Array = 5,
    Bool = 1,
    Data = 11,
    Dictionary = 6,
    Float = 3,
    Int = 2,
    None = 0,
    String = 4,
    Tlv8 = 12,
    UInt16 = 8,
    UInt32 = 9,
    UInt64 = 10,
    UInt8 = 7,
}

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 {
    AdminOnlyAccess = 29,
    AudioFeedback = 28,
    Brightness = 4,
    CoolingThreshold = 10,
    CurrentDoorState = 15,
    CurrentHeatingCooling = 8,
    CurrentLockMechanismState = 31,
    CurrentRelativeHumidity = 13,
    CurrentTemperature = 6,
    HeatingCoolingStatus = 12,
    HeatingThreshold = 11,
    Hue = 2,
    Identify = 22,
    LockManagementAutoSecureTimeout = 35,
    LockManagementControlPoint = 34,
    LockMechanismLastKnownAction = 33,
    Logs = 27,
    Manufacturer = 19,
    Model = 20,
    MotionDetected = 30,
    Name = 18,
    None = 0,
    ObstructionDetected = 17,
    OutletInUse = 25,
    PowerState = 1,
    RotationDirection = 23,
    RotationSpeed = 24,
    Saturation = 3,
    SerialNumber = 21,
    TargetDoorState = 16,
    TargetHeatingCooling = 9,
    TargetLockMechanismState = 32,
    TargetRelativeHumidity = 14,
    TargetTemperature = 7,
    TemperatureUnits = 5,
    Version = 26,
}

New Type MonoTouch.HomeKit.HMCharacteristicValueDoorState

[Serializable]
public enum HMCharacteristicValueDoorState {
    Closed = 1,
    Closing = 3,
    Open = 0,
    Opening = 2,
    Stopped = 4,
}

New Type MonoTouch.HomeKit.HMCharacteristicValueHeatingCooling

[Serializable]
public enum HMCharacteristicValueHeatingCooling {
    Auto = 3,
    Cool = 2,
    Heat = 1,
    Off = 0,
}

New Type MonoTouch.HomeKit.HMCharacteristicValueLockMechanism

[Serializable]
public enum HMCharacteristicValueLockMechanism {
    LastKnownActionSecuredRemotely = 6,
    LastKnownActionSecuredUsingPhysicalMovementExterior = 2,
    LastKnownActionSecuredUsingPhysicalMovementInterior = 0,
    LastKnownActionSecuredWithAutomaticSecureTimeout = 8,
    LastKnownActionSecuredWithKeypad = 4,
    LastKnownActionUnsecuredRemotely = 7,
    LastKnownActionUnsecuredUsingPhysicalMovementExterior = 3,
    LastKnownActionUnsecuredUsingPhysicalMovementInterior = 1,
    LastKnownActionUnsecuredWithKeypad = 5,
}

New Type MonoTouch.HomeKit.HMCharacteristicValueLockMechanismState

[Serializable]
public enum HMCharacteristicValueLockMechanismState {
    Jammed = 2,
    Secured = 1,
    Unknown = 3,
    Unsecured = 0,
}

New Type MonoTouch.HomeKit.HMCharacteristicValueRotationDirection

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

New Type MonoTouch.HomeKit.HMCharacteristicValueTemperatureUnit

[Serializable]
public enum HMCharacteristicValueTemperatureUnit {
    Celsius = 0,
    Fahrenheit = 1,
}

New Type MonoTouch.HomeKit.HMCharacteristicWriteAction

public class HMCharacteristicWriteAction : MonoTouch.HomeKit.HMAction, 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> completion);
    public virtual System.Threading.Tasks.Task UpdateTargetValueAsync (MonoTouch.Foundation.NSObject targetValue);
}

New Type MonoTouch.HomeKit.HMError

[Serializable]
public enum HMError {
    AccessDenied = 10,
    AccessoryDiscoveryFailed = 57,
    AccessoryIsBlocked = 61,
    AccessoryIsBusy = 14,
    AccessoryNotReachable = 4,
    AccessoryOutOfCompliance = 66,
    AccessoryOutOfResources = 16,
    AccessoryPairingFailed = 18,
    AccessoryPoweredOff = 9,
    AccessoryResponseError = 59,
    AccessorySentInvalidResponse = 50,
    ActionInAnotherActionSet = 30,
    ActionSetExecutionFailed = 63,
    ActionSetExecutionInProgress = 65,
    ActionSetExecutionPartialSuccess = 64,
    AddAccessoryFailed = 79,
    AlreadyExists = 1,
    CannotActivateTriggerTooFarInFuture = 71,
    CannotRemoveNonBridgeAccessory = 34,
    ClientRequestError = 58,
    CloudDataSyncInProgress = 77,
    CommunicationFailure = 54,
    DataResetFailure = 67,
    DateMustBeOnSpecifiedBoundaries = 70,
    FireDateInPast = 28,
    GenericError = 52,
    HomeAccessNotAuthorized = 47,
    HomeWithSimilarNameExists = 32,
    InsufficientPrivileges = 17,
    InvalidAssociatedServiceType = 62,
    InvalidClass = 22,
    InvalidDataFormatSpecified = 19,
    InvalidMessageSize = 56,
    InvalidParameter = 3,
    InvalidValueType = 43,
    KeychainSyncNotEnabled = 76,
    MaximumObjectLimitReached = 49,
    MessageAuthenticationFailed = 55,
    MissingEntitlement = 80,
    MissingParameter = 27,
    NameContainsProhibitedCharacters = 35,
    NameDoesNotEndWithValidCharacters = 60,
    NameDoesNotStartWithValidCharacters = 36,
    NetworkUnavailable = 78,
    NilParameter = 20,
    NoActionsInActionSet = 25,
    NoRegisteredActionSets = 26,
    NotFound = 2,
    NotificationAlreadyEnabled = 68,
    NotificationNotSupported = 7,
    NotSignedIntoiCloud = 75,
    ObjectAlreadyAssociatedToHome = 13,
    ObjectAssociatedToAnotherHome = 11,
    ObjectNotAssociatedToAnyHome = 12,
    ObjectWithSimilarNameExistsInHome = 31,
    OperationCancelled = 23,
    OperationInProgress = 15,
    OperationNotSupported = 48,
    OperationTimedOut = 8,
    ReadOnlyCharacteristic = 5,
    ReadWriteFailure = 74,
    ReadWritePartialSuccess = 73,
    RecurrenceMustBeOnSpecifiedBoundaries = 69,
    RecurrenceTooLarge = 72,
    RecurrenceTooSmall = 42,
    RenameWithSimilarName = 33,
    RoomForHomeCannotBeInZone = 24,
    RoomForHomeCannotBeUpdated = 29,
    SecurityFailure = 53,
    StringLongerThanMaximum = 46,
    StringShorterThanMinimum = 51,
    UnconfiguredParameter = 21,
    UserDeclinedAddingUser = 38,
    UserDeclinedInvite = 40,
    UserDeclinedRemovingUser = 39,
    UserIDNotEmailAddress = 37,
    UserManagementFailed = 41,
    ValueHigherThanMaximum = 45,
    ValueLowerThanMinimum = 44,
    WriteOnlyCharacteristic = 6,
}

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.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 static MonoTouch.Foundation.NSString UserFailedAccessoriesKey { get; }
    public virtual HMUser[] Users { 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<HMHomeServiceServiceGroupEventArgs> DidAddService;
    public event System.EventHandler<HMHomeServiceGroupEventArgs> DidAddServiceGroup;
    public event System.EventHandler<HMHomeTriggerEventArgs> DidAddTrigger;
    public event System.EventHandler<HMHomeUserEventArgs> DidAddUser;
    public event System.EventHandler<HMHomeZoneEventArgs> DidAddZone;
    public event System.EventHandler<HMHomeErrorAccessoryEventArgs> DidEncounterError;
    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> DidRemoveService;
    public event System.EventHandler<HMHomeServiceGroupEventArgs> DidRemoveServiceGroup;
    public event System.EventHandler<HMHomeTriggerEventArgs> DidRemoveTrigger;
    public event System.EventHandler<HMHomeUserEventArgs> DidRemoveUser;
    public event System.EventHandler<HMHomeZoneEventArgs> DidRemoveZone;
    public event System.EventHandler<HMHomeAccessoryEventArgs> DidUnblockAccessory;
    public event System.EventHandler<HMHomeActionSetEventArgs> DidUpdateActionsForActionSet;
    public event System.EventHandler<HMHomeActionSetEventArgs> DidUpdateNameForActionSet;
    public event System.EventHandler DidUpdateNameForHome;
    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<HMHomeRoomAccessoryEventArgs> DidUpdateRoom;
    public event System.EventHandler<HMHomeTriggerEventArgs> DidUpdateTrigger;
    // methods
    public virtual void AddAccessory (HMAccessory accessory, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task AddAccessoryAsync (HMAccessory accessory);
    public virtual void AddActionSet (string actionSetName, System.Action<HMActionSet,MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task<HMActionSet> AddActionSetAsync (string actionSetName);
    public virtual void AddRoom (string roomName, System.Action<HMRoom,MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task<HMRoom> AddRoomAsync (string roomName);
    public virtual void AddServiceGroup (string serviceGroupName, System.Action<HMServiceGroup,MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task<HMServiceGroup> AddServiceGroupAsync (string serviceGroupName);
    public virtual void AddTrigger (HMTrigger trigger, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task AddTriggerAsync (HMTrigger trigger);
    public virtual void AddUser (System.Action<HMUser,MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task<HMUser> AddUserAsync ();
    public virtual void AddZone (string zoneName, System.Action<HMZone,MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task<HMZone> AddZoneAsync (string zoneName);
    public virtual void AssignAccessory (HMAccessory accessory, HMRoom room, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task AssignAccessoryAsync (HMAccessory accessory, HMRoom room);
    protected override void Dispose (bool disposing);
    public virtual void ExecuteActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task ExecuteActionSetAsync (HMActionSet actionSet);
    public virtual HMRoom GetRoomForEntireHome ();
    public HMService[] GetServices (HMServiceType serviceTypes);
    public virtual void RemoveAccessory (HMAccessory accessory, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveAccessoryAsync (HMAccessory accessory);
    public virtual void RemoveActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveActionSetAsync (HMActionSet actionSet);
    public virtual void RemoveRoom (HMRoom room, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveRoomAsync (HMRoom room);
    public virtual void RemoveServiceGroup (HMServiceGroup group, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveServiceGroupAsync (HMServiceGroup group);
    public virtual void RemoveTrigger (HMTrigger trigger, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveTriggerAsync (HMTrigger trigger);
    public virtual void RemoveUser (HMUser user, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveUserAsync (HMUser user);
    public virtual void RemoveZone (HMZone zone, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveZoneAsync (HMZone zone);
    public virtual void UnblockAccessory (HMAccessory accessory, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task UnblockAccessoryAsync (HMAccessory accessory);
    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.HMHomeAccessoryEventArgs

public class HMHomeAccessoryEventArgs : System.EventArgs {
    // constructors
    public HMHomeAccessoryEventArgs (HMAccessory accessory);
    // properties
    public HMAccessory Accessory { 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.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 DidAddService (HMHome home, HMService service, HMServiceGroup group);
    public virtual void DidAddServiceGroup (HMHome home, HMServiceGroup group);
    public virtual void DidAddTrigger (HMHome home, HMTrigger trigger);
    public virtual void DidAddUser (HMHome home, HMUser user);
    public virtual void DidAddZone (HMHome home, HMZone zone);
    public virtual void DidEncounterError (HMHome home, MonoTouch.Foundation.NSError error, HMAccessory accessory);
    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 DidRemoveService (HMHome home, HMService service, HMServiceGroup group);
    public virtual void DidRemoveServiceGroup (HMHome home, HMServiceGroup group);
    public virtual void DidRemoveTrigger (HMHome home, HMTrigger trigger);
    public virtual void DidRemoveUser (HMHome home, HMUser user);
    public virtual void DidRemoveZone (HMHome home, HMZone zone);
    public virtual void DidUnblockAccessory (HMHome home, HMAccessory accessory);
    public virtual void DidUpdateActionsForActionSet (HMHome home, HMActionSet actionSet);
    public virtual void DidUpdateNameForActionSet (HMHome home, HMActionSet actionSet);
    public virtual void DidUpdateNameForHome (HMHome home);
    public virtual void DidUpdateNameForRoom (HMHome home, HMRoom room);
    public virtual void DidUpdateNameForServiceGroup (HMHome home, HMServiceGroup group);
    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 DidAddService (IHMHomeDelegate This, HMHome home, HMService service, HMServiceGroup group);
    public static void DidAddServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup group);
    public static void DidAddTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
    public static void DidAddUser (IHMHomeDelegate This, HMHome home, HMUser user);
    public static void DidAddZone (IHMHomeDelegate This, HMHome home, HMZone zone);
    public static void DidEncounterError (IHMHomeDelegate This, HMHome home, MonoTouch.Foundation.NSError error, HMAccessory accessory);
    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 DidRemoveService (IHMHomeDelegate This, HMHome home, HMService service, HMServiceGroup group);
    public static void DidRemoveServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup group);
    public static void DidRemoveTrigger (IHMHomeDelegate This, HMHome home, HMTrigger trigger);
    public static void DidRemoveUser (IHMHomeDelegate This, HMHome home, HMUser user);
    public static void DidRemoveZone (IHMHomeDelegate This, HMHome home, HMZone zone);
    public static void DidUnblockAccessory (IHMHomeDelegate This, HMHome home, HMAccessory accessory);
    public static void DidUpdateActionsForActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
    public static void DidUpdateNameForActionSet (IHMHomeDelegate This, HMHome home, HMActionSet actionSet);
    public static void DidUpdateNameForHome (IHMHomeDelegate This, HMHome home);
    public static void DidUpdateNameForRoom (IHMHomeDelegate This, HMHome home, HMRoom room);
    public static void DidUpdateNameForServiceGroup (IHMHomeDelegate This, HMHome home, HMServiceGroup group);
    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.HMHomeErrorAccessoryEventArgs

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

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> completion);
    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> completion);
    public virtual System.Threading.Tasks.Task RemoveHomeAsync (HMHome home);
    public virtual void UpdatePrimaryHome (HMHome home, System.Action<MonoTouch.Foundation.NSError> completion);
    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.HMHomeRoomAccessoryEventArgs

public class HMHomeRoomAccessoryEventArgs : System.EventArgs {
    // constructors
    public HMHomeRoomAccessoryEventArgs (HMRoom room, HMAccessory accessory);
    // properties
    public HMAccessory Accessory { get; set; }
    public HMRoom Room { 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 group);
    // properties
    public HMServiceGroup Group { get; set; }
}

New Type MonoTouch.HomeKit.HMHomeServiceServiceGroupEventArgs

public class HMHomeServiceServiceGroupEventArgs : System.EventArgs {
    // constructors
    public HMHomeServiceServiceGroupEventArgs (HMService service, HMServiceGroup group);
    // properties
    public HMServiceGroup Group { get; set; }
    public HMService Service { 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.HMHomeUserEventArgs

public class HMHomeUserEventArgs : System.EventArgs {
    // constructors
    public HMHomeUserEventArgs (HMUser user);
    // properties
    public HMUser User { 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.HMRoom

public class HMRoom : MonoTouch.Foundation.NSObject, 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> completion);
    public virtual System.Threading.Tasks.Task UpdateNameAsync (string name);
}

New Type MonoTouch.HomeKit.HMService

public class HMService : MonoTouch.Foundation.NSObject, 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 string AssociatedServiceType { 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 UpdateAssociatedServiceType (string serviceType, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task UpdateAssociatedServiceTypeAsync (string serviceType);
    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.HMServiceGroup

public class HMServiceGroup : MonoTouch.Foundation.NSObject, 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> completion);
    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> completion);
    public virtual System.Threading.Tasks.Task RemoveServiceAsync (HMService service);
    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.HMServiceType

[Serializable]
[Flags]
public enum HMServiceType {
    AccessoryInformation = 5,
    Fan = 6,
    GarageDoorOpener = 4,
    LightBulb = 1,
    LockManagement = 9,
    LockMechanism = 8,
    None = 0,
    Outlet = 7,
    Switch = 2,
    Thermostat = 3,
}

New Type MonoTouch.HomeKit.HMTimerTrigger

public class HMTimerTrigger : MonoTouch.HomeKit.HMTrigger, 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.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> completion);
    public virtual System.Threading.Tasks.Task UpdateFireDateAsync (MonoTouch.Foundation.NSDate fireDate);
    public virtual void UpdateRecurrence (MonoTouch.Foundation.NSDateComponents recurrence, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task UpdateRecurrenceAsync (MonoTouch.Foundation.NSDateComponents recurrence);
    public virtual void UpdateTimeZone (MonoTouch.Foundation.NSTimeZone timeZone, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task UpdateTimeZoneAsync (MonoTouch.Foundation.NSTimeZone timeZone);
}

New Type MonoTouch.HomeKit.HMTrigger

public class HMTrigger : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public HMTrigger (MonoTouch.Foundation.NSCoder coder);
    public HMTrigger (MonoTouch.Foundation.NSObjectFlag t);
    public HMTrigger (System.IntPtr handle);
    // properties
    public virtual HMActionSet[] ActionSets { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual bool Enabled { get; }
    public virtual MonoTouch.Foundation.NSDate LastFireDate { get; }
    public virtual string Name { get; }
    // methods
    public virtual void AddActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completion);
    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> completion);
    public virtual System.Threading.Tasks.Task EnableAsync (bool enable);
    public virtual void RemoveActionSet (HMActionSet actionSet, System.Action<MonoTouch.Foundation.NSError> completion);
    public virtual System.Threading.Tasks.Task RemoveActionSetAsync (HMActionSet actionSet);
    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.HMUser

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

New Type MonoTouch.HomeKit.HMZone

public class HMZone : MonoTouch.Foundation.NSObject, 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> completion);
    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> completion);
    public virtual System.Threading.Tasks.Task RemoveRoomAsync (HMRoom room);
    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.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; }
    public virtual string LocalizedFallbackTitle { get; set; }
    // methods
    public virtual bool CanEvaluatePolicy (LAPolicy policy, out 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.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 sourceBytesPerRow, uint sourceBytesPerImage, 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 destinatinBytesPerRow, uint destinationBytesPerImage);
    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 Commit ();
    public virtual void Enqueue ();
    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 SetBuffer (IMTLBuffer buffer, uint offset, uint index);
    public virtual void SetComputePipelineState (IMTLComputePipelineState state);
    public virtual void SetSamplerState (IMTLSamplerState sampler, uint index);
    public virtual void SetSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
    public virtual void SetTexture (IMTLTexture texture, uint index);
    public virtual void SetThreadgroupMemoryLength (uint length, uint index);
    public virtual void SispatchThreadgroups (MTLSize threadgroupsPerGrid, MTLSize threadsPerThreadgroup);
}

New Type MonoTouch.Metal.IMTLComputePipelineState

public interface IMTLComputePipelineState : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual IMTLDevice Device { get; }
    public virtual uint MaxTotalThreadsPerThreadgroup { get; }
    public virtual uint ThreadExecutionWidth { 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, MTLPipelineOption options, System.Action<IMTLComputePipelineState,MonoTouch.Metal.MTLComputePipelineReflection,MonoTouch.Foundation.NSError> completionHandler);
    public virtual IMTLComputePipelineState CreateComputePipelineState (IMTLFunction computeFunction, out MonoTouch.Foundation.NSError error);
    public virtual IMTLLibrary CreateDefaultLibrary ();
    public virtual IMTLDepthStencilState CreateDepthStencilState (MTLDepthStencilDescriptor 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 bool SupportsFeatureSet (MTLFeatureSet featureSet);
}

New Type MonoTouch.Metal.IMTLDrawable

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

New Type MonoTouch.Metal.IMTLFunction

public interface IMTLFunction : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // properties
    public virtual IMTLDevice Device { get; }
    public virtual MTLFunctionType FunctionType { get; }
    public virtual string Name { get; }
    public virtual MTLVertexAttribute[] VertexAttributes { 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.IMTLParallelRenderCommandEncoder

public interface IMTLParallelRenderCommandEncoder : MonoTouch.ObjCRuntime.INativeObject, System.IDisposable, IMTLCommandEncoder {
    // methods
    public virtual IMTLRenderCommandEncoder CreateRenderCommandEncoder ();
}

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 SetDepthStencilState (IMTLDepthStencilState depthStencilState);
    public virtual void SetFragmentBuffer (IMTLBuffer buffer, uint offset, uint index);
    public virtual void SetFragmentBuffers (IMTLBuffer buffers, System.IntPtr IntPtrOffsets, MonoTouch.Foundation.NSRange range);
    public virtual void SetFragmentSamplerState (IMTLSamplerState sampler, uint index);
    public virtual void SetFragmentSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
    public virtual void SetFragmentSamplerStates (IMTLSamplerState[] samplers, System.IntPtr floatArrayPtrLodMinClamps, System.IntPtr floatArrayPtrLodMaxClamps, MonoTouch.Foundation.NSRange range);
    public virtual void SetFragmentSamplerStates (IMTLSamplerState[] samplers, MonoTouch.Foundation.NSRange range);
    public virtual void SetFragmentTexture (IMTLTexture texture, uint index);
    public virtual void SetFragmentTextures (IMTLTexture[] textures, MonoTouch.Foundation.NSRange range);
    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 SetVertexBuffers (IMTLBuffer[] buffers, System.IntPtr uintArrayPtrOffsets, MonoTouch.Foundation.NSRange range);
    public virtual void SetVertexSamplerState (IMTLSamplerState sampler, uint index);
    public virtual void SetVertexSamplerState (IMTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, uint index);
    public virtual void SetVertexSamplerStates (IMTLSamplerState[] samplers, System.IntPtr floatArrayPtrLodMinClamps, System.IntPtr floatArrayPtrLodMaxClamps, MonoTouch.Foundation.NSRange range);
    public virtual void SetVertexSamplerStates (IMTLSamplerState[] samplers, MonoTouch.Foundation.NSRange range);
    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 IMTLTexture CreateTextureView (MTLPixelFormat pixelFormat);
}

New Type MonoTouch.Metal.MTLArgument

public class MTLArgument : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLArgument ();
    public MTLArgument (MonoTouch.Foundation.NSCoder coder);
    public MTLArgument (MonoTouch.Foundation.NSObjectFlag t);
    public MTLArgument (System.IntPtr handle);
    // properties
    public virtual MTLArgumentAccess Access { get; }
    public virtual bool Active { get; }
    public virtual uint BufferAlignment { get; }
    public virtual uint BufferDataSize { get; }
    public virtual MTLDataType BufferDataType { get; }
    public virtual MTLStructType BufferStructType { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual uint Index { get; }
    public virtual string Name { get; }
    public virtual MTLDataType TextureDataType { get; }
    public virtual MTLTextureType TextureType { get; }
    public virtual uint ThreadgroupMemoryAlignment { get; }
    public virtual uint ThreadgroupMemoryDataSize { get; }
    public virtual MTLArgumentType Type { get; }
    // methods
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLArgumentAccess

[Serializable]
public enum MTLArgumentAccess {
    ReadOnly = 0,
    ReadWrite = 1,
    WriteOnly = 2,
}

New Type MonoTouch.Metal.MTLArgumentType

[Serializable]
public enum MTLArgumentType {
    Buffer = 0,
    Sampler = 3,
    Texture = 2,
    ThreadgroupMemory = 1,
}

New Type MonoTouch.Metal.MTLArrayType

public class MTLArrayType : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLArrayType ();
    public MTLArrayType (MonoTouch.Foundation.NSCoder coder);
    public MTLArrayType (MonoTouch.Foundation.NSObjectFlag t);
    public MTLArrayType (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLDataType ElementType { get; }
    public virtual uint Length { get; }
    public virtual uint Stride { get; }
    // methods
    public virtual MTLArrayType ElementArrayType ();
    public virtual MTLStructType ElementStructType ();
}

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 {
    // methods
    public static IMTLParallelRenderCommandEncoder CreateParallelRenderCommandEncoder (IMTLCommandBuffer This, MTLRenderPassDescriptor renderPassDescriptor);
    public static IMTLRenderCommandEncoder CreateRenderCommandEncoder (IMTLCommandBuffer This, MTLRenderPassDescriptor renderPassDescriptor);
    public static void PresentDrawable (IMTLCommandBuffer This, IMTLDrawable drawable);
    public static void PresentDrawable (IMTLCommandBuffer This, IMTLDrawable drawable, double presentationTime);
}

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 {
    // methods
    public static void SetBuffers (IMTLComputeCommandEncoder This, IMTLBuffer[] buffers, System.IntPtr offsets, MonoTouch.Foundation.NSRange range);
    public static void SetSamplerStates (IMTLComputeCommandEncoder This, IMTLSamplerState[] samplers, System.IntPtr floatArrayPtrLodMinClamps, System.IntPtr floatArrayPtrLodMaxClamps, MonoTouch.Foundation.NSRange range);
    public static void SetSamplerStates (IMTLComputeCommandEncoder This, IMTLSamplerState[] samplers, MonoTouch.Foundation.NSRange range);
    public static void SetTextures (IMTLComputeCommandEncoder This, IMTLTexture[] textures, MonoTouch.Foundation.NSRange range);
}

New Type MonoTouch.Metal.MTLComputePipelineReflection

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

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.MTLDataType

[Serializable]
public enum MTLDataType {
    Array = 2,
    Bool = 53,
    Bool2 = 54,
    Bool3 = 55,
    Bool4 = 56,
    Char = 45,
    Char2 = 46,
    Char3 = 47,
    Char4 = 48,
    Float = 3,
    Float2 = 4,
    Float2x2 = 7,
    Float2x3 = 8,
    Float2x4 = 9,
    Float3 = 5,
    Float3x2 = 10,
    Float3x3 = 11,
    Float3x4 = 12,
    Float4 = 6,
    Float4x2 = 13,
    Float4x3 = 14,
    Float4x4 = 15,
    Half = 16,
    Half2 = 17,
    Half2x2 = 20,
    Half2x3 = 21,
    Half2x4 = 22,
    Half3 = 18,
    Half3x2 = 23,
    Half3x3 = 24,
    Half3x4 = 25,
    Half4 = 19,
    Half4x2 = 26,
    Half4x3 = 27,
    Half4x4 = 28,
    Int = 29,
    Int2 = 30,
    Int3 = 31,
    Int4 = 32,
    None = 0,
    Short = 37,
    Short2 = 38,
    Short3 = 39,
    Short4 = 40,
    Struct = 1,
    UChar = 49,
    UChar2 = 50,
    UChar3 = 51,
    UChar4 = 52,
    UInt = 33,
    UInt2 = 34,
    UInt3 = 35,
    UInt4 = 36,
    UShort = 41,
    UShort2 = 42,
    UShort3 = 43,
    UShort4 = 44,
}

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.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 BackFaceStencil { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLCompareFunction DepthCompareFunction { get; set; }
    public virtual bool DepthWriteEnabled { get; set; }
    public virtual MTLStencilDescriptor FrontFaceStencil { 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 static class MTLDevice {
    // properties
    public static IMTLDevice SystemDefault { get; }
}

New Type MonoTouch.Metal.MTLDevice_Extensions

public static class MTLDevice_Extensions {
    // methods
    public static IMTLBuffer CreateBuffer<T> (IMTLDevice This, T[] data, MTLResourceOptions options);
    public static IMTLBuffer CreateBufferNoCopy<T> (IMTLDevice This, T[] data, MTLResourceOptions options, MTLDeallocator deallocator);
    public static IMTLComputePipelineState CreateComputePipelineState (IMTLDevice This, IMTLFunction computeFunction, MTLPipelineOption options, out MTLComputePipelineReflection reflection, out MonoTouch.Foundation.NSError error);
    public static void CreateComputePipelineState (IMTLDevice This, IMTLFunction computeFunction, System.Action<IMTLComputePipelineState,MonoTouch.Foundation.NSError> completionHandler);
    public static IMTLRenderPipelineState CreateRenderPipelineState (IMTLDevice This, MTLRenderPipelineDescriptor descriptor, MTLPipelineOption options, out MTLRenderPipelineReflection reflection, out MonoTouch.Foundation.NSError error);
    public static void CreateRenderPipelineState (IMTLDevice This, MTLRenderPipelineDescriptor descriptor, MTLPipelineOption options, System.Action<IMTLRenderPipelineState,MonoTouch.Metal.MTLRenderPipelineReflection,MonoTouch.Foundation.NSError> completionHandler);
}

New Type MonoTouch.Metal.MTLDrawable

public abstract class MTLDrawable : MonoTouch.Foundation.NSObject, IMTLDrawable, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLDrawable ();
    public MTLDrawable (MonoTouch.Foundation.NSCoder coder);
    public MTLDrawable (MonoTouch.Foundation.NSObjectFlag t);
    public MTLDrawable (System.IntPtr handle);
    // methods
    public virtual void Present ();
    public virtual void Present (double presentationTime);
}

New Type MonoTouch.Metal.MTLDrawable_Extensions

public static class MTLDrawable_Extensions {
}

New Type MonoTouch.Metal.MTLFeatureSet

[Serializable]
public enum MTLFeatureSet {
    iOS_GPUFamily1_v1 = 0,
    iOS_GPUFamily2_v1 = 1,
}

New Type MonoTouch.Metal.MTLFunction_Extensions

public static class MTLFunction_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.MTLParallelRenderCommandEncoder_Extensions

public static class MTLParallelRenderCommandEncoder_Extensions {
}

New Type MonoTouch.Metal.MTLPipelineOption

[Serializable]
[Flags]
public enum MTLPipelineOption {
    ArgumentInfo = 1,
    BufferTypeInfo = 2,
    None = 0,
}

New Type MonoTouch.Metal.MTLPixelFormat

[Serializable]
public enum MTLPixelFormat {
    A1BGR5Unorm = 41,
    A8Unorm = 1,
    ABGR4Unorm = 42,
    ASTC_10x10_LDR = 216,
    ASTC_10x10_sRGB = 198,
    ASTC_10x5_LDR = 213,
    ASTC_10x5_sRGB = 195,
    ASTC_10x6_LDR = 214,
    ASTC_10x6_sRGB = 196,
    ASTC_10x8_LDR = 215,
    ASTC_10x8_sRGB = 197,
    ASTC_12x10_LDR = 217,
    ASTC_12x10_sRGB = 199,
    ASTC_12x12_LDR = 218,
    ASTC_12x12_sRGB = 200,
    ASTC_4x4_LDR = 204,
    ASTC_4x4_sRGB = 186,
    ASTC_5x4_LDR = 205,
    ASTC_5x4_sRGB = 187,
    ASTC_5x5_LDR = 206,
    ASTC_5x5_sRGB = 188,
    ASTC_6x5_LDR = 207,
    ASTC_6x5_sRGB = 189,
    ASTC_6x6_LDR = 208,
    ASTC_6x6_sRGB = 190,
    ASTC_8x5_LDR = 210,
    ASTC_8x5_sRGB = 192,
    ASTC_8x6_LDR = 211,
    ASTC_8x6_sRGB = 193,
    ASTC_8x8_LDR = 212,
    ASTC_8x8_sRGB = 194,
    B5G6R5Unorm = 40,
    BGRA8Unorm = 80,
    BGRA8Unorm_sRGB = 81,
    BGRG422 = 241,
    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,
    GBGR422 = 240,
    Invalid = 0,
    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,
    RG11B10Float = 92,
    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,
    RGB10A2Uint = 91,
    RGB10A2Unorm = 90,
    RGB9E5Float = 93,
    RGBA16Float = 115,
    RGBA16Sint = 114,
    RGBA16Snorm = 112,
    RGBA16Uint = 113,
    RGBA16Unorm = 110,
    RGBA32Float = 125,
    RGBA32Sint = 124,
    RGBA32Uint = 123,
    RGBA8Sint = 74,
    RGBA8Snorm = 72,
    RGBA8Uint = 73,
    RGBA8Unorm = 70,
    RGBA8Unorm_sRGB = 71,
    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.MTLRegion

public struct MTLRegion {
    // constructors
    public MTLRegion (MTLOrigin origin, MTLSize size);
    // fields
    public MTLOrigin Origin;
    public MTLSize Size;
    // methods
    public static MTLRegion Create1D (uint x, uint width);
    public static MTLRegion Create2D (uint x, uint y, uint width, uint height);
    public static MTLRegion Create3D (uint x, uint y, uint z, uint width, uint height, uint depth);
}

New Type MonoTouch.Metal.MTLRenderCommandEncoder_Extensions

public static class MTLRenderCommandEncoder_Extensions {
    // methods
    public static void SetVertexTextures (IMTLRenderCommandEncoder This, IMTLTexture[] textures, MonoTouch.Foundation.NSRange range);
}

New Type MonoTouch.Metal.MTLRenderPassAttachmentDescriptor

public class MTLRenderPassAttachmentDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPassAttachmentDescriptor ();
    public MTLRenderPassAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPassAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPassAttachmentDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    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);
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLRenderPassColorAttachmentDescriptor

public class MTLRenderPassColorAttachmentDescriptor : MonoTouch.Metal.MTLRenderPassAttachmentDescriptor, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPassColorAttachmentDescriptor ();
    public MTLRenderPassColorAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPassColorAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPassColorAttachmentDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLClearColor ClearColor { get; set; }
}

New Type MonoTouch.Metal.MTLRenderPassColorAttachmentDescriptorArray

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

New Type MonoTouch.Metal.MTLRenderPassDepthAttachmentDescriptor

public class MTLRenderPassDepthAttachmentDescriptor : MonoTouch.Metal.MTLRenderPassAttachmentDescriptor, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPassDepthAttachmentDescriptor ();
    public MTLRenderPassDepthAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPassDepthAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPassDepthAttachmentDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual double ClearDepth { get; set; }
}

New Type MonoTouch.Metal.MTLRenderPassDescriptor

public class MTLRenderPassDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPassDescriptor ();
    public MTLRenderPassDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPassDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPassDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLRenderPassColorAttachmentDescriptorArray ColorAttachments { get; }
    public virtual MTLRenderPassDepthAttachmentDescriptor DepthAttachment { get; set; }
    public virtual MTLRenderPassStencilAttachmentDescriptor StencilAttachment { get; set; }
    public virtual IMTLBuffer VisibilityResultBuffer { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    public static MTLRenderPassDescriptor CreateRenderPassDescriptor ();
    protected override void Dispose (bool disposing);
}

New Type MonoTouch.Metal.MTLRenderPassStencilAttachmentDescriptor

public class MTLRenderPassStencilAttachmentDescriptor : MonoTouch.Metal.MTLRenderPassAttachmentDescriptor, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPassStencilAttachmentDescriptor ();
    public MTLRenderPassStencilAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPassStencilAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPassStencilAttachmentDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual uint ClearStencil { get; set; }
}

New Type MonoTouch.Metal.MTLRenderPipelineColorAttachmentDescriptor

public class MTLRenderPipelineColorAttachmentDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLRenderPipelineColorAttachmentDescriptor ();
    public MTLRenderPipelineColorAttachmentDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLRenderPipelineColorAttachmentDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLRenderPipelineColorAttachmentDescriptor (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 MTLPixelFormat PixelFormat { 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);
}

New Type MonoTouch.Metal.MTLRenderPipelineColorAttachmentDescriptorArray

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

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 MTLRenderPipelineColorAttachmentDescriptorArray ColorAttachments { get; }
    public virtual MTLPixelFormat DepthAttachmentPixelFormat { get; set; }
    public virtual IMTLFunction FragmentFunction { get; set; }
    public virtual string Label { get; set; }
    public virtual bool RasterizationEnabled { get; set; }
    public virtual uint SampleCount { get; set; }
    public virtual MTLPixelFormat StencilAttachmentPixelFormat { get; set; }
    public virtual MTLVertexDescriptor VertexDescriptor { get; set; }
    public virtual IMTLFunction VertexFunction { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    protected override void Dispose (bool disposing);
    public virtual void Reset ();
}

New Type MonoTouch.Metal.MTLRenderPipelineError

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

New Type MonoTouch.Metal.MTLRenderPipelineReflection

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

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.MTLStructMember

public class MTLStructMember : MonoTouch.Foundation.NSObject, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLStructMember ();
    public MTLStructMember (MonoTouch.Foundation.NSCoder coder);
    public MTLStructMember (MonoTouch.Foundation.NSObjectFlag t);
    public MTLStructMember (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLDataType DataType { get; }
    public virtual string Name { get; }
    public virtual uint Offset { get; }
    // methods
    public virtual MTLArrayType ArrayType ();
    public virtual MTLStructType StructType ();
}

New Type MonoTouch.Metal.MTLStructType

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

New Type MonoTouch.Metal.MTLTexture_Extensions

public static class MTLTexture_Extensions {
    // methods
    public static void GetBytes (IMTLTexture This, System.IntPtr pixelBytes, uint bytesPerRow, uint bytesPerImage, MTLRegion region, uint level, uint slice);
    public static void GetBytes (IMTLTexture This, System.IntPtr pixelBytes, uint bytesPerRow, MTLRegion region, uint level);
    public static void ReplaceRegion (IMTLTexture This, MTLRegion region, uint level, uint slice, System.IntPtr pixelBytes, uint bytesPerRow, uint bytesPerImage);
    public static void ReplaceRegion (IMTLTexture This, MTLRegion region, uint level, System.IntPtr pixelBytes, uint bytesPerRow);
}

New Type MonoTouch.Metal.MTLTextureDescriptor

public 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.MTLVertexAttribute

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

New Type MonoTouch.Metal.MTLVertexAttributeDescriptor

public class MTLVertexAttributeDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLVertexAttributeDescriptor ();
    public MTLVertexAttributeDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLVertexAttributeDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLVertexAttributeDescriptor (System.IntPtr handle);
    // properties
    public virtual uint BufferIndex { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLVertexFormat Format { get; set; }
    public virtual uint Offset { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Metal.MTLVertexAttributeDescriptorArray

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

New Type MonoTouch.Metal.MTLVertexBufferLayoutDescriptor

public class MTLVertexBufferLayoutDescriptor : MonoTouch.Foundation.NSObject, MonoTouch.Foundation.INSCopying, MonoTouch.ObjCRuntime.INativeObject, System.IDisposable {
    // constructors
    public MTLVertexBufferLayoutDescriptor ();
    public MTLVertexBufferLayoutDescriptor (MonoTouch.Foundation.NSCoder coder);
    public MTLVertexBufferLayoutDescriptor (MonoTouch.Foundation.NSObjectFlag t);
    public MTLVertexBufferLayoutDescriptor (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLVertexStepFunction StepFunction { get; set; }
    public virtual uint StepRate { get; set; }
    public virtual uint Stride { get; set; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
}

New Type MonoTouch.Metal.MTLVertexBufferLayoutDescriptorArray

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

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 virtual MTLVertexAttributeDescriptorArray Attributes { get; }
    public override System.IntPtr ClassHandle { get; }
    public virtual MTLVertexBufferLayoutDescriptorArray Layouts { get; }
    // methods
    public virtual MonoTouch.Foundation.NSObject Copy (MonoTouch.Foundation.NSZone zone);
    public static MTLVertexDescriptor Create ();
    protected override void Dispose (bool disposing);
    public virtual void Reset ();
}

New Type MonoTouch.Metal.MTLVertexFormat

[Serializable]
public enum MTLVertexFormat {
    Char2 = 4,
    Char2Normalized = 10,
    Char3 = 5,
    Char3Normalized = 11,
    Char4 = 6,
    Char4Normalized = 12,
    Float = 28,
    Float2 = 29,
    Float3 = 30,
    Float4 = 31,
    Half2 = 25,
    Half3 = 26,
    Half4 = 27,
    Int = 32,
    Int1010102Normalized = 40,
    Int2 = 33,
    Int3 = 34,
    Int4 = 35,
    Invalid = 0,
    Short2 = 16,
    Short2Normalized = 22,
    Short3 = 17,
    Short3Normalized = 23,
    Short4 = 18,
    Short4Normalized = 24,
    UChar2 = 1,
    UChar2Normalized = 7,
    UChar3 = 2,
    UChar3Normalized = 8,
    UChar4 = 3,
    UChar4Normalized = 9,
    UInt = 36,
    UInt1010102Normalized = 41,
    UInt2 = 37,
    UInt3 = 38,
    UInt4 = 39,
    UShort2 = 13,
    UShort2Normalized = 19,
    UShort3 = 14,
    UShort3Normalized = 20,
    UShort4 = 15,
    UShort4Normalized = 21,
}

New Type MonoTouch.Metal.MTLVertexStepFunction

[Serializable]
public enum MTLVertexStepFunction {
    Constant = 0,
    PerInstance = 2,
    PerVertex = 1,
}

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 (MonoTouch.Foundation.NSCoder coder);
    public NCWidgetController (MonoTouch.Foundation.NSObjectFlag t);
    public NCWidgetController (System.IntPtr handle);
    // properties
    public override System.IntPtr ClassHandle { get; }
    // methods
    public static NCWidgetController GetWidgetController ();
    public virtual void SetHasContent (bool flag, string bundleID);
}

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 string BurstIdentifier { get; }
    public virtual PHAssetBurstSelectionType BurstSelectionTypes { get; }
    public override System.IntPtr ClassHandle { 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 (string burstIdentifier, PHFetchOptions options);
    public static PHFetchResult FetchAssets (PHAssetCollection assetCollection, PHFetchOptions options);
    public static PHFetchResult FetchAssets (MonoTouch.Foundation.NSUrl[] assetUrls, PHFetchOptions options);
    public static PHFetchResult FetchAssets (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 RevertAssetContentToOriginal ();
}

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 (PHObject[] assets);
    public static PHAssetCollectionChangeRequest ChangeRequest (PHAssetCollection assetCollection);
    public static PHAssetCollectionChangeRequest ChangeRequest (PHAssetCollection assetCollection, PHFetchResult assets);
    public static PHAssetCollectionChangeRequest CreateAssetCollection (string title);
    public static void DeleteAssetCollections (PHAssetCollection[] assetCollections);
    protected override void Dispose (bool disposing);
    public virtual void InsertAssets (PHObject[] assets, MonoTouch.Foundation.NSIndexSet indexes);
    public virtual void MoveAssets (MonoTouch.Foundation.NSIndexSet fromIndexes, uint toIndex);
    public virtual void RemoveAssets (PHObject[] assets);
    public virtual void RemoveAssets (MonoTouch.Foundation.NSIndexSet indexes);
    public virtual void ReplaceAssets (MonoTouch.Foundation.NSIndexSet indexes, PHObject[] assets);
}

New Type MonoTouch.Photos.PHAssetCollectionSubtype

[Serializable]
public enum PHAssetCollectionSubtype {
    AlbumCloudShared = 101,
    AlbumImported = 6,
    AlbumRegular = 2,
    AlbumSyncedAlbum = 5,
    AlbumSyncedEvent = 3,
    AlbumSyncedFaces = 4,
    Any = 2147483647,
    SmartAlbumAllHidden = 205,
    SmartAlbumBursts = 207,
    SmartAlbumFavorites = 203,
    SmartAlbumGeneric = 200,
    SmartAlbumPanoramas = 201,
    SmartAlbumRecentlyAdded = 206,
    SmartAlbumSlomoVideos = 208,
    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]
public enum PHAssetEditOperation {
    Content = 2,
    Delete = 1,
    None = 0,
    Properties = 3,
}

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 (double progress, MonoTouch.Foundation.NSError error, out bool stop, MonoTouch.Foundation.NSDictionary info, 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, MonoTouch.Foundation.NSDictionary info);
}

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.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, MonoTouch.Foundation.NSDictionary info, 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, MonoTouch.Foundation.NSDictionary info);
}

New Type MonoTouch.Photos.PHAuthorizationStatus

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

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]
public enum PHCollectionEditOperation {
    AddContent = 3,
    CreateContent = 4,
    Delete = 6,
    DeleteContent = 1,
    None = 0,
    RearrangeContent = 5,
    RemoveContent = 2,
    Rename = 7,
}

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 PHCollectionListSubtype CollectionListSubtype { 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 FetchCollectionLists (PHCollection collection, PHFetchOptions options);
    public static PHFetchResult FetchCollectionLists (PHCollectionListType type, PHCollectionListSubtype subType, PHFetchOptions options);
    public static PHFetchResult FetchCollectionLists (string[] identifiers, PHFetchOptions options);
    public static PHFetchResult FetchMomentLists (PHCollectionListSubtype subType, PHAssetCollection moment, PHFetchOptions options);
    public static PHFetchResult FetchMomentLists (PHCollectionListSubtype subType, 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.PHCollectionListSubtype

[Serializable]
public enum PHCollectionListSubtype {
    Any = 2147483647,
    MomentListCluster = 1,
    MomentListYear = 2,
    RegularFolder = 100,
    SmartFolderEvents = 200,
    SmartFolderFaces = 201,
}

New Type MonoTouch.Photos.PHCollectionListType

[Serializable]
public enum PHCollectionListType {
    Folder = 2,
    MomentList = 1,
    SmartFolder = 3,
}

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 MonoTouch.CoreImage.CIImageOrientation 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);
    public PHContentEditingOutput (PHObjectPlaceholder placeholderForCreatedAsset);
    // 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 bool IncludeHiddenAssets { 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 int 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);
    public virtual uint CountOfAssetsWithMediaType (PHAssetMediaType mediaType);
    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 int IndexOf (MonoTouch.Foundation.NSObject id);
    public virtual int IndexOf (MonoTouch.Foundation.NSObject id, MonoTouch.Foundation.NSRange range);
    public virtual MonoTouch.Foundation.NSObject ObjectAt (int 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.PHImageDataHandler

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

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 ResultIsDegraded { get; }
    public static MonoTouch.Foundation.NSString ResultIsInCloud { get; }
    public static MonoTouch.Foundation.NSString ResultRequestID { 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 DefaultManager { get; }
    public static System.Drawing.SizeF MaximumSize { get; }
    // methods
    public virtual void CancelImageRequest (int requestID);
    public virtual int RequestAvAsset (PHAsset asset, PHVideoRequestOptions options, PHImageManagerRequestAvAssetHandler resultHandler);
    public virtual int RequestExportSession (PHAsset asset, PHVideoRequestOptions options, string exportPreset, PHImageManagerRequestExportHandler resultHandler);
    public virtual int RequestImageData (PHAsset asset, PHImageRequestOptions options, PHImageDataHandler handler);
    public virtual int RequestImageForAsset (PHAsset asset, System.Drawing.SizeF targetSize, PHImageContentMode contentMode, PHImageRequestOptions options, PHImageResultHandler resultHandler);
    public virtual int 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 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.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 static PHAuthorizationStatus AuthorizationStatus { get; }
    public override System.IntPtr ClassHandle { get; }
    public static PHPhotoLibrary SharedPhotoLibrary { 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 object RegisterChangeObserver (System.Action<PHChange> changeObserver);
    public virtual void RegisterChangeObserver (PHPhotoLibraryChangeObserver observer);
    public static void RequestAuthorization (System.Action<PHAuthorizationStatus> handler);
    public void UnregisterChangeObserver (object registeredToken);
    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 = 3,
    HighQualityFormat = 1,
    MediumQualityFormat = 2,
}

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 {
    // properties
    public virtual bool ShouldShowCancelConfirmation { get; }
    // 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);
    // properties
    public virtual bool ShouldShowCancelConfirmation { get; }
    // 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._SCNShaderModifiers

public static class _SCNShaderModifiers {
}

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 {
    // properties
    public virtual SCNTechnique Technique { get; set; }
}

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 static SCNAction CustomAction (double seconds, SCNActionNodeWithElapsedTimeHandler handler);
    public static SCNAction FadeIn (double durationInSeconds);
    public static SCNAction FadeOpacityBy (float factor, double durationInSeconds);
    public static SCNAction FadeOpacityTo (float opacity, double durationInSeconds);
    public static SCNAction FadeOut (double durationInSeconds);
    public static SCNAction FromJavascript (string script, double seconds);
    public static SCNAction Group (SCNAction[] actions);
    public static SCNAction MoveBy (SCNVector3 delta, double durationInSeconds);
    public static SCNAction MoveBy (float deltaX, float deltaY, float deltaZ, double durationInSeconds);
    public static SCNAction MoveTo (SCNVector3 location, double durationInSeconds);
    public static SCNAction RemoveFromParentNode ();
    public static SCNAction RepeatAction (SCNAction action, uint count);
    public static SCNAction RepeatActionForever (SCNAction action);
    public virtual SCNAction ReversedAction ();
    public static SCNAction RotateBy (float angle, SCNVector3 axis, double durationInSeconds);
    public static SCNAction RotateBy (float xAngle, float yAngle, float zAngle, double durationInSeconds);
    public static SCNAction RotateTo (float xAngle, float yAngle, float zAngle, double durationInSeconds);
    public static SCNAction RotateTo (float xAngle, float yAngle, float zAngle, double durationInSeconds, bool shortestUnitArc);
    public static SCNAction RotateTo (SCNVector4 axisAngle, double durationInSeconds);
    public static SCNAction Run (System.Action<SCNNode> handler, MonoTouch.CoreFoundation.DispatchQueue queue);
    public static SCNAction Run (System.Action<SCNNode> handler);
    public static SCNAction ScaleBy (float scale, double durationInSeconds);
    public static SCNAction ScaleTo (float scale, double durationInSeconds);
    public static SCNAction Sequence (SCNAction[] actions);
    public virtual void SetTimingFunction (System.Action<float> timingFunction);
    public static SCNAction Wait (double durationInSeconds);
    public static SCNAction Wait (double durationInSeconds, double durationRange);
}

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.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.SCNAntialiasingMode

[Serializable]
public enum SCNAntialiasingMode {
    Multisampling2X = 1,
    Multisampling4X = 2,
    None = 0,
}

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 virtual float Aperture { get; set; }
    public virtual bool AutomaticallyAdjustsZRange { get; set; }
    public virtual uint CategoryBitMask { get; set; }
    public override System.IntPtr ClassHandle { get; }
    public virtual float FocalBlurRadius { get; set; }
    public virtual float FocalDistance { get; set; }
    public virtual float FocalSize { get; set; }
    public virtual string Name { get; set; }
    public virtual double OrthographicScale { get; set; }
    public virtual SCNMatrix4 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 SCNShaderModifiers ShaderModifiers { get; set; }
    public virtual uint SubdivisionLevel { get; set; }
    public virtual MonoTouch.Foundation.NSDictionary WeakShaderModifiers { 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, Syst