Removed:

 	public const string Version = "5.4.0";

Added:

 	public const string Version = "5.99.4";
 	public const string StoreKitLibrary = "/System/Library/Frameworks/StoreKit.framework/StoreKit";
 	public const string MediaToolboxLibrary = "/System/Library/Frameworks/MediaToolbox.framework/MediaToolbox";
 	public const string PassKitLibrary = "/System/Library/Frameworks/PassKit.framework/PassKit";
 	public const string SocialLibrary = "/System/Library/Frameworks/Social.framework/Social";

Added:

 	public virtual AVTimedMetadataGroup[] GetChapterMetadataGroupsBestMatchingPreferredLanguages (string [] languages);
 	public virtual AVAssetReferenceRestrictions ReferenceRestrictions {
 		get;
 	}
 	public virtual AVAssetResourceLoader ResourceLoader {
 		get;
 	}

Added:

 	public static void DetermineCompatibilityOfExportPreset (string presetName, AVAsset asset, string outputFileType, Action<bool> isCompatibleResult);
 	public static AVAssetExportSession FromAsset (AVAsset asset, string presetName);
 	public virtual void DetermineCompatibleFileTypes (Action<string []> compatibleFileTypesHandler);

Added:

 	public virtual AVAsset Asset {
 		get;
 	}

Removed:

 	public static AVAssetReaderAudioMixOutput FromTracks (AVAssetTrack[] audioTracks, MonoTouch.Foundation.NSDictionary audioSettings);
 	public virtual MonoTouch.Foundation.NSDictionary AudioSettings {

Added:

 	public AVAssetReaderAudioMixOutput (AVAssetTrack[] audioTracks, AudioSettings settings);
 	[Obsolete("Use Create method")]
	public static AVAssetReaderAudioMixOutput FromTracks (AVAssetTrack[] audioTracks, MonoTouch.Foundation.NSDictionary audioSettings);
 	public AVAssetReaderAudioMixOutput Create (AVAssetTrack[] audioTracks, AudioSettings settings);
 	[Obsolete("Use Settings property")]
	public virtual MonoTouch.Foundation.NSDictionary AudioSettings {
 	public AudioSettings Settings {
 		get;
 	}

Removed:

 	public static AVAssetReaderTrackOutput FromTrack (AVAssetTrack track, MonoTouch.Foundation.NSDictionary outputSettings);

Added:

 	public AVAssetReaderTrackOutput (AVAssetTrack track, AudioSettings settings);
 	public AVAssetReaderTrackOutput (AVAssetTrack track, AVVideoSettingsUncompressed settings);
 	public static AVAssetReaderTrackOutput Create (AVAssetTrack track, AudioSettings settings);
 	public static AVAssetReaderTrackOutput Create (AVAssetTrack track, AVVideoSettingsUncompressed settings);
 	[Obsolete("Use Create method")]
	public static AVAssetReaderTrackOutput FromTrack (AVAssetTrack track, MonoTouch.Foundation.NSDictionary outputSettings);

Removed:

 	public AVAssetReaderVideoCompositionOutput (AVAssetTrack[] videoTracks, AVVideoSettings videoSettings);
 	public AVAssetReaderVideoCompositionOutput FromTracks (AVAssetTrack[] videoTracks, AVVideoSettings videoSettings);
 	public virtual AVAssetReaderVideoCompositionOutput WeakFromTracks (AVAssetTrack[] videoTracks, MonoTouch.Foundation.NSDictionary videoSettings);
 	public AVVideoSettings VideoSettings {

Added:

 	[Obsolete("Use overload with PixelBufferAttributes")]
	public AVAssetReaderVideoCompositionOutput (AVAssetTrack[] videoTracks, AVVideoSettings videoSettings);
 	public AVAssetReaderVideoCompositionOutput (AVAssetTrack[] videoTracks, MonoTouch.CoreVideo.CVPixelBufferAttributes settings);
 	public AVAssetReaderVideoCompositionOutput Create (AVAssetTrack[] videoTracks, MonoTouch.CoreVideo.CVPixelBufferAttributes settings);
 	[Obsolete("Use Create method or constructor")]
	public AVAssetReaderVideoCompositionOutput FromTracks (AVAssetTrack[] videoTracks, AVVideoSettings videoSettings);
 	[Obsolete("Use Create method")]
	public virtual AVAssetReaderVideoCompositionOutput WeakFromTracks (AVAssetTrack[] videoTracks, MonoTouch.Foundation.NSDictionary videoSettings);
 	public MonoTouch.CoreVideo.CVPixelBufferAttributes UncompressedVideoSettings {
 		get;
 	}
 	[Obsolete("Use UncompressedVideoSettings property")]
	public AVVideoSettings VideoSettings {

public class AVAssetResourceLoader : MonoTouch.Foundation.NSObject {
public AVAssetResourceLoader ();
public AVAssetResourceLoader (MonoTouch.Foundation.NSCoder coder);
public AVAssetResourceLoader (MonoTouch.Foundation.NSObjectFlag t);
public AVAssetResourceLoader (IntPtr handle);

protected override void Dispose (bool disposing);
public virtual void SetDelegate (AVAssetResourceLoaderDelegate resourceLoaderDelegate, MonoTouch.CoreFoundation.DispatchQueue delegateQueue);

public override IntPtr ClassHandle {
	get;
}
public virtual AVAssetResourceLoaderDelegate Delegate {
	get;
}
public virtual MonoTouch.CoreFoundation.DispatchQueue DelegateQueue {
	get;
}

}

public abstract class AVAssetResourceLoaderDelegate : MonoTouch.Foundation.NSObject {
public AVAssetResourceLoaderDelegate ();
public AVAssetResourceLoaderDelegate (MonoTouch.Foundation.NSCoder coder);
public AVAssetResourceLoaderDelegate (MonoTouch.Foundation.NSObjectFlag t);
public AVAssetResourceLoaderDelegate (IntPtr handle);

public abstract bool ShouldWaitForLoadingOfRequestedResource (AVAssetResourceLoader resourceLoader, AVAssetResourceLoadingRequest loadingRequest);

}

public class AVAssetResourceLoadingRequest : MonoTouch.Foundation.NSObject {
public AVAssetResourceLoadingRequest ();
public AVAssetResourceLoadingRequest (MonoTouch.Foundation.NSCoder coder);
public AVAssetResourceLoadingRequest (MonoTouch.Foundation.NSObjectFlag t);
public AVAssetResourceLoadingRequest (IntPtr handle);

protected override void Dispose (bool disposing);
public virtual void FinishLoading (MonoTouch.Foundation.NSUrlResponse usingResponse, MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSUrlRequest redirect);
public virtual void FinishLoadingWithError (MonoTouch.Foundation.NSError error);
public virtual MonoTouch.Foundation.NSData GetStreamingContentKey (MonoTouch.Foundation.NSData appIdentifier, MonoTouch.Foundation.NSData contentIdentifier, MonoTouch.Foundation.NSDictionary options, out MonoTouch.Foundation.NSError error);

public override IntPtr ClassHandle {
	get;
}
public virtual bool Finished {
	get;
}
public virtual MonoTouch.Foundation.NSUrlRequest Request {
	get;
}

}

Removed:

 	public virtual bool CanApplyOutputSettings (MonoTouch.Foundation.NSDictionary outputSettings, string toMediaType);
 	public virtual bool FinishWriting ();

Added:

 	public bool CanApplyOutputSettings (AudioSettings outputSettings, string mediaType);
 	public bool CanApplyOutputSettings (AVVideoSettingsCompressed outputSettings, string mediaType);
 	public virtual bool CanApplyOutputSettings (MonoTouch.Foundation.NSDictionary outputSettings, string mediaType);
 	[Obsolete("This is a synchronous methods, use the asynchronous FinishWriting(NSAction completionHandler) instead")]
	public virtual bool FinishWriting ();
 	public virtual void FinishWriting (MonoTouch.Foundation.NSAction completionHandler);

Removed:

 	public static AVAssetWriterInput FromType (string mediaType, MonoTouch.Foundation.NSDictionary outputSettings);

Added:

 	protected AVAssetWriterInput (string mediaType, MonoTouch.Foundation.NSDictionary outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public AVAssetWriterInput (string mediaType, AudioSettings outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public AVAssetWriterInput (string mediaType, AVVideoSettingsCompressed outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public AVAssetWriterInput (string mediaType, AudioSettings outputSettings);
 	public AVAssetWriterInput (string mediaType, AVVideoSettingsCompressed outputSettings);
 	public static AVAssetWriterInput Create (string mediaType, AudioSettings outputSettings);
 	public static AVAssetWriterInput Create (string mediaType, AudioSettings outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public static AVAssetWriterInput Create (string mediaType, AVVideoSettingsCompressed outputSettings);
 	public static AVAssetWriterInput Create (string mediaType, AVVideoSettingsCompressed outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	[Obsolete("Use constructor or Create method")]
	public static AVAssetWriterInput FromType (string mediaType, MonoTouch.Foundation.NSDictionary outputSettings);
 	public virtual MonoTouch.CoreMedia.CMFormatDescription SourceFormatHint {
 		get;
 	}

Removed:

 	public static AVAssetWriterInputPixelBufferAdaptor FromInput (AVAssetWriterInput input, MonoTouch.Foundation.NSDictionary sourcePixelBufferAttributes);

Added:

 	public AVAssetWriterInputPixelBufferAdaptor (AVAssetWriterInput input, MonoTouch.CoreVideo.CVPixelBufferAttributes attributes);
 	public static AVAssetWriterInputPixelBufferAdaptor Create (AVAssetWriterInput input, MonoTouch.CoreVideo.CVPixelBufferAttributes attributes);
 	[Obsolete("Use Create method")]
	public static AVAssetWriterInputPixelBufferAdaptor FromInput (AVAssetWriterInput input, MonoTouch.Foundation.NSDictionary sourcePixelBufferAttributes);
 	public MonoTouch.CoreVideo.CVPixelBufferAttributes Attributes {
 		get;
 	}
 	public virtual MonoTouch.CoreVideo.CVPixelBufferPool PixelBufferPool {
 		get;
 	}

Added:

 	public virtual MonoTouch.MediaToolbox.MTAudioProcessingTap AudioTapProcessor {
 		get;
 	}

Removed:

 	public AVAudioPlayerSettings Settings {

Added:

 	public virtual AVAudioSessionChannelDescription[] ChannelAssignments {
 		get;
 		set;
 	}
 	[Obsolete("Use SoundSettings")]
	public AVAudioPlayerSettings Settings {
 		get;
 	}
 	public AudioSettings SoundSetting {
 	protected virtual MonoTouch.Foundation.NSDictionary WeakSettings {
 		get;
 	}

Removed:

 	public virtual void EndInterruption (AVAudioPlayer player);

Added:

 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void EndInterruption (AVAudioPlayer player);

Removed:

 	[Obsolete("Use the factory AVAudioRecorder.ToUrl as this method had an invalid signature up to MonoTouch 1.4.4")]
	public AVAudioRecorder (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, MonoTouch.Foundation.NSError outError);
 	public static AVAudioRecorder ToUrl (MonoTouch.Foundation.NSUrl url, AVAudioRecorderSettings settings, out MonoTouch.Foundation.NSError error);
 	public static AVAudioRecorder ToUrl (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, out MonoTouch.Foundation.NSError error);
 	public virtual MonoTouch.Foundation.NSDictionary Settings {

Added:

 	[Obsolete("Use static Create method as this method had an invalid signature up to MonoTouch 1.4.4")]
	public AVAudioRecorder (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, MonoTouch.Foundation.NSError outError);
 	public static AVAudioRecorder Create (MonoTouch.Foundation.NSUrl url, AudioSettings settings, out MonoTouch.Foundation.NSError error);
 	[Obsolete("Use Create method")]
	public static AVAudioRecorder ToUrl (MonoTouch.Foundation.NSUrl url, AVAudioRecorderSettings settings, out MonoTouch.Foundation.NSError error);
 	[Obsolete("Use Create method")]
	public static AVAudioRecorder ToUrl (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, out MonoTouch.Foundation.NSError error);
 	public virtual void RecordAt (double time);
 	public virtual void RecordAt (double time, float duration);
 	public AudioSettings AudioSettings {
 		get;
 	}
 	public virtual AVAudioSessionChannelDescription[] ChannelAssignments {
 		get;
 		set;
 	}
 	public virtual double DeviceCurrentTime {
 		get;
 	}
 	[Obsolete("Use AudioSettings")]
	public virtual MonoTouch.Foundation.NSDictionary Settings {

Removed:

 	public virtual void EndInterruption (AVAudioRecorder recorder);

Added:

 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void EndInterruption (AVAudioRecorder recorder);

Removed:

 	public bool SetActive (bool beActive, AVAudioSessionFlags flags, out MonoTouch.Foundation.NSError outError);
 	public bool SetActive (bool beActive, out MonoTouch.Foundation.NSError outError);
 	public bool SetCategory (MonoTouch.Foundation.NSString theCategory, out MonoTouch.Foundation.NSError outError);
 	[Obsolete("Use SetPreferredHardwareSampleRate(bool, out NSError) instead")]
	public bool SetPreferredHardwareSampleRate (double sampleRate, MonoTouch.Foundation.NSError outError);
 	public bool SetPreferredHardwareSampleRate (double sampleRate, out MonoTouch.Foundation.NSError outError);
 	public bool SetPreferredIOBufferDuration (double duration, out MonoTouch.Foundation.NSError outError);
 	public virtual int currentHardwareInputNumberOfChannels {
 	public virtual int CurrentHardwareOutputNumberOfChannels {
 	public virtual double CurrentHardwareSampleRate {
 	public AVAudioSessionDelegate Delegate {
 	public virtual bool InputIsAvailable {
 	public virtual double PreferredHardwareSampleRate {

Added:

 	public virtual bool OverrideOutputAudioPort (AVAudioSessionPortOverride portOverride, out MonoTouch.Foundation.NSError outError);
 	[Obsolete("Obsolete in iOS 6.0, use SetActive (bool, AVAudioSessionSetActiveOptions, out NSError) instead")]
	public virtual bool SetActive (bool beActive, AVAudioSessionFlags flags, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetActive (bool active, AVAudioSessionSetActiveOptions options, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetActive (bool beActive, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetCategory (MonoTouch.Foundation.NSString theCategory, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetCategory (string category, AVAudioSessionCategoryOptions options, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetInputDataSource (AVAudioSessionDataSourceDescription dataSource, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetInputGain (float gain, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetOutputDataSource (AVAudioSessionDataSourceDescription dataSource, out MonoTouch.Foundation.NSError outError);
 	[Obsolete("Use SetPreferredSampleRate(bool, out NSError) on iOS 6.0 instead")]
	public bool SetPreferredHardwareSampleRate (double sampleRate, MonoTouch.Foundation.NSError outError);
 	[Obsolete("Obsoleted in iOS 6.0, use SetPreferredSampleRate")]
	public virtual bool SetPreferredHardwareSampleRate (double sampleRate, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetPreferredIOBufferDuration (double duration, out MonoTouch.Foundation.NSError outError);
 	public virtual bool SetPreferredSampleRate (double sampleRate, out MonoTouch.Foundation.NSError error);
 	public static MonoTouch.Foundation.NSString CategoryMultiRoute {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString InterruptionNotification {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString MediaServicesWereResetNotification {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString ModeMoviePlayback {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortAirPlay {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortBluetoothA2DP {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortBluetoothHfp {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortBuiltInMic {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortBuiltInReceiver {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortBuiltInSpeaker {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortHdmi {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortHeadphones {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortHeadsetMic {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortLineIn {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortLineOut {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PortUsbAudio {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString RouteChangeNotification {
 		get;
 	}
 	public virtual AVAudioSessionCategoryOptions CategoryOptions {
 		get;
 	}
 	[Obsolete("Deprecated in iOS 6.0, use InputNumberOfChannels instead")]
	public virtual int CurrentHardwareInputNumberOfChannels {
 	[Obsolete("Deprecated in iOS 6.0, use OutputNumberOfChannels instead")]
	public virtual int CurrentHardwareOutputNumberOfChannels {
 	[Obsolete("Deprecated in iOS 6.0, use SampleRate instead")]
	public virtual double CurrentHardwareSampleRate {
 	public virtual AVAudioSessionRouteDescription CurrentRoute {
 		get;
 	}
 	[Obsolete("AVAudioSession.Delegate is deprecated on iOS 6.0, use AVAudioSession.Notification.Observe* methods instead")]
	public AVAudioSessionDelegate Delegate {
 	public virtual bool InputAvailable {
 		get;
 	}
 	public virtual AVAudioSessionDataSourceDescription InputDataSource {
 		get;
 	}
 	public virtual AVAudioSessionDataSourceDescription[] InputDataSources {
 		get;
 	}
 	public virtual float InputGain {
 		get;
 	}
 	public virtual bool InputGainSettable {
 		get;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool InputIsAvailable {
 		get;
 	}
 	public virtual double InputLatency {
 		get;
 	}
 	public virtual int InputNumberOfChannels {
 		get;
 	}
 	public virtual double IOBufferDuration {
 	public virtual bool OtherAudioPlaying {
 		get;
 	}
 	public virtual AVAudioSessionDataSourceDescription OutputDataSource {
 		get;
 	}
 	public virtual AVAudioSessionDataSourceDescription[] OutputDataSources {
 		get;
 	}
 	public virtual double OutputLatency {
 		get;
 	}
 	public virtual int OutputNumberOfChannels {
 		get;
 	}
 	public virtual float OutputVolume {
 		get;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual double PreferredHardwareSampleRate {
 	public virtual double PreferredSampleRate {
 		get;
 	}
 	public virtual double SampleRate {
 		get;
 	}
public static class Notifications {
	
	public static MonoTouch.Foundation.NSObject ObserveInterruption (EventHandler<AVAudioSessionInterruptionEventArgs> handler);
	public static MonoTouch.Foundation.NSObject ObserveMediaServicesWereReset (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
	public static MonoTouch.Foundation.NSObject ObserveRouteChange (EventHandler<AVAudioSessionRouteChangeEventArgs> handler);
}

[Serializable]
[Flags]
public enum AVAudioSessionCategoryOptions {
	MixWithOthers,
	DuckOthers,
	AllowBluetooth,
	DefaultToSpeaker
}

public class AVAudioSessionChannelDescription : MonoTouch.Foundation.NSObject {
public AVAudioSessionChannelDescription ();
public AVAudioSessionChannelDescription (MonoTouch.Foundation.NSCoder coder);
public AVAudioSessionChannelDescription (MonoTouch.Foundation.NSObjectFlag t);
public AVAudioSessionChannelDescription (IntPtr handle);

public virtual string ChannelName {
	get;
}
public virtual int ChannelNumber {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual string OwningPortUID {
	get;
}

}

public class AVAudioSessionDataSourceDescription : MonoTouch.Foundation.NSObject {
public AVAudioSessionDataSourceDescription ();
public AVAudioSessionDataSourceDescription (MonoTouch.Foundation.NSCoder coder);
public AVAudioSessionDataSourceDescription (MonoTouch.Foundation.NSObjectFlag t);
public AVAudioSessionDataSourceDescription (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSNumber DataSourceID {
	get;
}
public virtual string DataSourceName {
	get;
}

}

public class AVAudioSessionInterruptionEventArgs : MonoTouch.Foundation.NSNotificationEventArgs {
public AVAudioSessionInterruptionEventArgs (MonoTouch.Foundation.NSNotification notification);

public AVAudioSessionInterruptionType InterruptionType {
	get;
}
public AVAudioSessionInterruptionOptions Option {
	get;
}

}

[Serializable]
[Flags]
public enum AVAudioSessionInterruptionOptions {
	ShouldResume
}

[Serializable]
public enum AVAudioSessionInterruptionType {
	Ended,
	Began
}

public class AVAudioSessionPortDescription : MonoTouch.Foundation.NSObject {
public AVAudioSessionPortDescription ();
public AVAudioSessionPortDescription (MonoTouch.Foundation.NSCoder coder);
public AVAudioSessionPortDescription (MonoTouch.Foundation.NSObjectFlag t);
public AVAudioSessionPortDescription (IntPtr handle);

protected override void Dispose (bool disposing);

public virtual AVAudioSessionChannelDescription[] Channels {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual string PortName {
	get;
}
public virtual MonoTouch.Foundation.NSString PortType {
	get;
}
public virtual string UID {
	get;
}

}

[Serializable]
public enum AVAudioSessionPortOverride {
	None,
	Speaker
}

public class AVAudioSessionRouteChangeEventArgs : MonoTouch.Foundation.NSNotificationEventArgs {
public AVAudioSessionRouteChangeEventArgs (MonoTouch.Foundation.NSNotification notification);

public AVAudioSessionRouteDescription PreviousRoute {
	get;
}
public AVAudioSessionRouteChangeReason Reason {
	get;
}

}

[Serializable]
public enum AVAudioSessionRouteChangeReason {
	Unknown,
	NewDeviceAvailable,
	OldDeviceUnavailable,
	CategoryChange,
	Override,
	WakeFromSleep,
	NoSuitableRouteForCategory
}

public class AVAudioSessionRouteDescription : MonoTouch.Foundation.NSObject {
public AVAudioSessionRouteDescription ();
public AVAudioSessionRouteDescription (MonoTouch.Foundation.NSCoder coder);
public AVAudioSessionRouteDescription (MonoTouch.Foundation.NSObjectFlag t);
public AVAudioSessionRouteDescription (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual AVAudioSessionPortDescription[] Inputs {
	get;
}
public virtual AVAudioSessionPortDescription[] Outputs {
	get;
}

}

[Serializable]
[Flags]
public enum AVAudioSessionSetActiveOptions {
	NotifyOthersOnDeactivation
}

Added:

 	public virtual void DidDropSampleBuffer (AVCaptureOutput captureOutput, MonoTouch.CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);

Added:

 	public virtual bool AutomaticallyAdjustsVideoMirroring {
 		get;
 		set;
 	}
 	public virtual bool EnablesVideoStabilizationWhenAvailable {
 		get;
 		set;
 	}
 	public virtual bool SupportsVideoStabilization {
 		get;
 	}
 	public virtual AVCaptureVideoPreviewLayer VideoPreviewLayer {
 		get;
 	}
 	public virtual bool VideoStabilizationEnabled {
 		get;
 	}

Added:

 	public virtual bool SetTorchModeLevel (float torchLevel, out MonoTouch.Foundation.NSError outError);
 	public static float MaxAvailableTorchLevel {
 		get;
 	}
 	public virtual bool AutomaticallyEnablesLowLightBoostWhenAvailable {
 		get;
 		set;
 	}
 	public virtual bool LowLightBoostEnabled {
 		get;
 	}
 	public virtual bool LowLightBoostSupported {
 		get;
 	}
 	public virtual bool TorchActive {
 		get;
 	}

[Serializable]
public enum AVCaptureDeviceTransportControlsPlaybackMode {
	NotPlaying,
	Playing
}

Added:

 	public virtual MonoTouch.CoreMedia.CMFormatDescription FormatDescription {
 		get;
 	}

public class AVCaptureMetadataOutput : AVCaptureOutput {
public AVCaptureMetadataOutput ();
public AVCaptureMetadataOutput (MonoTouch.Foundation.NSCoder coder);
public AVCaptureMetadataOutput (MonoTouch.Foundation.NSObjectFlag t);
public AVCaptureMetadataOutput (IntPtr handle);

protected override void Dispose (bool disposing);
public virtual void SetDelegate (AVCaptureMetadataOutputObjectsDelegate objectsDelegate, MonoTouch.CoreFoundation.DispatchQueue objectsCallbackQueue);

public virtual MonoTouch.Foundation.NSString[] AvailableMetadataObjectTypes {
	get;
}
public virtual MonoTouch.CoreFoundation.DispatchQueue CallbackQueue {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual AVCaptureMetadataOutputObjectsDelegate Delegate {
	get;
}
public virtual MonoTouch.Foundation.NSArray MetadataObjectTypes {
	get;
	set;
}

}

public class AVCaptureMetadataOutputObjectsDelegate : MonoTouch.Foundation.NSObject {
public AVCaptureMetadataOutputObjectsDelegate ();
public AVCaptureMetadataOutputObjectsDelegate (MonoTouch.Foundation.NSCoder coder);
public AVCaptureMetadataOutputObjectsDelegate (MonoTouch.Foundation.NSObjectFlag t);
public AVCaptureMetadataOutputObjectsDelegate (IntPtr handle);

public virtual void DidOutputMetadataObjects (AVCaptureMetadataOutput captureOutput, AVMetadataObject[] metadataObjects, AVCaptureConnection connection);

}

Added:

 	public virtual AVMetadataObject GetTransformedMetadataObject (AVMetadataObject metadataObject, AVCaptureConnection connection);

Added:

 	public AVVideoSettingsCompressed CompressedVideoSetting {
 		get;
 		set;
 	}
 	public AVVideoSettingsUncompressed UncompressedVideoSetting {
 		get;
 		set;
 	}

Removed:

 	public AVVideoSettings VideoSettings {

Added:

 	public AVVideoSettingsCompressed CompressedVideoSetting {
 		get;
 		set;
 	}
 	public AVVideoSettingsUncompressed UncompressedVideoSetting {
 		get;
 		set;
 	}
 	[Obsolete("Use Compressed or Uncompressed property")]
	public AVVideoSettings VideoSettings {

Removed:

 	public virtual bool AutomaticallyAdjustsMirroring {
 	public virtual bool Mirrored {
 	public virtual bool MirroringSupported {
 	public virtual AVCaptureVideoOrientation Orientation {
 	public virtual bool OrientationSupported {
 	public virtual string VideoGravity {

Added:

 	public virtual System.Drawing.PointF CaptureDevicePointOfInterestForPoint (System.Drawing.PointF pointInLayer);
 	public virtual AVMetadataObject GetTransformedMetadataObject (AVMetadataObject metadataObject);
 	public virtual System.Drawing.PointF PointForCaptureDevicePointOfInterest (System.Drawing.PointF captureDevicePointOfInterest);
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool AutomaticallyAdjustsMirroring {
 	public virtual AVCaptureConnection Connection {
 		get;
 	}
 	public AVLayerVideoGravity LayerVideoGravity {
 		get;
 		set;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool Mirrored {
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool MirroringSupported {
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual AVCaptureVideoOrientation Orientation {
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool OrientationSupported {
 	[Obsolete("Use LayerVideoGravity")]
	public virtual string VideoGravity {
 		get;
 		set;
 	}
 	protected virtual MonoTouch.Foundation.NSString WeakVideoGravity {

Removed:

 	DecodeFailed,
 	FileAlreadyExists,
 	ContentIsProtected,
 	FailedToParse,
 	FormatNotRecognized,
 	MediaServicesWereReset,
 	InvalidOutputURLPathExtension

Added:

 	MediaServicesWereReset,
 	DecodeFailed,
 	FileAlreadyExists,
 	FormatNotRecognized,
 	FailedToParse,
 	ContentIsProtected,
 	ApplicationIsNotAuthorized,
 	ReferenceForbiddenByReferencePolicy,
 	InvalidOutputURLPathExtension,
 	ScreenCaptureFailed,
 	DisplayWasDisabled,
 	TorchLevelUnavailable,
 	OperationInterrupted,
 	IncompatibleAsset,
 	FailedToLoadMediaData,
 	ServerIncorrectlyConfigured

Removed:

 public class AVFileType {
public AVFileType ();

Added:

 public static class AVFileType {

[Serializable]
public enum AVLayerVideoGravity {
	ResizeAspect,
	ResizeAspectFill,
	Resize
}

Removed:

 public class AVMediaCharacteristic {
public AVMediaCharacteristic ();

Added:

 public static class AVMediaCharacteristic {
 	public static MonoTouch.Foundation.NSString EasyToRead {
 		get;
 	}

Removed:

 	public static AVMediaSelectionOption[] MediaSelectionOptionsExcludingCharacteristics (MonoTouch.Foundation.NSArray array, MonoTouch.Foundation.NSString[] avmediaCharacteristics);

Added:

 	public static AVMediaSelectionOption[] MediaSelectionOptionsExcludingCharacteristics (AVMediaSelectionOption[] source, MonoTouch.Foundation.NSString[] avmediaCharacteristics);

Removed:

 public class AVMediaType {
public AVMediaType ();

Added:

 public static class AVMediaType {
 	public static MonoTouch.Foundation.NSString Metadata {
 		get;
 	}

Removed:

 public class AVMetadata {
public AVMetadata ();

Added:

 public static class AVMetadata {

public class AVMetadataFaceObject : AVMetadataObject {
public AVMetadataFaceObject ();
public AVMetadataFaceObject (MonoTouch.Foundation.NSCoder coder);
public AVMetadataFaceObject (MonoTouch.Foundation.NSObjectFlag t);
public AVMetadataFaceObject (IntPtr handle);

public override IntPtr ClassHandle {
	get;
}
public virtual int FaceID {
	get;
}
public virtual bool HasRollAngle {
	get;
}
public virtual bool HasYawAngle {
	get;
}
public virtual float RollAngle {
	get;
}
public virtual float YawAngle {
	get;
}

}

Removed:

 	public static AVMetadataItem[] FilterWithKey (AVMetadataItem[] array, MonoTouch.Foundation.NSObject key, string keySpace);

Added:

 	public static AVMetadataItem[] FilterFromPreferredLanguages (AVMetadataItem[] metadataItems, string [] preferredLanguages);
 	public static AVMetadataItem[] FilterWithKey (AVMetadataItem[] metadataItems, MonoTouch.Foundation.NSObject key, string keySpace);

public class AVMetadataObject : MonoTouch.Foundation.NSObject {
public AVMetadataObject (MonoTouch.Foundation.NSCoder coder);
public AVMetadataObject (MonoTouch.Foundation.NSObjectFlag t);
public AVMetadataObject (IntPtr handle);

public static MonoTouch.Foundation.NSString TypeFace {
	get;
}
public virtual System.Drawing.RectangleF Bounds {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.CoreMedia.CMTime Duration {
	get;
}
public virtual MonoTouch.CoreMedia.CMTime Time {
	get;
}
public virtual string Type {
	get;
}

}

Added:

 	public virtual MonoTouch.MediaToolbox.MTAudioProcessingTap AudioTapProcessor {
 		get;
 		set;
 	}

Removed:

 	public virtual bool AirPlayVideoActive {
 	public virtual bool AllowsAirPlayVideo {
 	public virtual bool UsesAirPlayVideoWhileAirPlayScreenIsActive {

Added:

 	public virtual void CancelPendingPrerolls ();
 	public virtual void Preroll (float rate, AVCompletion onComplete);
 	public virtual void Seek (MonoTouch.Foundation.NSDate date);
 	public virtual void Seek (MonoTouch.Foundation.NSDate date, AVCompletion onComplete);
 	public virtual void SetRate (float rate, MonoTouch.CoreMedia.CMTime itemTime, MonoTouch.CoreMedia.CMTime hostClockTime);
 	[Obsolete("Obsoleted in iOS6, use ExternalPlaybackActive")]
	public virtual bool AirPlayVideoActive {
 	[Obsolete("Obsoleted in iOS6, use AllowsExternalPlayback")]
	public virtual bool AllowsAirPlayVideo {
 		get;
 		set;
 	}
 	public virtual bool AllowsExternalPlayback {
 	public virtual bool ExternalPlaybackActive {
 		get;
 	}
 	public Nullable<AVLayerVideoGravity> ExternalPlaybackVideoGravity {
 		get;
 		set;
 	}
 	public virtual MonoTouch.CoreMedia.CMClock MasterClock {
 		get;
 	}
 	public virtual bool OutputObscuredDueToInsufficientExternalProtection {
 		get;
 	}
 	[Obsolete("Obsoleted in iOS6, use UsesExternalPlaybackWhileExternalScreenIsActive")]
	public virtual bool UsesAirPlayVideoWhileAirPlayScreenIsActive {
 		get;
 		set;
 	}
 	public virtual bool UsesExternalPlaybackWhileExternalScreenIsActive {
 		get;
 		set;
 	}
 	protected virtual MonoTouch.Foundation.NSString WeakExternalPlaybackVideoGravity {

Added:

 	public virtual void AddOutput (AVPlayerItemOutput output);
 	public virtual void RemoveOutput (AVPlayerItemOutput output);
 	public virtual bool Seek (MonoTouch.Foundation.NSDate date, AVCompletion completion);
 	public static MonoTouch.Foundation.NSString NewAccessLogEntryNotification {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString NewErrorLogEntryNotification {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString PlaybackStalledNotification {
 		get;
 	}
 	public virtual bool CanPlayReverse {
 		get;
 	}
 	public virtual bool CanPlaySlowForward {
 		get;
 	}
 	public virtual bool CanPlaySlowReverse {
 		get;
 	}
 	public virtual bool CanStepBackward {
 		get;
 	}
 	public virtual bool CanStepForward {
 		get;
 	}
 	public virtual MonoTouch.CoreMedia.CMTime Duration {
 		get;
 	}
 	public virtual AVPlayerItemOutput Outputs {
 		get;
 	}
 	public virtual bool SeekingWaitsForVideoCompositionRendering {
 		get;
 		set;
 	}
 	public virtual AVTextStyleRule[] TextStyleRules {
 		get;
 		set;
 	}
 	public virtual MonoTouch.CoreMedia.CMTimebase Timebase {
 		get;
 	}
 		public static MonoTouch.Foundation.NSObject ObserveNewAccessLogEntry (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
 		public static MonoTouch.Foundation.NSObject ObserveNewErrorLogEntry (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
 		public static MonoTouch.Foundation.NSObject ObservePlaybackStalled (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);

Added:

 	public virtual int NumberOfMediaRequests {
 		get;
 	}

public class AVPlayerItemOutput : MonoTouch.Foundation.NSObject {
public AVPlayerItemOutput (MonoTouch.Foundation.NSCoder coder);
public AVPlayerItemOutput (MonoTouch.Foundation.NSObjectFlag t);
public AVPlayerItemOutput (IntPtr handle);

public virtual MonoTouch.CoreMedia.CMTime GetItemTime (double hostTimeInSeconds);
public virtual MonoTouch.CoreMedia.CMTime GetItemTime (long machAbsoluteTime);

public override IntPtr ClassHandle {
	get;
}
public virtual bool SuppressesPlayerRendering {
	get;
	set;
}

}

public class AVPlayerItemOutputPullDelegate : MonoTouch.Foundation.NSObject {
public AVPlayerItemOutputPullDelegate ();
public AVPlayerItemOutputPullDelegate (MonoTouch.Foundation.NSCoder coder);
public AVPlayerItemOutputPullDelegate (MonoTouch.Foundation.NSObjectFlag t);
public AVPlayerItemOutputPullDelegate (IntPtr handle);

public virtual void OutputMediaDataWillChange (AVPlayerItemOutput sender);
public virtual void OutputSequenceWasFlushed (AVPlayerItemOutput output);

}

public class AVPlayerItemVideoOutput : AVPlayerItemOutput {
public AVPlayerItemVideoOutput ();
public AVPlayerItemVideoOutput (MonoTouch.Foundation.NSCoder coder);
public AVPlayerItemVideoOutput (MonoTouch.Foundation.NSObjectFlag t);
public AVPlayerItemVideoOutput (IntPtr handle);
protected AVPlayerItemVideoOutput (MonoTouch.Foundation.NSDictionary pixelBufferAttributes);
public AVPlayerItemVideoOutput (MonoTouch.CoreVideo.CVPixelBufferAttributes attributes);

public virtual MonoTouch.CoreVideo.CVPixelBuffer CopyPixelBuffer (MonoTouch.CoreMedia.CMTime itemTime, ref MonoTouch.CoreMedia.CMTime outItemTimeForDisplay);
protected override void Dispose (bool disposing);
public virtual bool HasNewPixelBufferForItemTime (MonoTouch.CoreMedia.CMTime itemTime);
public virtual void RequestNotificationOfMediaDataChange (double advanceInterval);
public virtual void SetDelegate (AVPlayerItemOutputPullDelegate delegateClass, MonoTouch.CoreFoundation.DispatchQueue delegateQueue);

public override IntPtr ClassHandle {
	get;
}
public AVPlayerItemOutputPullDelegate Delegate {
	get;
}
public virtual MonoTouch.CoreFoundation.DispatchQueue DelegateQueue {
	get;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
}

}

Removed:

 	public virtual string VideoGravity {

Added:

 	public AVLayerVideoGravity LayerVideoGravity {
 		get;
 		set;
 	}
 	[Obsolete("Use LayerVideoGravity")]
	public virtual string VideoGravity {
 		get;
 		set;
 	}
 	protected virtual MonoTouch.Foundation.NSString WeakVideoGravity {

public class AVTextStyleRule : MonoTouch.Foundation.NSObject {
public AVTextStyleRule ();
public AVTextStyleRule (MonoTouch.Foundation.NSCoder coder);
public AVTextStyleRule (MonoTouch.Foundation.NSObjectFlag t);
public AVTextStyleRule (IntPtr handle);
protected AVTextStyleRule (MonoTouch.Foundation.NSDictionary textMarkupAttributes);
public AVTextStyleRule (MonoTouch.CoreMedia.CMTextMarkupAttributes attributes);
protected AVTextStyleRule (MonoTouch.Foundation.NSDictionary textMarkupAttributes, string textSelector);
public AVTextStyleRule (MonoTouch.CoreMedia.CMTextMarkupAttributes attributes, string textSelector);

public static AVTextStyleRule[] FromPropertyList (MonoTouch.Foundation.NSObject plist);
public static AVTextStyleRule FromTextMarkupAttributes (MonoTouch.CoreMedia.CMTextMarkupAttributes textMarkupAttributes);
public static AVTextStyleRule FromTextMarkupAttributes (MonoTouch.CoreMedia.CMTextMarkupAttributes textMarkupAttributes, string textSelector);
public static MonoTouch.Foundation.NSObject ToPropertyList (AVTextStyleRule[] textStyleRules);
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public MonoTouch.CoreMedia.CMTextMarkupAttributes TextMarkupAttributes {
	get;
}
public virtual string TextSelector {
	get;
}
protected virtual MonoTouch.Foundation.NSDictionary WeakTextMarkupAttributes {
	get;
}

}

Removed:

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

Added:

 	public AVUrlAsset (MonoTouch.Foundation.NSUrl url, AVUrlAssetOptions options);
 	public static AVUrlAsset Create (MonoTouch.Foundation.NSUrl url, AVUrlAssetOptions options);
 	[Obsolete("Use Create or constructor")]
	public static AVUrlAsset FromUrl (MonoTouch.Foundation.NSUrl URL, MonoTouch.Foundation.NSDictionary options);
 	public static MonoTouch.Foundation.NSString ReferenceRestrictionsKey {
 		get;
 	}
 	public virtual AVAssetResourceLoader ResourceLoader {
 		get;
 	}

public class AVUrlAssetOptions : MonoTouch.Foundation.DictionaryContainer {
public AVUrlAssetOptions ();
public AVUrlAssetOptions (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<bool> PreferPreciseDurationAndTiming {
	get;
	set;
}
public Nullable<avassetreferencerestrictions> ReferenceRestrictions {
	get;
	set;
}

}

Removed:

 public class AVVideo {
public AVVideo ();

Added:

 public static class AVVideo {
 	public static MonoTouch.Foundation.NSString ProfileLevelH264High40 {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString ProfileLevelH264High41 {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString ScalingModeKey {
 		get;
 	}

public class AVVideoCleanApertureSettings : MonoTouch.Foundation.DictionaryContainer {
public AVVideoCleanApertureSettings ();
public AVVideoCleanApertureSettings (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<int> Height {
	get;
	set;
}
public Nullable<int> HorizontalOffset {
	get;
	set;
}
public Nullable<int> VerticalOffset {
	get;
	set;
}
public Nullable<int> Width {
	get;
	set;
}

}

[Serializable]
public enum AVVideoCodec {
	H264,
	JPEG
}

public class AVVideoCodecSettings : MonoTouch.Foundation.DictionaryContainer {
public AVVideoCodecSettings ();
public AVVideoCodecSettings (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<int> AverageBitRate {
	get;
	set;
}
public Nullable<float> JPEGQuality {
	get;
	set;
}
public Nullable<int> MaxKeyFrameInterval {
	get;
	set;
}
public AVVideoPixelAspectRatioSettings PixelAspectRatio {
	set;
}
public Nullable<avvideoprofilelevelh264> ProfileLevelH264 {
	set;
}
public AVVideoCleanApertureSettings VideoCleanAperture {
	set;
}

}

Added:

 	public static AVVideoComposition FromAssetProperties (AVAsset asset);

[Serializable]
public enum AVVideoFieldMode {
	Both,
	TopOnly,
	BottomOnly,
	Deinterlace
}

public class AVVideoPixelAspectRatioSettings : MonoTouch.Foundation.DictionaryContainer {
public AVVideoPixelAspectRatioSettings ();
public AVVideoPixelAspectRatioSettings (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<int> HorizontalSpacing {
	get;
	set;
}
public Nullable<int> VerticalSpacing {
	get;
	set;
}

}

[Serializable]
public enum AVVideoProfileLevelH264 {
	Baseline30,
	Baseline31,
	Baseline41,
	Main30,
	Main31,
	Main32,
	Main41,
	High40,
	High41
}

[Serializable]
public enum AVVideoScalingMode {
	Fit,
	Resize,
	ResizeAspect,
	ResizeAspectFill
}

public static class AVVideoScalingModeKey {
public static MonoTouch.Foundation.NSString Fit {
	get;
}
public static MonoTouch.Foundation.NSString Resize {
	get;
}
public static MonoTouch.Foundation.NSString ResizeAspect {
	get;
}
public static MonoTouch.Foundation.NSString ResizeAspectFill {
	get;
}

}

Removed:

 	public AVVideoSettings (MonoTouch.CoreVideo.CVPixelFormatType formatType);
 	public MonoTouch.Foundation.NSDictionary ToDictionary ();
 	public System.Nullable<MonoTouch.CoreVideo.CVPixelFormatType> PixelFormat {

Added:

 	[Obsolete("Use PixelBufferAttributes")]
	public AVVideoSettings (MonoTouch.CoreVideo.CVPixelFormatType formatType);
 	[Obsolete("Use PixelBufferAttributes")]
	public MonoTouch.Foundation.NSDictionary ToDictionary ();
 	[Obsolete("Use PixelBufferAttributes")]
	public System.Nullable<MonoTouch.CoreVideo.CVPixelFormatType> PixelFormat {

public class AVVideoSettingsCompressed : MonoTouch.Foundation.DictionaryContainer {
public AVVideoSettingsCompressed ();
public AVVideoSettingsCompressed (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<avvideocodec> Codec {
	set;
}
public AVVideoCodecSettings CodecSettings {
	set;
}
public Nullable<int> Height {
	get;
	set;
}
public Nullable<avvideoscalingmode> ScalingMode {
	set;
}
public Nullable<int> Width {
	get;
	set;
}

}

public class AVVideoSettingsUncompressed : MonoTouch.CoreVideo.CVPixelBufferAttributes {
public AVVideoSettingsUncompressed ();
public AVVideoSettingsUncompressed (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<avvideoscalingmode> ScalingMode {
	set;
}

}

public class AudioSettings : MonoTouch.Foundation.DictionaryContainer {
public AudioSettings ();
public AudioSettings (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<avaudioquality> AudioQuality {
	get;
	set;
}
public MonoTouch.AudioToolbox.AudioChannelLayout ChannelLayout {
	set;
}
public Nullable<int> EncoderBitDepthHint {
	get;
	set;
}
public Nullable<int> EncoderBitRate {
	get;
	set;
}
public Nullable<int> EncoderBitRatePerChannel {
	get;
	set;
}
public System.Nullable<monotouch.audiotoolbox.audioformattype> Format {
	get;
	set;
}
public Nullable<bool> LinearPcmBigEndian {
	get;
	set;
}
public Nullable<int> LinearPcmBitDepth {
	get;
	set;
}
public Nullable<bool> LinearPcmFloat {
	get;
	set;
}
public Nullable<bool> LinearPcmNonInterleaved {
	get;
	set;
}
public Nullable<int> NumberChannels {
	get;
	set;
}
public Nullable<float> SampleRate {
	get;
	set;
}
public Nullable<avaudioquality> SampleRateConverterAudioQuality {
	get;
	set;
}

}
</monotouch.audiotoolbox.audioformattype>

Removed:

 	public ACAccountCredential (string token, string secret);

Added:

 	public ACAccountCredential (string oauthToken, string tokenSecret);
 	public ACAccountCredential (string oauth2Token, string refreshToken, MonoTouch.Foundation.NSDate expiryDate);
 	public virtual string OAuthToken {
 		get;
 		set;
 	}

[Serializable]
public enum ACAccountCredentialRenewResult {
	Renewed,
	Rejected,
	Failed
}

Removed:

 	public virtual void RequestAccess (ACAccountType accountType, ACRequestCompletionHandler completionHandler);

Added:

 	public virtual void RenewCredentials (ACAccount account, System.Action<ACAccountCredentialRenewResult,MonoTouch.Foundation.NSError> completionHandler);
 	[Obsolete("Obsolete in iOS 6.0. Use overload with options instead")]
	public virtual void RequestAccess (ACAccountType accountType, ACRequestCompletionHandler completionHandler);
 	public void RequestAccess (ACAccountType accountType, AccountStoreOptions options, ACRequestCompletionHandler completion);
 	protected virtual void RequestAccess (ACAccountType accountType, MonoTouch.Foundation.NSDictionary options, ACRequestCompletionHandler completion);

Added:

 	public static MonoTouch.Foundation.NSString Facebook {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString SinaWeibo {
 		get;
 	}

Removed:

 	PermissionDenied

Added:

 	PermissionDenied,
 	AccessInfoInvalid

[Serializable]
public enum ACFacebookAudience {
	Everyone,
	Friends,
	OnlyMe
}

public static class ACFacebookAudienceValue {
public static MonoTouch.Foundation.NSString Everyone {
	get;
}
public static MonoTouch.Foundation.NSString Friends {
	get;
}
public static MonoTouch.Foundation.NSString OnlyMe {
	get;
}

}

public static class ACFacebookKey {
public static MonoTouch.Foundation.NSString AppId {
	get;
}
public static MonoTouch.Foundation.NSString Audience {
	get;
}
public static MonoTouch.Foundation.NSString Permissions {
	get;
}

}

public class AccountStoreOptions : MonoTouch.Foundation.DictionaryContainer {
public AccountStoreOptions ();
public AccountStoreOptions (MonoTouch.Foundation.NSDictionary dictionary);

public void SetPermissions (ACFacebookAudience audience, params string [] permissions);

public string FacebookAppId {
	get;
	set;
}

}

public class ASIdentifierManager : MonoTouch.Foundation.NSObject {
public ASIdentifierManager (MonoTouch.Foundation.NSCoder coder);
public ASIdentifierManager (MonoTouch.Foundation.NSObjectFlag t);
public ASIdentifierManager (IntPtr handle);

protected override void Dispose (bool disposing);

public static ASIdentifierManager SharedManager {
	get;
}
public virtual MonoTouch.Foundation.NSUuid AdvertisingIdentifier {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual bool IsAdvertisingTrackingEnabled {
	get;
}

}

Removed:

 	public ABAddressBook ();

Added:

 	[Obsolete("Use static Create method in iOS 6.0")]
	public ABAddressBook ();
 	public static ABAddressBook Create (out MonoTouch.Foundation.NSError error);
 	public static ABAuthorizationStatus GetAuthorizationStatus ();
 	public void RequestAccess (System.Action<bool,MonoTouch.Foundation.NSError> onCompleted);

Removed:

 	OperationNotPermittedByStore

Added:

 	OperationNotPermittedByStore,
 	OperationNotPermittedByUserError

[Serializable]
public enum ABAuthorizationStatus {
	NotDetermined,
	Restricted,
	Denied,
	Authorized
}

Removed:

 	public ABMultiValue`1 GetAddresses ();
 	public ABMultiValue`1 GetInstantMessages ();
 	public ABMultiValue`1 GetSocialProfile ();

Added:

 	[Obsolete("Use GetAllAddresses")]
	public ABMultiValue`1 GetAddresses ();
 	public ABMultiValue`1 GetAllAddresses ();
 	[Obsolete("Use GetInstantMessageServices")]
	public ABMultiValue`1 GetInstantMessages ();
 	public ABMultiValue`1 GetInstantMessageServices ();
 	[Obsolete("Use GetSocialProfiles")]
	public ABMultiValue`1 GetSocialProfile ();
 	public ABMultiValue`1 GetSocialProfiles ();
 	public void SetAddresses (ABMultiValue`1 addresses);
 	public void SetInstantMessages (ABMultiValue`1 services);
 	public void SetSocialProfile (ABMultiValue`1 profiles);

Added:

 	public static MonoTouch.Foundation.NSString Facebook {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString GaduGadu {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString GoogleTalk {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString QQ {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString Skype {
 		get;
 	}

public static class ABPersonSocialProfileService {
public static readonly MonoTouch.Foundation.NSString Twitter;
public static readonly MonoTouch.Foundation.NSString GameCenter;
public static readonly MonoTouch.Foundation.NSString Facebook;
public static readonly MonoTouch.Foundation.NSString Myspace;
public static readonly MonoTouch.Foundation.NSString LinkedIn;
public static readonly MonoTouch.Foundation.NSString Flickr;
public static readonly MonoTouch.Foundation.NSString SinaWeibo;

}

public class InstantMessageService : MonoTouch.Foundation.DictionaryContainer {
public InstantMessageService ();
public InstantMessageService (MonoTouch.Foundation.NSDictionary dictionary);

public MonoTouch.Foundation.NSString Service {
	set;
}
public string ServiceName {
	get;
	set;
}
public string Username {
	get;
	set;
}

}

public class PersonAddress : MonoTouch.Foundation.DictionaryContainer {
public PersonAddress ();
public PersonAddress (MonoTouch.Foundation.NSDictionary dictionary);

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

}

public class SocialProfile : MonoTouch.Foundation.DictionaryContainer {
public SocialProfile ();
public SocialProfile (MonoTouch.Foundation.NSDictionary dictionary);

public MonoTouch.Foundation.NSString Service {
	set;
}
public string ServiceName {
	get;
	set;
}
public string Url {
	get;
	set;
}
public string UserIdentifier {
	get;
	set;
}
public string Username {
	get;
	set;
}

}

Added:

 	public MonoTouch.Foundation.NSUrl AssetUrl {
 		get;
 	}

Added:

 	public static void DisableSharedPhotoStreamsSupport ();
 	public static ALAuthorizationStatus AuthorizationStatus {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString DeletedAssetGroupsKey {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString InsertedAssetGroupsKey {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString UpdatedAssetGroupsKey {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString UpdatedAssetsKey {
 		get;
 	}

[Serializable]
public enum ALAuthorizationStatus {
	NotDetermined,
	Restricted,
	Denied,
	Authorized
}

Removed:

 	AES3,
 	MPEG4AAC_ELD,
 	MPEG4AAC_ELD_V2

Added:

 	MPEG4AAC_ELD,
 	MPEG4AAC_ELD_SBR,
 	MPEG4AAC_ELD_V2,
 	AES3

Added:

 	public AudioQueueStatus EnqueueBuffer (AudioQueueBuffer* audioQueueBuffer, int bytes, AudioStreamPacketDescription[] desc, int trimFramesAtStart, int trimFramesAtEnd, AudioQueueParameterEvent[] parameterEvents, ref AudioTimeStamp startTime, out AudioTimeStamp actualStartTime);
 	public AudioQueueStatus EnqueueBuffer (IntPtr audioQueueBuffer, int bytes, AudioStreamPacketDescription[] desc, int trimFramesAtStart, int trimFramesAtEnd, AudioQueueParameterEvent[] parameterEvents, ref AudioTimeStamp startTime, out AudioTimeStamp actualStartTime);

Removed:

 	AUiPodTime

Added:

 	Varispeed,
 	DeferredRenderer,
 	Splitter,
 	Merger,
 	NewTimePitch,
 	AUiPodTime,
 	AUiPodTimeOther

Removed:

 	AUiPodEQ

Added:

 	PeakLimiter,
 	DynamicsProcessor,
 	LowPassFilter,
 	HighPassFilter,
 	HighShelfFilter,
 	LowShelfFilter,
 	DCFilter,
 	ParametricEQ,
 	Delay,
 	Distortion,
 	BandPassFilter,
 	AUiPodEQ,
 	Reverb2,
 	NBandEq

Added:

 	Matrix,

Added:

 	CPULoad,
 	ParameterValueStrings,
 	HostCallbacks,
 	OfflineRender,
 	DependentParameters,
 	InputSampleInOutput,
 	ParameterHistoryInfo,
 	Nickname,

Added:

 	public virtual bool DrawsAsynchronously {
 		get;
 		set;
 	}

[Serializable]
public enum CBATTError {
	Success,
	InvalidHandle,
	ReadNotPermitted,
	WriteNotPermitted,
	InvalidPdu,
	InsufficientAuthentication,
	RequestNotSupported,
	InvalidOffset,
	InsufficientAuthorization,
	PrepareQueueFull,
	AttributeNotFound,
	AttributeNotLong,
	InsufficientEncryptionKeySize,
	InvalidAttributeValueLength,
	UnlikelyError,
	InsufficientEncryption,
	UnsupportedGroupType,
	InsufficientResources
}

public class CBATTRequest : MonoTouch.Foundation.NSObject {
public CBATTRequest ();
public CBATTRequest (MonoTouch.Foundation.NSCoder coder);
public CBATTRequest (MonoTouch.Foundation.NSObjectFlag t);
public CBATTRequest (IntPtr handle);

protected override void Dispose (bool disposing);

public virtual CBCentral Central {
	get;
}
public virtual CBCharacteristic Characteristic {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual int Offset {
	get;
}
public virtual MonoTouch.Foundation.NSData Value {
	get;
	set;
}

}

public class CBATTRequestEventArgs : EventArgs {
public CBATTRequestEventArgs (CBATTRequest request);

public CBATTRequest Request {
	get;
	set;
}

}

public class CBATTRequestsEventArgs : EventArgs {
public CBATTRequestsEventArgs (CBATTRequest[] requests);

public CBATTRequest[] Requests {
	get;
	set;
}

}

Removed:

 public class CBAdvertisement {
public CBAdvertisement ();

Added:

 public static class CBAdvertisement {
 	public static MonoTouch.Foundation.NSString DataOverflowServiceUUIDsKey {
 		get;
 	}

[Serializable]
[Flags]
public enum CBAttributePermissions {
	Readable,
	Writeable,
	ReadEncryptionRequired,
	WriteEncryptionRequired
}

public class CBCentral : MonoTouch.Foundation.NSObject {
public CBCentral (MonoTouch.Foundation.NSCoder coder);
public CBCentral (MonoTouch.Foundation.NSObjectFlag t);
public CBCentral (IntPtr handle);

public override IntPtr ClassHandle {
	get;
}
public virtual IntPtr UUID {
	get;
}

}

Removed:

 	public CBCentralManager (CBCentralManagerDelegate cbDelegate, MonoTouch.CoreFoundation.DispatchQueue queue);

Added:

 	public CBCentralManager (CBCentralManagerDelegate centralDelegate, MonoTouch.CoreFoundation.DispatchQueue queue);
 	public static MonoTouch.Foundation.NSString OptionNotifyOnConnectionKey {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString OptionNotifyOnNotificationKey {
 		get;
 	}
public event EventHandler<CBPeripheralEventArgs> ConnectedPeripheral;
public event EventHandler<CBPeripheralErrorEventArgs> DisconnectedPeripheral;
public event EventHandler<CBDiscoveredPeripheralEventArgs> DiscoveredPeripheral;
public event EventHandler<CBPeripheralErrorEventArgs> FailedToConnectPeripheral;
public event EventHandler<CBPeripheralsEventArgs> RetrievedConnectedPeripherals;
public event EventHandler<CBPeripheralsEventArgs> RetrievedPeripherals;
public event EventHandler UpdatedState;

Removed:

 	public abstract void ConnectedPeripheral (CBCentralManager central, CBPeripheral peripheral);
 	public abstract void DisconnectedPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSError error);
 	public abstract void DiscoveredPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSDictionary advertisementData, MonoTouch.Foundation.NSNumber RSSI);
 	public abstract void FailedToConnectPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSError error);
 	public abstract void RetrievedConnectedPeripherals (CBCentralManager central, CBPeripheral peripherals);
 	public abstract void RetrievedPeripherals (CBCentralManager central, CBPeripheral[] peripherals);

Added:

 	public virtual void ConnectedPeripheral (CBCentralManager central, CBPeripheral peripheral);
 	public virtual void DisconnectedPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSError error);
 	public virtual void DiscoveredPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSDictionary advertisementData, MonoTouch.Foundation.NSNumber RSSI);
 	public virtual void FailedToConnectPeripheral (CBCentralManager central, CBPeripheral peripheral, MonoTouch.Foundation.NSError error);
 	public virtual void RetrievedConnectedPeripherals (CBCentralManager central, CBPeripheral[] peripherals);
 	public virtual void RetrievedPeripherals (CBCentralManager central, CBPeripheral[] peripherals);

public class CBCharacteristicEventArgs : EventArgs {
public CBCharacteristicEventArgs (CBCharacteristic characteristic, MonoTouch.Foundation.NSError error);

public CBCharacteristic Characteristic {
	get;
	set;
}
public MonoTouch.Foundation.NSError Error {
	get;
	set;
}

}

Removed:

 	ExtendedProperties

Added:

 	ExtendedProperties,
 	NotifyEncryptionRequired,
 	IndicateEncryptionRequired

public class CBDescriptorEventArgs : EventArgs {
public CBDescriptorEventArgs (CBDescriptor descriptor, MonoTouch.Foundation.NSError error);

public CBDescriptor Descriptor {
	get;
	set;
}
public MonoTouch.Foundation.NSError Error {
	get;
	set;
}

}

public class CBDiscoveredPeripheralEventArgs : EventArgs {
public CBDiscoveredPeripheralEventArgs (CBPeripheral peripheral, MonoTouch.Foundation.NSDictionary advertisementData, MonoTouch.Foundation.NSNumber RSSI);

public MonoTouch.Foundation.NSDictionary AdvertisementData {
	get;
	set;
}
public CBPeripheral Peripheral {
	get;
	set;
}
public MonoTouch.Foundation.NSNumber RSSI {
	get;
	set;
}

}

Removed:

 	ReadNotPermitted,
 	WriteNotPermitted,
 	InvalidPdu,
 	InsufficientAuthentication,
 	RequestNotSupported,
 	InvalidOffset,
 	InsufficientAuthorization,
 	PrepareQueueFull,
 	AttributeNotFound,
 	AttributeNotLong,
 	InsufficientEncryptionKeySize,
 	InvalidAttributeValueLength,
 	UnlikelyError,
 	InsufficientEncryption,
 	UnsupportedGroupType,
 	InsufficientResources

Added:

 	Unknown,
 	InvalidParameters,
 	NotConnected,
 	OutOfSpace,
 	OperationCancelled,
 	ConnectionTimeout,
 	PeripheralDisconnected,
 	UUIDNotAllowed,
 	AlreadyAdvertising

public class CBMutableCharacteristic : CBCharacteristic {
public CBMutableCharacteristic ();
public CBMutableCharacteristic (MonoTouch.Foundation.NSCoder coder);
public CBMutableCharacteristic (MonoTouch.Foundation.NSObjectFlag t);
public CBMutableCharacteristic (IntPtr handle);
public CBMutableCharacteristic (CBUUID uuid, CBCharacteristicProperties properties, MonoTouch.Foundation.NSData value, CBAttributePermissions permissions);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual CBDescriptor[] Descriptors {
	get;
	set;
}
public virtual CBAttributePermissions Permissions {
	get;
	set;
}
public virtual CBCharacteristicProperties Properties {
	get;
	set;
}
public virtual CBUUID UUID {
	get;
}
public virtual MonoTouch.Foundation.NSData Value {
	get;
	set;
}

}

public class CBMutableDescriptor : CBDescriptor {
public CBMutableDescriptor ();
public CBMutableDescriptor (MonoTouch.Foundation.NSCoder coder);
public CBMutableDescriptor (MonoTouch.Foundation.NSObjectFlag t);
public CBMutableDescriptor (IntPtr handle);
public CBMutableDescriptor (CBUUID uuid, IntPtr descriptorValue);

public override IntPtr ClassHandle {
	get;
}

}

public class CBMutableService : CBService {
public CBMutableService ();
public CBMutableService (MonoTouch.Foundation.NSCoder coder);
public CBMutableService (MonoTouch.Foundation.NSObjectFlag t);
public CBMutableService (IntPtr handle);
public CBMutableService (CBUUID uuid, bool primary);

protected override void Dispose (bool disposing);

public virtual CBCharacteristic[] Characteristics {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual CBService[] IncludedServices {
	get;
	set;
}
public virtual bool Primary {
	get;
	set;
}
public virtual CBUUID UUID {
	get;
	set;
}

}

Removed:

 	public virtual void SetNotifyValue (bool notifyValue, CBCharacteristic characteristic);

Added:

 	public virtual void SetNotifyValue (bool enabled, CBCharacteristic characteristic);
public event EventHandler<CBServiceEventArgs> DiscoverCharacteristic;
public event EventHandler<CBCharacteristicEventArgs> DiscoveredDescriptor;
public event EventHandler<CBServiceEventArgs> DiscoveredIncludedService;
public event System.EventHandler<MonoTouch.Foundation.NSErrorEventArgs> DiscoveredService;
public event EventHandler InvalidatedService;
public event System.EventHandler<MonoTouch.Foundation.NSErrorEventArgs> RssiUpdated;
public event EventHandler<CBCharacteristicEventArgs> UpdatedCharacterteristicValue;
public event EventHandler UpdatedName;
public event EventHandler<CBCharacteristicEventArgs> UpdatedNotificationState;
public event EventHandler<CBDescriptorEventArgs> UpdatedValue;
public event EventHandler<CBCharacteristicEventArgs> WroteCharacteristicValue;
public event EventHandler<CBDescriptorEventArgs> WroteDescriptorValue;

Added:

 	public virtual void InvalidatedService (CBPeripheral peripheral);
 	public virtual void UpdatedName (CBPeripheral peripheral);

public class CBPeripheralErrorEventArgs : EventArgs {
public CBPeripheralErrorEventArgs (CBPeripheral peripheral, MonoTouch.Foundation.NSError error);

public MonoTouch.Foundation.NSError Error {
	get;
	set;
}
public CBPeripheral Peripheral {
	get;
	set;
}

}

public class CBPeripheralEventArgs : EventArgs {
public CBPeripheralEventArgs (CBPeripheral peripheral);

public CBPeripheral Peripheral {
	get;
	set;
}

}

public class CBPeripheralManager : MonoTouch.Foundation.NSObject {
public CBPeripheralManager ();
public CBPeripheralManager (MonoTouch.Foundation.NSCoder coder);
public CBPeripheralManager (MonoTouch.Foundation.NSObjectFlag t);
public CBPeripheralManager (IntPtr handle);
public CBPeripheralManager (CBPeripheralManagerDelegate peripheralDelegate, MonoTouch.CoreFoundation.DispatchQueue queue);

public virtual void AddService (CBMutableService service);
protected override void Dispose (bool disposing);
public virtual void RemoveAllServices ();
public virtual void RemoveService (CBMutableService service);
public virtual void RespondToRequest (CBATTRequest request, CBATTError result);
public virtual void SetDesiredConnectionLatency (CBPeripheralManagerConnectionLatency latency, CBCentral connectedCentral);
public void StartAdvertising (StartAdvertisingOptions options);
public virtual void StopAdvertising ();
public virtual bool UpdateValue (MonoTouch.Foundation.NSData value, CBMutableCharacteristic characteristic, CBCentral[] subscribedCentrals);

public virtual bool Advertising {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public CBPeripheralManagerDelegate Delegate {
	get;
	set;
}
public virtual CBPeripheralManagerState State {
	get;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public event System.EventHandler<monotouch.foundation.nserroreventargs> AdvertisingStarted;
public event EventHandler<cbperipheralmanagersubscriptioneventargs> CharacteristicSubscribed;
public event EventHandler<cbperipheralmanagersubscriptioneventargs> CharacteristicUnsubscribed;
public event EventHandler<cbattrequesteventargs> ReadRequestReceived;
public event EventHandler ReadyToUpdateSubscribers;
public event EventHandler<cbperipheralmanagerserviceeventargs> ServiceAdded;
public event EventHandler StateUpdated;
public event EventHandler<cbattrequestseventargs> WriteRequestsReceived;

}
</monotouch.foundation.nserroreventargs>

[Serializable]
public enum CBPeripheralManagerConnectionLatency {
	Low,
	Medium,
	High
}

public abstract class CBPeripheralManagerDelegate : MonoTouch.Foundation.NSObject {
public CBPeripheralManagerDelegate ();
public CBPeripheralManagerDelegate (MonoTouch.Foundation.NSCoder coder);
public CBPeripheralManagerDelegate (MonoTouch.Foundation.NSObjectFlag t);
public CBPeripheralManagerDelegate (IntPtr handle);

public virtual void AdvertisingStarted (CBPeripheralManager peripheral, MonoTouch.Foundation.NSError error);
public virtual void CharacteristicSubscribed (CBPeripheralManager peripheral, CBCentral central, CBCharacteristic characteristic);
public virtual void CharacteristicUnsubscribed (CBPeripheralManager peripheral, CBCentral central, CBCharacteristic characteristic);
public virtual void ReadRequestReceived (CBPeripheralManager peripheral, CBATTRequest request);
public virtual void ReadyToUpdateSubscribers (CBPeripheralManager peripheral);
public virtual void ServiceAdded (CBPeripheralManager peripheral, CBService service, MonoTouch.Foundation.NSError error);
public abstract void StateUpdated (CBPeripheralManager peripheral);
public virtual void WriteRequestsReceived (CBPeripheralManager peripheral, CBATTRequest[] requests);

}

public class CBPeripheralManagerServiceEventArgs : EventArgs {
public CBPeripheralManagerServiceEventArgs (CBService service, MonoTouch.Foundation.NSError error);

public MonoTouch.Foundation.NSError Error {
	get;
	set;
}
public CBService Service {
	get;
	set;
}

}

[Serializable]
public enum CBPeripheralManagerState {
	Unknown,
	Resetting,
	Unsupported,
	Unauthorized,
	PoweredOff,
	PoweredOn
}

public class CBPeripheralManagerSubscriptionEventArgs : EventArgs {
public CBPeripheralManagerSubscriptionEventArgs (CBCentral central, CBCharacteristic characteristic);

public CBCentral Central {
	get;
	set;
}
public CBCharacteristic Characteristic {
	get;
	set;
}

}

public class CBPeripheralsEventArgs : EventArgs {
public CBPeripheralsEventArgs (CBPeripheral[] peripherals);

public CBPeripheral[] Peripherals {
	get;
	set;
}

}

Added:

 	public virtual bool Primary {
 		get;
 	}

public class CBServiceEventArgs : EventArgs {
public CBServiceEventArgs (CBService service, MonoTouch.Foundation.NSError error);

public MonoTouch.Foundation.NSError Error {
	get;
	set;
}
public CBService Service {
	get;
	set;
}

}

public class StartAdvertisingOptions : MonoTouch.Foundation.DictionaryContainer {
public StartAdvertisingOptions ();
public StartAdvertisingOptions (MonoTouch.Foundation.NSDictionary dictionary);

public string LocalName {
	get;
	set;
}
public CBUUID[] ServicesUUID {
	set;
}

}

public class CFAllocator : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
public CFAllocator (IntPtr handle);
public CFAllocator (IntPtr handle, bool owns);

public IntPtr Allocate (long size, CFAllocatorFlags hint);
public void Deallocate (IntPtr ptr);
public void Dispose ();
protected virtual void Dispose (bool disposing);
protected override void Finalize ();

public static CFAllocator Default {
	get;
}
public static CFAllocator Malloc {
	get;
}
public static CFAllocator MallocZone {
	get;
}
public static CFAllocator Null {
	get;
}
public static CFAllocator SystemDefault {
	get;
}
public IntPtr Handle {
	get;
}

}

[Serializable]
[Flags]
public enum CFAllocatorFlags : ulong {
	GCScannedMemory,
	GCObjectMemory
}

Added:

 	public CGPDFPage (IntPtr handle);

Removed:

 	public virtual void DrawImage (CIImage image, System.Drawing.PointF atPoint, System.Drawing.RectangleF fromRect);

Added:

 	[Obsolete("Use DrawImage (CIImage, RectangleF, RectangleF) instead")]
	public virtual void DrawImage (CIImage image, System.Drawing.PointF atPoint, System.Drawing.RectangleF fromRect);

Added:

 	public static CIDetector CreateFaceDetector (CIContext context, bool highAccuracy, float minFeatureSize);

Added:

 	public virtual bool HasTrackingFrameCount {
 		get;
 	}
 	public virtual bool HasTrackingId {
 		get;
 	}
 	public virtual int TrackingFrameCount {
 		get;
 	}
 	public virtual int TrackingId {
 		get;
 	}

Added:

 	public static CIFilter[] FromSerializedXMP (MonoTouch.Foundation.NSData xmpData, System.Drawing.RectangleF extent, out MonoTouch.Foundation.NSError error);
 	public static MonoTouch.Foundation.NSData SerializedXMP (CIFilter[] filters, System.Drawing.RectangleF extent);

Added:

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

Removed:

 	public CIImage (MonoTouch.Foundation.NSData d, int bpr, System.Drawing.SizeF size, int f, MonoTouch.CoreGraphics.CGColorSpace c);
 	public CIImage (int glTextureName, System.Drawing.SizeF size, bool flag, MonoTouch.CoreGraphics.CGColorSpace cs);

Added:

 	public CIImage (MonoTouch.Foundation.NSData d, int bpr, System.Drawing.SizeF size, int f, MonoTouch.CoreGraphics.CGColorSpace colorSpace);
 	public CIImage (int glTextureName, System.Drawing.SizeF size, bool flipped, MonoTouch.CoreGraphics.CGColorSpace colorSpace);

[Serializable]
public enum CLActivityType {
	Other,
	AutomotiveNavigation,
	Fitness,
	OtherNavigation
}

public class CLAuthorizationChangedEventArgs : EventArgs {
public CLAuthorizationChangedEventArgs (CLAuthorizationStatus status);

public CLAuthorizationStatus Status {
	get;
	set;
}

}

Removed:

 public class CLAuthroziationChangedEventArgs : EventArgs {
public CLAuthorizationStatus Status {
	get;
	set;
}

Added:

 [Obsolete]
public class CLAuthroziationChangedEventArgs : CLAuthorizationChangedEventArgs {

Removed:

 	GeocodeCanceled

Added:

 	GeocodeCanceled,
 	DeferredFailed,
 	DeferredNotUpdatingLocation,
 	DeferredAccuracyTooLow,
 	DeferredDistanceFiltered,
 	DeferredCanceled

Removed:

 	public virtual double Distancefrom (CLLocation location);

Added:

 	[Obsolete("Replaced by DistanceFrom")]
	public virtual double Distancefrom (CLLocation location);

public static class CLLocationDistance {
public static double FilterNone {
	get;
}
public static double MaxDistance {
	get;
}

}

Removed:

 	public virtual void StartMonitoring (CLRegion region, double desiredAccuracy);
 	public static bool RegionMonitoringEnabled {
 	public virtual string Purpose {
 	public event EventHandler<CLAuthroziationChangedEventArgs> AuthorizationChanged;

Added:

 	public virtual void AllowDeferredLocationUpdatesUntil (double distance, double timeout);
 	public virtual void DisallowDeferredLocationUpdates ();
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void StartMonitoring (CLRegion region, double desiredAccuracy);
 	public static bool DeferredLocationUpdatesAvailable {
 		get;
 	}
 	public static double MaxTimeInterval {
 		get;
 	}
 	[Obsolete("Replaced by RegionMonitoringAvailable in iOS 6.0")]
	public static bool RegionMonitoringEnabled {
 	public virtual CLActivityType ActivityType {
 		get;
 		set;
 	}
 	public virtual bool PausesLocationUpdatesAutomatically {
 		get;
 		set;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual string Purpose {
 	public event EventHandler<CLAuthorizationChangedEventArgs> AuthorizationChanged;
 	public event System.EventHandler<MonoTouch.Foundation.NSErrorEventArgs> DeferredUpdatesFinished;
 	public event EventHandler<CLLocationsUpdatedEventArgs> LocationsUpdated;
 	public event EventHandler LocationUpdatesPaused;
 	public event EventHandler LocationUpdatesResumed;

Removed:

 	public virtual void UpdatedLocation (CLLocationManager manager, CLLocation newLocation, CLLocation oldLocation);

Added:

 	public virtual void DeferredUpdatesFinished (CLLocationManager manager, MonoTouch.Foundation.NSError error);
 	public virtual void LocationsUpdated (CLLocationManager manager, CLLocation[] locations);
 	public virtual void LocationUpdatesPaused (CLLocationManager manager);
 	public virtual void LocationUpdatesResumed (CLLocationManager manager);
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void UpdatedLocation (CLLocationManager manager, CLLocation newLocation, CLLocation oldLocation);

public class CLLocationsUpdatedEventArgs : EventArgs {
public CLLocationsUpdatedEventArgs (CLLocation[] locations);

public CLLocation[] Locations {
	get;
	set;
}

}

public class CMAudioFormatDescription : CMFormatDescription {
}

Removed:

 	public int CopyDataBytes (uint offsetToData, uint dataLength, IntPtr destination);

Added:

 	public static CMBlockBuffer CreateEmpty (uint subBlockCapacity, CMBlockBufferFlags flags, out CMBlockBufferError error);
 	public CMBlockBufferError CopyDataBytes (uint offsetToData, uint dataLength, IntPtr destination);

[Serializable]
public enum CMBlockBufferError {
	None,
	StructureAllocationFailed,
	BlockAllocationFailed,
	BadCustomBlockSource,
	BadOffsetParameter,
	BadLengthParameter,
	BadPointerParameter,
	EmptyBlockBuffer,
	UnallocatedBlock
}

[Serializable]
[Flags]
public enum CMBlockBufferFlags : uint {
	AssureMemoryNow,
	AlwaysCopyData,
	DontOptimizeDepth,
	PermitEmptyReference
}

public class CMClock : CMClockOrTimebase {
public CMClock (IntPtr handle);

public static ulong ConvertHostTimeToSystemUnits (CMTime hostTime);
public static CMClock CreateAudioClock (out CMClockError clockError);
public static CMTime CreateHostTimeFromSystemUnits (ulong hostTime);
public CMClockError GetAnchorTime (out CMTime clockTime, out CMTime referenceClockTime);
public void Invalidate ();
public bool MightDrift (CMClock otherClock);

public static CMClock HostTimeClock {
	get;
}
public CMTime CurrentTime {
	get;
}

}

[Serializable]
public enum CMClockError {
	None,
	MissingRequiredParameter,
	InvalidParameter,
	AllocationFailed,
	UnsupportedOperation
}

public class CMClockOrTimebase : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
public CMClockOrTimebase (IntPtr handle);

public static CMTime ConvertTime (CMTime time, CMClockOrTimebase from, CMClockOrTimebase to);
public static double GetRelativeRate (CMClockOrTimebase clockOrTimebaseA, CMClockOrTimebase clockOrTimebaseB);
public static CMSyncError GetRelativeRateAndAnchorTime (CMClockOrTimebase clockOrTimebaseA, CMClockOrTimebase clockOrTimebaseB, out double relativeRate, out CMTime timeA, out CMTime timeB);
public static bool MightDrift (CMClockOrTimebase clockOrTimebaseA, CMClockOrTimebase clockOrTimebaseB);
public void Dispose ();
protected virtual void Dispose (bool disposing);
protected override void Finalize ();

public IntPtr Handle {
	get;
}
public CMTime Time {
	get;
}

}

[Serializable]
public enum CMClosedCaptionFormatType : uint {
	CEA608,
	CEA708,
	ATSC
}

Removed:

 	public System.Drawing.RectangleF GetVideoCleanAperture (bool originIsAtTopLeft);
 	public System.Drawing.SizeF GetVideoPresentationDimensions (bool usePixelAspectRatio, bool useCleanAperture);
 	public uint MediaSubType {
 	public System.Drawing.Size VideoDimensions {

Added:

 	public static CMFormatDescription Create (CMMediaType mediaType, uint mediaSubtype, out CMFormatDescriptionError error);
 	[Obsolete("Use CMVideoFormatDescription")]
	public System.Drawing.RectangleF GetVideoCleanAperture (bool originIsAtTopLeft);
 	[Obsolete("Use CMVideoFormatDescription")]
	public System.Drawing.SizeF GetVideoPresentationDimensions (bool usePixelAspectRatio, bool useCleanAperture);
 	public CMClosedCaptionFormatType ClosedCaptionFormatType {
 		get;
 	}
 	[Obsolete("Use specific SubType property")]
	public uint MediaSubType {
 	public CMMetadataFormatType MetadataFormatType {
 		get;
 	}
 	public CMMuxedStreamType MuxedStreamType {
 		get;
 	}
 	public CMSubtitleFormatType SubtitleFormatType {
 		get;
 	}
 	public CMTimeCodeFormatType TimeCodeFormatType {
 		get;
 	}
 	public CMVideoCodecType VideoCodecType {
 		get;
 	}
 	[Obsolete("Use CMVideoFormatDescription")]
	public System.Drawing.Size VideoDimensions {

[Serializable]
public enum CMFormatDescriptionError {
	None,
	InvalidParameter,
	AllocationFailed
}

Removed:

 	TimedMetadata

Added:

 	TimedMetadata,
 	Metadata

public class CMMemoryPool : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
public CMMemoryPool ();
public CMMemoryPool (TimeSpan ageOutPeriod);

public void Dispose ();
protected virtual void Dispose (bool disposing);
protected override void Finalize ();
public void Flush ();
public MonoTouch.CoreFoundation.CFAllocator GetAllocator ();
public void Invalidate ();

public IntPtr Handle {
	get;
}

}

[Serializable]
public enum CMMetadataFormatType : uint {
	ICY,
	ID3,
	Boxed
}

[Serializable]
public enum CMMuxedStreamType : uint {
	MPEG1System,
	MPEG2Transport,
	MPEG2Program,
	DV
}

Removed:

 	public CMFormatDescription GetFormatDescription ();
 	public MonoTouch.Foundation.NSMutableDictionary[] GetSampleAttachments (bool createIfNecessary);

Added:

 	public static CMSampleBuffer CreateForImageBuffer (MonoTouch.CoreVideo.CVImageBuffer imageBuffer, bool dataReady, CMVideoFormatDescription formatDescription, CMSampleTimingInfo sampleTiming, out CMSampleBufferError error);
 	public static CMSampleBuffer CreateWithPacketDescriptions (CMBlockBuffer dataBuffer, CMFormatDescription formatDescription, int samplesCount, CMTime sampleTimestamp, MonoTouch.AudioToolbox.AudioStreamPacketDescription[] packetDescriptions, out CMSampleBufferError error);
 	public CMAudioFormatDescription GetAudioFormatDescription ();
 	[Obsolete("Use GetAudioFormatDescription or GetVideoFormatDescription")]
	public CMFormatDescription GetFormatDescription ();
 	public CMSampleBufferAttachmentSettings[] GetSampleAttachments (bool createIfNecessary);
 	public CMVideoFormatDescription GetVideoFormatDescription ();

public class CMSampleBufferAttachmentSettings : MonoTouch.Foundation.DictionaryContainer {
public Nullable<bool> DependedOnByOthers {
	get;
	set;
}
public Nullable<bool> DependsOnOthers {
	get;
	set;
}
public Nullable<bool> DisplayEmptyMediaImmediately {
	get;
	set;
}
public Nullable<bool> DisplayImmediately {
	get;
	set;
}
public Nullable<bool> DoNotDisplay {
	get;
	set;
}
public Nullable<bool> DrainAfterDecoding {
	get;
	set;
}
public string DroppedFrameReason {
	get;
}
public Nullable<bool> EarlierDisplayTimesAllowed {
	get;
	set;
}
public Nullable<bool> EmptyMedia {
	get;
	set;
}
public Nullable<bool> EndsPreviousSampleDuration {
	get;
	set;
}
public Nullable<bool> FillDiscontinuitiesWithSilence {
	get;
	set;
}
public Nullable<bool> NotSync {
	get;
	set;
}
public Nullable<bool> PartialSync {
	get;
	set;
}
public Nullable<bool> PermanentEmptyMedia {
	get;
	set;
}
public Nullable<bool> RedundantCoding {
	get;
	set;
}
public Nullable<bool> ResetDecoderBeforeDecoding {
	get;
	set;
}
public Nullable<bool> Reverse {
	get;
	set;
}

}

[Serializable]
public enum CMSampleBufferError {
	None,
	AllocationFailed,
	RequiredParameterMissing,
	AlreadyHasDataBuffer,
	BufferNotReady,
	SampleIndexOutOfRange,
	BufferHasNoSampleSizes,
	BufferHasNoSampleTimingInfo,
	ArrayTooSmall,
	InvalidEntryCount,
	CannotSubdivide,
	SampleTimingInfoInvalid,
	InvalidMediaTypeForOperation,
	InvalidSampleData,
	InvalidMediaFormat,
	Invalidated
}

public struct CMSampleTimingInfo {
public CMTime Duration;
public CMTime PresentationTimeStamp;
public CMTime DecodeTimeStamp;

}

[Serializable]
public enum CMSubtitleFormatType : uint {
	Text3G,
	WebVTT
}

[Serializable]
public enum CMSyncError {
	None,
	MissingRequiredParameter,
	InvalidParameter,
	AllocationFailed,
	RateMustBeNonZero
}

public class CMTextMarkupAttributes : MonoTouch.Foundation.DictionaryContainer {
public CMTextMarkupAttributes ();
public CMTextMarkupAttributes (MonoTouch.Foundation.NSDictionary dictionary);

public Nullable<textmarkupcolor> BackgroundColor {
	get;
	set;
}
public Nullable<bool> Bold {
	get;
	set;
}
public string FontFamilyName {
	get;
	set;
}
public Nullable<textmarkupcolor> ForegroundColor {
	get;
	set;
}
public Nullable<bool> Italic {
	get;
	set;
}
public Nullable<int> RelativeFontSize {
	get;
	set;
}
public Nullable<bool> Underline {
	get;
	set;
}

}

[Serializable]
public enum CMTimeCodeFormatType : uint {
	TimeCode32,
	TimeCode64,
	Counter32,
	Counter64
}

public struct CMTimeScale {
public CMTimeScale (int value);

public static readonly CMTimeScale MaxValue;
public int Value;

}

public class CMTimebase : CMClockOrTimebase {
public CMTimebase (IntPtr handle);
public CMTimebase (CMClock masterClock);
public CMTimebase (CMTimebase masterTimebase);

public CMTimebaseError AddTimer (MonoTouch.Foundation.NSTimer timer, MonoTouch.Foundation.NSRunLoop runloop);
public CMClockOrTimebase GetMaster ();
public CMClock GetMasterClock ();
public CMTimebase GetMasterTimebase ();
public CMTime GetTime (CMTimeScale timeScale, CMTimeRoundingMethod roundingMethod);
public CMTimebaseError GetTimeAndRate (out CMTime time, out double rate);
public CMClock GetUltimateMasterClock ();
public CMTimebaseError NotificationBarrier ();
public CMTimebaseError RemoveTimer (MonoTouch.Foundation.NSTimer timer);
public CMTimebaseError SetAnchorTime (CMTime timebaseTime, CMTime immediateMasterTime);
public CMTimebaseError SetRateAndAnchorTime (double rate, CMTime timebaseTime, CMTime immediateMasterTime);
public CMTimebaseError SetTimerNextFireTime (MonoTouch.Foundation.NSTimer timer, CMTime fireTime);
public CMTimebaseError SetTimerToFireImmediately (MonoTouch.Foundation.NSTimer timer);

public double EffectiveRate {
	get;
}
public double Rate {
	get;
	set;
}
public CMTime Time {
	get;
	set;
}

public const double VeryLongTimeInterval = 8073216000;

}

[Serializable]
public enum CMTimebaseError {
	None,
	MissingRequiredParameter,
	InvalidParameter,
	AllocationFailed,
	TimerIntervalTooShort,
	ReadOnly
}

public class CMVideoFormatDescription : CMFormatDescription {
public CMVideoFormatDescription (CMVideoCodecType codecType, System.Drawing.Size size);

public static CMVideoFormatDescription CreateForImageBuffer (MonoTouch.CoreVideo.CVImageBuffer imageBuffer, out CMFormatDescriptionError error);
public System.Drawing.RectangleF GetCleanAperture (bool originIsAtTopLeft);
public System.Drawing.SizeF GetPresentationDimensions (bool usePixelAspectRatio, bool useCleanAperture);

public System.Drawing.Size Dimensions {
	get;
}

}

public struct TextMarkupColor {
public TextMarkupColor (float red, float green, float blue, float alpha);

public float Alpha {
	get;
}
public float Blue {
	get;
}
public float Green {
	get;
}
public float Red {
	get;
}

}

Removed:

 	IDNotUnique

Added:

 	IDNotUnique,
 	NotPermitted

[Serializable]
public enum CTErrorDomain {
	NoError,
	Posix,
	Mach
}

[Serializable]
public enum CTBaselineClass {
	Roman,
	IdeographicCentered,
	IdeographicLow,
	IdeographicHigh,
	Hanging,
	Math
}

[Serializable]
public enum CTBaselineFont {
	Reference,
	Original
}

Added:

 	public CTFontDescriptor[] GetDefaultCascadeList (string [] languages);
 	public System.Drawing.RectangleF GetOpticalBounds (ushort [] glyphs, System.Drawing.RectangleF [] boundingRects, int count, CTFontOptions options);

Added:

 	public static bool MatchFontDescriptors (CTFontDescriptor[] descriptors, MonoTouch.Foundation.NSSet mandatoryAttributes, Func<CTFontDescriptorMatchingState,IntPtr,bool> progressHandler);

[Serializable]
public enum CTFontDescriptorMatchingState : uint {
	Started,
	Finished,
	WillBeginQuerying,
	Stalled,
	WillBeginDownloading,
	Downloading,
	DownloadingFinished,
	Matched,
	FailedWithError
}

Added:

 	public static bool RegisterGraphicsFont (MonoTouch.CoreGraphics.CGFont font, out MonoTouch.Foundation.NSError error);
 	public static bool UnregisterGraphicsFont (MonoTouch.CoreGraphics.CGFont font, out MonoTouch.Foundation.NSError error);

Removed:

 	ColorGlyphs

Added:

 	ColorGlyphs,
 	Composite,
 	Mask

Removed:

 	SExtendedBitmapData

Added:

 	SExtendedBitmapData,
 	AnchorPoints

Added:

 	public System.Drawing.RectangleF GetBounds (CTLineBoundsOptions options);

[Serializable]
public enum CTLineBoundsOptions {
	ExcludeTypographicLeading,
	ExcludeTypographicShifts,
	UseHangingPunctuation,
	UseGlyphPathBounds,
	UseOpticalBounds
}

Added:

 	public void SetBaselineInfo (CTBaselineClass baselineClass, double offset);
 	public void SetBaselineReferenceInfo (CTBaselineClass baselineClass, double offset);
 	public void SetWritingDirection (params CTWritingDirection[] writingDirections);
public Nullable<CTBaselineClass> BaselineClass {
	get;
	set;
}

Removed:

 	public static readonly MonoTouch.Foundation.NSString DisableBidiProcessing;

Added:

 	[Obsolete("Deprecated in iOS 6.0")]
	public static readonly MonoTouch.Foundation.NSString DisableBidiProcessing;

Removed:

 	public bool DisableBidiProcessing {

Added:

 	[Obsolete("Deprecated in iOS 6.0")]
	public bool DisableBidiProcessing {

Removed:

 	RightToLeft

Added:

 [Flags]
 	RightToLeft,
 	Embedding,
 	Override

Added:

 	public MonoTouch.CoreGraphics.CGColorSpace ColorSpace {
 		get;
 	}
 	public bool IsFlipped {
 		get;
 	}

Removed:

 	public CVPixelBuffer (int width, int height, CVPixelFormatType pixelFormatType, MonoTouch.Foundation.NSDictionary pixelBufferAttributes);

Added:

 	public CVPixelBuffer (System.Drawing.Size size, CVPixelFormatType pixelFormat);
 	public CVPixelBuffer (System.Drawing.Size size, CVPixelFormatType pixelFormatType, CVPixelBufferAttributes attributes);
 	[Obsolete("Use constructor with CVPixelBufferAttributes")]
	public CVPixelBuffer (int width, int height, CVPixelFormatType pixelFormatType, MonoTouch.Foundation.NSDictionary pixelBufferAttributes);
 	public static readonly MonoTouch.Foundation.NSString OpenGLESCompatibilityKey;

public class CVPixelBufferAttributes : MonoTouch.Foundation.DictionaryContainer {
public CVPixelBufferAttributes ();
public CVPixelBufferAttributes (MonoTouch.Foundation.NSDictionary dictionary);
public CVPixelBufferAttributes (CVPixelFormatType pixelFormatType, System.Drawing.Size size);

public Nullable<int> BytesPerRowAlignment {
	get;
	set;
}
public Nullable<bool> CGBitmapContextCompatibility {
	get;
	set;
}
public Nullable<bool> CGImageCompatibility {
	get;
	set;
}
public Nullable<int> ExtendedPixelsBottom {
	get;
	set;
}
public Nullable<int> ExtendedPixelsLeft {
	get;
	set;
}
public Nullable<int> ExtendedPixelsRight {
	get;
	set;
}
public Nullable<int> ExtendedPixelsTop {
	get;
	set;
}
public Nullable<int> Height {
	get;
	set;
}
public MonoTouch.CoreFoundation.CFAllocator MemoryAllocator {
	set;
}
public Nullable<bool> OpenGLCompatibility {
	get;
	set;
}
public Nullable<bool> OpenGLESCompatibility {
	get;
	set;
}
public Nullable<cvpixelformattype> PixelFormatType {
	get;
	set;
}
public Nullable<int> PlaneAlignment {
	get;
	set;
}
public Nullable<int> Width {
	get;
	set;
}

}

Removed:

 	TwoComponent8

Added:

 	TwoComponent8,
 	OneComponent16Half,
 	OneComponent32Float,
 	TwoComponent16Half,
 	TwoComponent32Float,
 	CV64RGBAHalf,
 	CV128RGBAFloat

Added:

 	WouldExceedAllocationThreshold,

Added:

 	public virtual EKAlarmProximity Proximity {
 		get;
 		set;
 	}
 	public virtual EKStructuredLocation StructuredLocation {
 		get;
 		set;
 	}

[Serializable]
public enum EKAlarmProximity {
	None,
	Enter,
	Leave
}

[Serializable]
public enum EKAuthorizationStatus {
	NotDetermined,
	Restricted,
	Denied,
	Authorized
}

Removed:

 	public static EKCalendar FromEventStore (EKEventStore eventStore);

Added:

 	public static EKCalendar Create (EKEntityType entityType, EKEventStore eventStore);
 	[Obsolete("Deprecated in iOS 6.0, use Create(EKEntityType, EKEventStore) instead")]
	public static EKCalendar FromEventStore (EKEventStore eventStore);
 	public virtual EKEntityMask AllowedEntityTypes {
 		get;
 	}

Removed:

 	public virtual string UUID {

Added:

 	public virtual string CalendarItemExternalIdentifier {
 		get;
 	}
 	public virtual string CalendarItemIdentifier {
 		get;
 	}
 	[Obsolete("Method obsoleted in iOS 6.0")]
	public virtual string UUID {

[Serializable]
[Flags]
public enum EKEntityMask {
	Event,
	Reminder
}

[Serializable]
public enum EKEntityType {
	Event,
	Reminder
}

Removed:

 	SourceDoesNotAllowCalendarAddDelete

Added:

 	SourceDoesNotAllowCalendarAddDelete,
 	RecurringReminderRequiresDueDate,
 	StructuredLocationsNotSupported,
 	ReminderLocationsNotSupported,
 	AlarmProximityNotSupported,
 	CalendarDoesNotAllowEvents,
 	CalendarDoesNotAllowReminders,
 	SourceDoesNotAllowReminders,
 	PriorityIsInvalid,
 	InvalidEntityType

Removed:

 	public virtual EKRecurrenceRule RecurrenceRule {

Added:

 	[Obsolete("Removed in iOS 6.0")]
	public virtual EKRecurrenceRule RecurrenceRule {

Removed:

 	public virtual bool RemoveCalendarc (EKCalendar calendar, bool commit, out MonoTouch.Foundation.NSError error);
 	public virtual EKCalendar[] Calendars {

Added:

 	public static EKAuthorizationStatus GetAuthorizationStatus (EKEntityType entityType);
 	public virtual void CancelFetchRequest (IntPtr fetchIdentifier);
 	public virtual IntPtr FetchReminders (MonoTouch.Foundation.NSPredicate predicate, Action<EKReminder[]> completion);
 	public virtual EKCalendarItem GetCalendarItem (string identifier);
 	public virtual EKCalendarItem[] GetCalendarItems (string externalIdentifier);
 	public virtual EKCalendar[] GetCalendars (EKEntityType entityType);
 	public virtual MonoTouch.Foundation.NSPredicate PredicateForCompleteReminders (MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, EKCalendar[] calendars);
 	public virtual MonoTouch.Foundation.NSPredicate PredicateForIncompleteReminders (MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, EKCalendar[] calendars);
 	public virtual MonoTouch.Foundation.NSPredicate PredicateForReminders (EKCalendar[] calendars);
 	public virtual bool RemoveCalendar (EKCalendar calendar, bool commit, out MonoTouch.Foundation.NSError error);
 	[Obsolete("Replaced by RemoveCalendar")]
	public bool RemoveCalendarc (EKCalendar calendar, bool commit, out MonoTouch.Foundation.NSError error);
 	public virtual bool RemoveReminder (EKReminder reminder, bool commit, out MonoTouch.Foundation.NSError error);
 	public virtual void RequestAccess (EKEntityType entityType, System.Action<bool,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual bool SaveReminder (EKReminder reminder, bool commit, out MonoTouch.Foundation.NSError error);
 	[Obsolete("Replaced by GetCalendars in iOS 6.0")]
	public virtual EKCalendar[] Calendars {
 	public virtual EKCalendar DefaultCalendarForNewReminders {
 		get;
 	}

Added:

 	public virtual bool IsCurrentUser {
 		get;
 	}

Removed:

 	public static MonoTouch.Foundation.NSObject FromDay (EKDay dayOfTheWeek);
 	public static MonoTouch.Foundation.NSObject FromDay (EKDay dayOfTheWeek, int weekNumber);

Added:

 	public static EKRecurrenceDayOfWeek FromDay (EKDay dayOfTheWeek);
 	public static EKRecurrenceDayOfWeek FromDay (EKDay dayOfTheWeek, int weekNumber);

public class EKReminder : EKCalendarItem {
public EKReminder ();
public EKReminder (MonoTouch.Foundation.NSCoder coder);
public EKReminder (MonoTouch.Foundation.NSObjectFlag t);
public EKReminder (IntPtr handle);

public static EKReminder Create (EKEventStore eventStore);
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual bool Completed {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSDate CompletionDate {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSDateComponents DueDateComponents {
	get;
	set;
}
public virtual int Priority {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSDateComponents StartDateComponents {
	get;
	set;
}

}

Removed:

 	public virtual MonoTouch.Foundation.NSSet Calendars {

Added:

 	public virtual MonoTouch.Foundation.NSSet GetCalendars (EKEntityType entityType);
 	[Obsolete("Replaced by GetCalendars in iOS 6.0")]
	public virtual MonoTouch.Foundation.NSSet Calendars {

public class EKStructuredLocation : EKObject {
public EKStructuredLocation ();
public EKStructuredLocation (MonoTouch.Foundation.NSCoder coder);
public EKStructuredLocation (MonoTouch.Foundation.NSObjectFlag t);
public EKStructuredLocation (IntPtr handle);

public static EKStructuredLocation FromTitle (string title);
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.CoreLocation.CLLocation GeoLocation {
	get;
	set;
}
public virtual double Radius {
	get;
	set;
}
public virtual string Title {
	get;
	set;
}

}

Added:

 	public EKCalendarChooser (EKCalendarChooserSelectionStyle selectionStyle, EKCalendarChooserDisplayStyle displayStyle, MonoTouch.EventKit.EKEntityType entityType, MonoTouch.EventKit.EKEventStore eventStore);

Added:

 	public virtual void CancelEditing ();

Added:

 	public EAAccessory Selected {
 		get;
 	}

Added:

 	public virtual void ShowBluetoothAccessoryPicker (MonoTouch.Foundation.NSPredicate predicate, System.Action<MonoTouch.Foundation.NSError> completion);
 	public static MonoTouch.Foundation.NSString BluetoothAccessoryPickerErrorDomain {
 		get;
 	}

public abstract class DictionaryContainer {
protected T[] GetArray<t> (NSString key) where T : NSObject;
protected Nullable<bool> GetBoolValue (NSString key);
protected Nullable<double> GetDoubleValue (NSString key);
protected Nullable<float> GetFloatValue (NSString key);
protected Nullable<int> GetInt32Value (NSString key);
protected Nullable<long> GetLongValue (NSString key);
protected string GetStringValue (NSString key);
protected Nullable<uint> GetUIntValue (NSString key);
protected void RemoveValue (NSString key);
protected void SetArrayValue (NSString key, MonoTouch.ObjCRuntime.INativeObject[] values);
protected void SetArrayValue (NSString key, NSNumber[] values);
protected void SetArrayValue (NSString key, string [] values);
protected void SetBooleanValue (NSString key, Nullable<bool> value);
protected void SetNativeValue (NSString key, MonoTouch.ObjCRuntime.INativeObject value);
protected void SetNumberValue (NSString key, Nullable<double> value);
protected void SetNumberValue (NSString key, Nullable<float> value);
protected void SetNumberValue (NSString key, Nullable<uint> value);
protected void SetNumberValue (NSString key, Nullable<int> value);
protected void SetNumberValue (NSString key, Nullable<long> value);
protected void SetStringValue (NSString key, NSString value);
protected void SetStringValue (NSString key, string value);

public NSDictionary Dictionary {
	get;
}

}

Added:

 	public static NSArray FromNSObjects (int count, params NSObject[] items);

Added:

 	public NSAttributedString (string str, MonoTouch.UIKit.UIStringAttributes attributes);
 	public NSAttributedString (string str, MonoTouch.UIKit.UIFont font, MonoTouch.UIKit.UIColor foregroundColor, MonoTouch.UIKit.UIColor backgroundColor, MonoTouch.UIKit.UIColor strokeColor, MonoTouch.UIKit.NSParagraphStyle paragraphStyle, NSLigatureType ligatures, float kerning, NSUnderlineStyle underlineStyle, MonoTouch.UIKit.NSShadow shadow, float strokeWidth, NSUnderlineStyle strikethroughStyle);
 	public virtual void DrawString (System.Drawing.PointF point);
 	public virtual void DrawString (System.Drawing.RectangleF rect);
 	public virtual void DrawString (System.Drawing.RectangleF rect, NSStringDrawingOptions options, NSStringDrawingContext context);
 	public virtual System.Drawing.RectangleF GetBoundingRect (System.Drawing.SizeF size, NSStringDrawingOptions options, NSStringDrawingContext context);
 	public MonoTouch.CoreText.CTStringAttributes GetCoreTextAttributes (int location, out NSRange effectiveRange);
 	public MonoTouch.CoreText.CTStringAttributes GetCoreTextAttributes (int location, out NSRange longestEffectiveRange, NSRange rangeLimit);
 	public MonoTouch.UIKit.UIStringAttributes GetUIKitAttributes (int location, out NSRange effectiveRange);
 	public MonoTouch.UIKit.UIStringAttributes GetUIKitAttributes (int location, out NSRange longestEffectiveRange, NSRange rangeLimit);
 	public virtual System.Drawing.SizeF Size {
 		get;
 	}

public class NSByteCountFormatter : NSFormatter {
public NSByteCountFormatter ();
public NSByteCountFormatter (NSCoder coder);
public NSByteCountFormatter (NSObjectFlag t);
public NSByteCountFormatter (IntPtr handle);

public static string Format (long byteCount, NSByteCountFormatterCountStyle countStyle);
public virtual string Format (long byteCount);

public virtual bool Adaptive {
	get;
	set;
}
public virtual NSByteCountFormatterUnits AllowedUnits {
	get;
	set;
}
public virtual bool AllowsNonnumericFormatting {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual NSByteCountFormatterCountStyle CountStyle {
	get;
	set;
}
public virtual bool IncludesActualByteCount {
	get;
	set;
}
public virtual bool IncludesCount {
	get;
	set;
}
public virtual bool IncludesUnit {
	get;
	set;
}
public virtual bool ZeroPadsFractionDigits {
	get;
	set;
}

}

[Serializable]
public enum NSByteCountFormatterCountStyle {
	File,
	Memory,
	Decimal,
	Binary
}

[Serializable]
[Flags]
public enum NSByteCountFormatterUnits {
	UseDefault,
	UseBytes,
	UseKB,
	UseMB,
	UseGB,
	UseTB,
	UsePB,
	UseEB,
	UseZB,
	UseYBOrHigher,
	UseAll
}

Removed:

 	public NSCalendar (string identifier);

Added:

 	public NSCalendar (NSCalendarType calendarType);
 	public NSCalendar (NSString identifier);

[Serializable]
public enum NSCalendarType {
	Gregorian,
	Buddhist,
	Chinese,
	Hebrew,
	Islamic,
	IslamicCivil,
	Japanese,
	RepublicOfChina,
	Persian,
	Indian,
	ISO8601
}

Added:

 	protected override void Dispose (bool disposing);
 	public virtual bool RequiresSecureCoding ();
 	public virtual NSSet AllowedClasses {
 		get;
 	}

Added:

 	WithoutOverwriting,

Added:

 	public virtual bool IsLeapMonth {
 		get;
 		set;
 	}

Added:

 	public NSDictionary (NSObject first, NSObject second, params NSObject[] args);
 	public NSDictionary (object first, object second, params object [] args);
 	public static NSObject GetSharedKeySetForKeys (NSObject[] keys);

Added:

 	public virtual void WillMove (NSUrl oldUrl, NSUrl newUrl);

Added:

 	public static NSString UbiquityIdentityDidChangeNotification {
 		get;
 	}
 	public virtual NSObject UbiquityIdentityToken {
 		get;
 	}
public static class Notifications {
	
	public static NSObject ObserveUbiquityIdentityDidChange (EventHandler<NSNotificationEventArgs> handler);
}

Added:

 	public static NSIndexPath FromItemSection (int item, int section);

[Serializable]
public enum NSLigatureType {
	None,
	Default,
	All
}

Removed:

 public class NSLinguisticTag {
public NSLinguisticTag ();

Added:

 public static class NSLinguisticTag {

Added:

 	public NSMutableAttributedString (string str, MonoTouch.UIKit.UIStringAttributes attributes);
 	public NSMutableAttributedString (string str, MonoTouch.UIKit.UIFont font, MonoTouch.UIKit.UIColor foregroundColor, MonoTouch.UIKit.UIColor backgroundColor, MonoTouch.UIKit.UIColor strokeColor, MonoTouch.UIKit.NSParagraphStyle paragraphStyle, NSLigatureType ligatures, float kerning, NSUnderlineStyle underlineStyle, MonoTouch.UIKit.NSShadow shadow, float strokeWidth, NSUnderlineStyle strikethroughStyle);
 	public void Append (NSAttributedString first, params object [] rest);

Added:

 	public static NSDictionary FromSharedKeySet (NSObject sharedKeyToken);

Added:

 	public NSMutableSet (NSObject[] objs);
 	public NSMutableSet (params string [] strings);
 	public NSMutableSet (NSArray other);
 	public NSMutableSet (NSSet other);
 	public NSMutableSet (int capacity);
 	public virtual void AddObjects (NSObject[] objects);
 	public virtual void RemoveAll ();

Added:

 	public virtual bool AllowsCellularAccess {
 		get;
 		set;
 	}

Removed:

 	[Obsolete("Use AcceptInputForMode (NSString, NSDate)")]
	public void AcceptInputForMode (string mode, NSDate limitDate);
 	[Obsolete("Use AddTimer (NSTimer, NSString)")]
	public void AddTimer (NSTimer timer, string forMode);
 	[Obsolete("Use LimitDateForMode (NSString) instead")]
	public NSDate LimitDateForMode (string mode);

Added:

 	[Obsolete("Use AcceptInputForMode (NSRunLoopMode, NSDate)")]
	public void AcceptInputForMode (string mode, NSDate limitDate);
 	[Obsolete("Use AddTimer (NSTimer, NSRunLoopMode)")]
	public void AddTimer (NSTimer timer, string forMode);
 	[Obsolete("Use LimitDateForMode (NSRunLoopMode) instead")]
	public NSDate LimitDateForMode (string mode);
 	public bool RunUntil (NSRunLoopMode mode, NSDate limitDate);
 	public static NSString UITrackingRunLoopMode {
 		get;
 	}
 	public NSRunLoopMode CurrentRunLoopMode {
 		get;
 	}

Removed:

 	Common

Added:

 	Common,
 	UITracking,
 	Other

Removed:

 	AllLibrariesDirectory

Added:

 	ApplicationScriptsDirectory,
 	AllLibrariesDirectory,
 	TrashDirectory

Removed:

 	public NSSet (NSObject[] objs);

Added:

 	public NSSet (params NSObject[] objs);
 	public NSSet (params object [] objs);
 	public NSSet (NSSet other);
 	public bool Contains (object obj);
 	public virtual bool IntersectsSet (NSSet other);
 	public static NSSet operator + (NSSet first, NSSet second);
 	public static NSSet operator - (NSSet first, NSSet second);

Added:

 	public virtual string Capitalize (NSLocale locale);
 	public virtual string ToLower (NSLocale locale);
 	public virtual string ToUpper (NSLocale locale);

public class NSStringDrawingContext : NSObject {
public NSStringDrawingContext ();
public NSStringDrawingContext (NSCoder coder);
public NSStringDrawingContext (NSObjectFlag t);
public NSStringDrawingContext (IntPtr handle);

public virtual float ActualScaleFactor {
	get;
}
public virtual float ActualTrackingAdjustment {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual float MinimumScaleFactor {
	get;
	set;
}
public virtual float MinimumTrackingAdjustment {
	get;
	set;
}
public virtual System.Drawing.RectangleF TotalBounds {
	get;
}

}

Added:

 	[Obsolete("This instance of NSTimer would be unusable. Symbol kept for binary compatibility")]
	public NSTimer ();

Removed:

 	QuotaViolationChange

Added:

 	QuotaViolationChange,
 	AccountChange

[Serializable]
public enum NSUnderlineStyle {
	None,
	Single
}

Added:

 	public NSUrl (NSData bookmarkData, NSUrlBookmarkResolutionOptions resolutionOptions, NSUrl relativeUrl, out bool bookmarkIsStale, out NSError error);
 	public virtual NSData CreateBookmarkData (NSUrlBookmarkCreationOptions options, string [] resourceValues, NSUrl relativeUrl, out NSError error);
 	public static NSString PathKey {
 		get;
 	}

[Serializable]
[Flags]
public enum NSUrlBookmarkCreationOptions {
	PreferFileIDResolution,
	MinimalBookmark,
	SuitableForBookmarkFile,
	WithSecurityScope,
	SecurityScopeAllowOnlyReadAccess
}

[Serializable]
[Flags]
public enum NSUrlBookmarkResolutionOptions {
	WithoutUI,
	WithoutMounting,
	WithSecurityScope
}

public class NSUuid : NSObject {
public NSUuid (byte [] bytes);
public NSUuid ();
public NSUuid (NSCoder coder);
public NSUuid (NSObjectFlag t);
public NSUuid (IntPtr handle);
public NSUuid (string str);

public virtual string AsString ();
public byte [] GetBytes ();

public override IntPtr ClassHandle {
	get;
}

}

Added:

 	public static NSValue FromMKCoordinate (MonoTouch.CoreLocation.CLLocationCoordinate2D coordinate);
 	public static NSValue FromMKCoordinateSpan (MonoTouch.MapKit.MKCoordinateSpan coordinateSpan);
 	public virtual MonoTouch.MapKit.MKCoordinateSpan CoordinateSpanValue {
 		get;
 	}
 	public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D CoordinateValue {
 		get;
 	}

[Serializable]
public enum NSWritingDirection {
	Natural,
	LeftToRight,
	RightToLeft
}

Removed:

 	public static void ResetAchivements (GKNotificationHandler errorHandler);
 	public virtual void ReportAchievement (GKNotificationHandler handler);
 	public virtual bool Hidden {

Added:

 	public static void ReportAchievements (GKAchievement[] achievements, GKNotificationHandler completionHandler);
 	public static void ResetAchivements (GKNotificationHandler completionHandler);
 	public virtual void IssueChallengeToPlayers (string [] playerIDs, string message);
 	public virtual void ReportAchievement (GKNotificationHandler completionHandler);
 	public virtual void SelectChallengeablePlayerIDs (string [] playerIDs, System.Action<string [],MonoTouch.Foundation.NSError> completionHandler);
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool Hidden {

public class GKAchievementChallenge : GKChallenge {
public GKAchievementChallenge ();
public GKAchievementChallenge (MonoTouch.Foundation.NSCoder coder);
public GKAchievementChallenge (MonoTouch.Foundation.NSObjectFlag t);
public GKAchievementChallenge (IntPtr handle);

protected override void Dispose (bool disposing);

public virtual GKAchievement Achievement {
	get;
}
public override IntPtr ClassHandle {
	get;
}

}

Added:

 	public virtual string GroupIdentifier {
 		get;
 	}
 	public virtual bool Replayable {
 		get;
 	}

Removed:

 public class GKAchievementViewController : MonoTouch.UIKit.UINavigationController {

Added:

 public class GKAchievementViewController : GKGameCenterViewController {

public class GKChallenge : MonoTouch.Foundation.NSObject {
public GKChallenge ();
public GKChallenge (MonoTouch.Foundation.NSCoder coder);
public GKChallenge (MonoTouch.Foundation.NSObjectFlag t);
public GKChallenge (IntPtr handle);

public static void LoadReceivedChallenges (System.Action<gkchallenge[],monotouch.foundation.nserror> completionHandler);
public virtual void Decline ();
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSDate CompletionDate {
	get;
}
public virtual MonoTouch.Foundation.NSDate IssueDate {
	get;
}
public virtual string IssuingPlayerID {
	get;
}
public virtual string Message {
	get;
}
public virtual string ReceivingPlayerID {
	get;
}
public virtual GKChallengeState State {
	get;
}

}
</gkchallenge[],monotouch.foundation.nserror>

public class GKChallengeEventHandler : MonoTouch.Foundation.NSObject {
public GKChallengeEventHandler (MonoTouch.Foundation.NSCoder coder);
public GKChallengeEventHandler (MonoTouch.Foundation.NSObjectFlag t);
public GKChallengeEventHandler (IntPtr handle);

protected override void Dispose (bool disposing);

public static GKChallengeEventHandler Instance {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public GKChallengeEventHandlerDelegate Delegate {
	get;
	set;
}
public GKChallengePredicate ShouldShowBannerForLocallyCompletedChallenge {
	get;
	set;
}
public GKChallengePredicate ShouldShowBannerForLocallyReceivedChallenge {
	get;
	set;
}
public GKChallengePredicate ShouldShowBannerForRemotelyCompletedChallenge {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public event EventHandler LocalPlayerCompletedChallenge;
public event EventHandler LocalPlayerReceivedChallenge;
public event EventHandler LocalPlayerSelectedChallenge;
public event EventHandler RemotePlayerCompletedChallenge;

}

public class GKChallengeEventHandlerDelegate : MonoTouch.Foundation.NSObject {
public GKChallengeEventHandlerDelegate ();
public GKChallengeEventHandlerDelegate (MonoTouch.Foundation.NSCoder coder);
public GKChallengeEventHandlerDelegate (MonoTouch.Foundation.NSObjectFlag t);
public GKChallengeEventHandlerDelegate (IntPtr handle);

public virtual void LocalPlayerCompletedChallenge (GKChallenge challenge);
public virtual void LocalPlayerReceivedChallenge (GKChallenge challenge);
public virtual void LocalPlayerSelectedChallenge (GKChallenge challenge);
public virtual void RemotePlayerCompletedChallenge (GKChallenge challenge);
public virtual bool ShouldShowBannerForLocallyCompletedChallenge (GKChallenge challenge);
public virtual bool ShouldShowBannerForLocallyReceivedChallenge (GKChallenge challenge);
public virtual bool ShouldShowBannerForRemotelyCompletedChallenge (GKChallenge challenge);

}

[Serializable]
public delegate bool GKChallengePredicate (GKChallenge challenge);

[Serializable]
public enum GKChallengeState {
	Invalid,
	Pending,
	Completed,
	Declined
}

Removed:

 	UnexpectedConnection

Added:

 	None,
 	UnexpectedConnection,
 	ChallengeInvalid,
 	TurnBasedMatchDataTooLarge,
 	TurnBasedTooManySessions,
 	TurnBasedInvalidParticipant,
 	TurnBasedInvalidTurn,
 	TurnBasedInvalidState

public class GKGameCenterControllerDelegate : MonoTouch.Foundation.NSObject {
public GKGameCenterControllerDelegate ();
public GKGameCenterControllerDelegate (MonoTouch.Foundation.NSCoder coder);
public GKGameCenterControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
public GKGameCenterControllerDelegate (IntPtr handle);

public virtual void Finished (GKGameCenterViewController controller);

}

public class GKGameCenterViewController : MonoTouch.UIKit.UINavigationController {
public GKGameCenterViewController ();
public GKGameCenterViewController (MonoTouch.Foundation.NSCoder coder);
public GKGameCenterViewController (MonoTouch.Foundation.NSObjectFlag t);
public GKGameCenterViewController (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public GKGameCenterControllerDelegate Delegate {
	get;
	set;
}
public virtual string LeaderboardCategory {
	get;
	set;
}
public virtual GKLeaderboardTimeScope LeaderboardTimeScope {
	get;
	set;
}
public virtual GKGameCenterViewControllerState ViewState {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public event EventHandler Finished;

}

[Serializable]
public enum GKGameCenterViewControllerState {
	Default,
	Leaderboards,
	Achievements,
	Challenges
}

Added:

 	public virtual uint PlayerAttributes {
 		get;
 	}
 	public virtual int PlayerGroup {
 		get;
 	}

[Serializable]
public enum GKInviteeResponse {
	Accepted,
	Declined,
	Failed,
	Incompatible,
	UnableToConnect,
	NoAnswer
}

Removed:

 	public static void LoadCategories (GKCategoryHandler categoryHandler);

Added:

 	[Obsolete("Deprecated iOS 6.0")]
	public static void LoadCategories (GKCategoryHandler categoryHandler);
 	public static void LoadLeaderboards (System.Action<GKLeaderboard[],MonoTouch.Foundation.NSError> completionHandler);
 	public virtual string GroupIdentifier {
 		get;
 	}

Removed:

 public class GKLeaderboardViewController : MonoTouch.UIKit.UINavigationController {

Added:

 public class GKLeaderboardViewController : GKGameCenterViewController {

Removed:

 	public virtual void Authenticate (GKNotificationHandler handler);

Added:

 	[Obsolete("Replaced by AuthenticateHandler in iOS 6.0")]
	public virtual void Authenticate (GKNotificationHandler handler);
 	public virtual void LoadDefaultLeaderboardCategoryID (System.Action<string,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void SetDefaultLeaderboardCategoryID (string categoryID, System.Action<MonoTouch.Foundation.NSError> completionHandler);
 	public virtual System.Action<MonoTouch.UIKit.UIViewController,MonoTouch.Foundation.NSError> AuthenticateHandler {
 		get;
 		set;
 	}

Added:

 	public virtual void ChooseBestHostPlayer (Action<string> completionHandler);
 	public virtual void Rematch (System.Action<GKMatch,MonoTouch.Foundation.NSError> completionHandler);

Added:

 	public static int GetMaxPlayersAllowed (GKMatchType matchType);
public virtual int DefaultNumberOfPlayers {
	get;
	set;
}
public virtual Action<string,GKInviteeResponse> InviteeResponseHandler {
	get;
	set;
}
public virtual string InviteMessage {
	get;
	set;
}

[Serializable]
public enum GKMatchType {
	PeerToPeer,
	Hosted,
	TurnBased
}

Removed:

 	public virtual void QueryPlayerGroupActivity (uint playerGroup, GKQueryHandler completionHandler);

Added:

 	public virtual void CancelInvite (string playerID);
 	public virtual void FinishMatchmaking (GKMatch match);
 	public virtual void Match (GKInvite invite, System.Action<GKMatch,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void QueryPlayerGroupActivity (int playerGroup, GKQueryHandler completionHandler);
 	public virtual void StartBrowsingForNearbyPlayers (Action<string,bool> reachableHandler);
 	public virtual void StopBrowsingForNearbyPlayers ();

Removed:

 	public GKMatchmakerViewController ();

Added:

 	public static void Show (string title, string message, double durationSeconds, Action completionHandler);

Added:

 	public virtual string DisplayName {
 		get;
 	}

Removed:

 	public virtual MonoTouch.Foundation.NSDate date {
 		set;

Added:

 	public static void ReportScores (GKScore[] scores, System.Action<MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void IssueChallengeToPlayers (string [] playerIDs, string message);
 	[Obsolete("Use Date property")]
	public virtual MonoTouch.Foundation.NSDate date {

public class GKScoreChallenge : GKChallenge {
public GKScoreChallenge ();
public GKScoreChallenge (MonoTouch.Foundation.NSCoder coder);
public GKScoreChallenge (MonoTouch.Foundation.NSObjectFlag t);
public GKScoreChallenge (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual GKScore Score {
	get;
}

}

Removed:

 	public virtual void HandleTurnEventForMatch (GKTurnBasedMatch match);

Added:

 	public virtual void HandleTurnEvent (GKTurnBasedMatch match, bool activated);
 	[Obsolete("Replaced by HandleTurnEvent in iOS 6.0")]
	public virtual void HandleTurnEventForMatch (GKTurnBasedMatch match);

Removed:

 	public virtual void EndTurnWithNextParticipant (GKTurnBasedParticipant nextParticipatn, MonoTouch.Foundation.NSData matchData, GKNotificationHandler noCompletion);
 	public virtual void ParticipantQuitInTurn (GKTurnBasedMatchOutcome matchOutcome, GKTurnBasedParticipant nextParticipant, MonoTouch.Foundation.NSData matchData, GKNotificationHandler onCompletion);

Added:

 	public static void LoadMatch (string matchId, System.Action<GKTurnBasedMatch,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void AcceptInvite (System.Action<GKTurnBasedMatch,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void DeclineInvite (System.Action<GKTurnBasedMatch,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void EndTurn (GKTurnBasedParticipant[] nextParticipants, double timeoutSeconds, MonoTouch.Foundation.NSData matchData, System.Action<MonoTouch.Foundation.NSError> completionHandler);
 	[Obsolete("Replaced by EndTurn in iOS 6.0")]
	public virtual void EndTurnWithNextParticipant (GKTurnBasedParticipant nextParticipant, MonoTouch.Foundation.NSData matchData, GKNotificationHandler noCompletion);
 	[Obsolete("Replaced by ParticipantQuitInTurn (GKTurnBasedMatchOutcome, GKTurnBasedParticipant[], double, NSData, Action<NSError>) in iOS 6.0")]
	public virtual void ParticipantQuitInTurn (GKTurnBasedMatchOutcome matchOutcome, GKTurnBasedParticipant nextParticipant, MonoTouch.Foundation.NSData matchData, GKNotificationHandler onCompletion);
 	public virtual void ParticipantQuitInTurn (GKTurnBasedMatchOutcome matchOutcome, GKTurnBasedParticipant[] nextParticipants, double timeoutSeconds, MonoTouch.Foundation.NSData matchData, System.Action<MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void Rematch (System.Action<GKTurnBasedMatch,MonoTouch.Foundation.NSError> completionHandler);
 	public virtual void SaveCurrentTurn (MonoTouch.Foundation.NSData matchData, System.Action<MonoTouch.Foundation.NSError> completionHandler);
 	public static double DefaultTimeout {
 		get;
 	}
 	public static double NoTimeout {
 		get;
 	}
 	public virtual int MatchDataMaximumSize {
 		get;
 	}

Removed:

 	public GKTurnBasedMatchmakerViewController ();

Added:

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

Removed:

 	Silent

Added:

 	Silent,
 	Connecting

Removed:

 public class CGImageProperties {
public CGImageProperties ();

Added:

 public static class CGImageProperties {

[Serializable]
public enum MKDirectionsMode {
	Driving,
	Walking
}

public class MKDirectionsRequest : MonoTouch.Foundation.NSObject {
public MKDirectionsRequest ();
public MKDirectionsRequest (MonoTouch.Foundation.NSCoder coder);
public MKDirectionsRequest (MonoTouch.Foundation.NSObjectFlag t);
public MKDirectionsRequest (IntPtr handle);
public MKDirectionsRequest (MonoTouch.Foundation.NSUrl url);

public static bool IsDirectionsRequestUrl (MonoTouch.Foundation.NSUrl url);
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual MKMapItem Destination {
	get;
}
public virtual MKMapItem Source {
	get;
}

}

public class MKLaunchOptions {
public MKLaunchOptions ();

public Nullable<mkdirectionsmode> DirectionsMode {
	get;
	set;
}
public System.Nullable<monotouch.corelocation.cllocationcoordinate2d> MapCenter {
	get;
	set;
}
public Nullable<mkcoordinatespan> MapSpan {
	get;
	set;
}
public Nullable<mkmaptype> MapType {
	get;
	set;
}
public Nullable<bool> ShowTraffic {
	get;
	set;
}

}
</monotouch.corelocation.cllocationcoordinate2d>

public class MKMapItem : MonoTouch.Foundation.NSObject {
public MKMapItem ();
public MKMapItem (MonoTouch.Foundation.NSCoder coder);
public MKMapItem (MonoTouch.Foundation.NSObjectFlag t);
public MKMapItem (IntPtr handle);
public MKMapItem (MKPlacemark placemark);

public static MKMapItem MapItemForCurrentLocation ();
public static bool OpenMaps (MKMapItem[] mapItems, MKLaunchOptions launchOptions);
protected override void Dispose (bool disposing);
public void OpenInMaps (MKLaunchOptions launchOptions);

public override IntPtr ClassHandle {
	get;
}
public virtual bool IsCurrentLocation {
	get;
}
public virtual string Name {
	get;
	set;
}
public virtual string PhoneNumber {
	get;
	set;
}
public virtual MKPlacemark Placemark {
	get;
}
public virtual MonoTouch.Foundation.NSUrl Url {
	get;
	set;
}

}

Added:

 	public static MonoTouch.Foundation.NSString BookmarkTimeProperty {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString IsCloudItemProperty {
 		get;
 	}
 	public double BookmarkTime {
 		get;
 	}
 	public bool IsCloudItem {
 		get;
 	}

Added:

 	public virtual bool ShowsCloudItems {
 		get;
 		set;
 	}

Removed:

 	public virtual bool UseApplicationAudioSession {
 		public static MonoTouch.Foundation.NSObject ObserveWillEnterFullscreen (EventHandler<MPMoviePlayerFullScreenEventArgs> handler);

Added:

 	public static MonoTouch.Foundation.NSString MoviePlayerReadyForDisplayDidChangeNotification {
 		get;
 	}
 	public virtual bool ReadyForDisplay {
 		get;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool UseApplicationAudioSession {
 		public static MonoTouch.Foundation.NSObject ObserveMoviePlayerReadyForDisplayDidChange (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);
 		public static MonoTouch.Foundation.NSObject ObserveWillEnterFullscreen (System.EventHandler<MonoTouch.Foundation.NSNotificationEventArgs> handler);

Added:

 	public virtual void PrepareToPlay ();
 	public virtual float CurrentPlaybackRate {
 		get;
 		set;
 	}
 	public virtual bool IsPreparedToPlay {
 		get;
 	}

Added:

 	public virtual MonoTouch.UIKit.UIImage GetMaximumVolumeSliderImage (MonoTouch.UIKit.UIControlState state);
 	public virtual MonoTouch.UIKit.UIImage GetMinimumVolumeSliderImage (MonoTouch.UIKit.UIControlState state);
 	public virtual MonoTouch.UIKit.UIImage GetRouteButtonImage (MonoTouch.UIKit.UIControlState state);
 	public virtual System.Drawing.RectangleF GetRouteButtonRect (System.Drawing.RectangleF bounds);
 	public virtual System.Drawing.RectangleF GetVolumeSliderRect (System.Drawing.RectangleF bounds);
 	public virtual MonoTouch.UIKit.UIImage GetVolumeThumbImage (MonoTouch.UIKit.UIControlState state);
 	public virtual System.Drawing.RectangleF GetVolumeThumbRect (System.Drawing.RectangleF bounds, System.Drawing.RectangleF columeSliderRect, float value);
 	public virtual void SetMaximumVolumeSliderImage (MonoTouch.UIKit.UIImage image, MonoTouch.UIKit.UIControlState state);
 	public virtual void SetMinimumVolumeSliderImage (MonoTouch.UIKit.UIImage image, MonoTouch.UIKit.UIControlState state);
 	public virtual void SetRouteButtonImage (MonoTouch.UIKit.UIImage image, MonoTouch.UIKit.UIControlState state);
 	public virtual void SetVolumeThumbImage (MonoTouch.UIKit.UIImage image, MonoTouch.UIKit.UIControlState state);

public class MTAudioProcessingTap : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
public MTAudioProcessingTap (MTAudioProcessingTapCallbacks callbacks, MTAudioProcessingTapCreationFlags flags);

public void Dispose ();
protected virtual void Dispose (bool disposing);
protected override void Finalize ();
public MTAudioProcessingTapError GetSourceAudio (long frames, ref MonoTouch.AudioToolbox.AudioBufferList bufferList, out MTAudioProcessingTapFlags flags, out MonoTouch.CoreMedia.CMTimeRange timeRange, long framesProvided);
public void * GetStorage ();

public IntPtr Handle {
	get;
}

}

public class MTAudioProcessingTapCallbacks {
public MTAudioProcessingTapCallbacks (MTAudioProcessingTapProcessCallback process);

public Action<mtaudioprocessingtap> Finalize {
	get;
	set;
}
public MTAudioProcessingTapInitCallback Initialize {
	get;
	set;
}
public MTAudioProcessingTapPrepareCallback Prepare {
	get;
	set;
}
public MTAudioProcessingTapProcessCallback Process {
	get;
}
public Action<mtaudioprocessingtap> Unprepare {
	get;
	set;
}

}

[Serializable]
[Flags]
public enum MTAudioProcessingTapCreationFlags : uint {
	PreEffects,
	PostEffects
}

[Serializable]
public enum MTAudioProcessingTapError {
	None,
	InvalidArgument
}

[Serializable]
[Flags]
public enum MTAudioProcessingTapFlags : uint {
	StartOfStream,
	EndOfStream
}

[Serializable]
public delegate void MTAudioProcessingTapInitCallback (MTAudioProcessingTap tap, out void * tapStorage);

[Serializable]
public delegate void MTAudioProcessingTapPrepareCallback (MTAudioProcessingTap tap, long maxFrames, ref MonoTouch.AudioToolbox.AudioStreamBasicDescription processingFormat);

[Serializable]
public delegate void MTAudioProcessingTapProcessCallback (MTAudioProcessingTap tap, long numberFrames, MTAudioProcessingTapFlags flags, ref MonoTouch.AudioToolbox.AudioBufferList bufferList, out long numberFramesOut, out MTAudioProcessingTapFlags flagsOut);

Added:

 	public static System.Drawing.SizeF GetSizeF (IntPtr handle, string symbol);

Removed:

 	public static void RectangleF_objc_msgSend_stret_IntPtr_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2);
 	public static void RectangleF_objc_msgSendSuper_stret_IntPtr_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2);
 	public static void void_objc_msgSend_UInt32_IntPtr (IntPtr receiver, IntPtr selector, uint arg1, IntPtr arg2);
 	public static void void_objc_msgSendSuper_UInt32_IntPtr (IntPtr receiver, IntPtr selector, uint arg1, IntPtr arg2);

Added:

 	public static bool bool_objc_msgSend_float_IntPtr (IntPtr receiver, IntPtr selector, float arg1, IntPtr arg2);
 	public static bool bool_objc_msgSend_RectangleF (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1);
 	public static bool bool_objc_msgSendSuper_float_IntPtr (IntPtr receiver, IntPtr selector, float arg1, IntPtr arg2);
 	public static bool bool_objc_msgSendSuper_RectangleF (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1);
 	public static void CMTime_objc_msgSend_stret_Double (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, double arg1);
 	public static void CMTime_objc_msgSend_stret_Int64 (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, long arg1);
 	public static void CMTime_objc_msgSendSuper_stret_Double (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, double arg1);
 	public static void CMTime_objc_msgSendSuper_stret_Int64 (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, long arg1);
 	public static float float_objc_msgSend_IntPtr_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static float float_objc_msgSendSuper_IntPtr_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static IntPtr IntPtr_objc_msgSend_CMTime_out_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, out MonoTouch.CoreMedia.CMTime arg2);
 	public static IntPtr IntPtr_objc_msgSend_int_int_int_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, int arg3, IntPtr arg4);
 	public static IntPtr IntPtr_objc_msgSend_Int64_int (IntPtr receiver, IntPtr selector, long arg1, int arg2);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_int_int_IntPtr_int_float_float (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, int arg3, IntPtr arg4, int arg5, float arg6, float arg7);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_int_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3, int arg4);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_int_IntPtr_out_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3, out bool arg4, IntPtr arg5);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_IntPtr_RectangleF (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, System.Drawing.RectangleF arg3);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_RectangleF_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, System.Drawing.RectangleF arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_UIEdgeInsets_int_Double (IntPtr receiver, IntPtr selector, IntPtr arg1, MonoTouch.UIKit.UIEdgeInsets arg2, int arg3, double arg4);
 	public static IntPtr IntPtr_objc_msgSend_MKCoordinateSpan (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKCoordinateSpan arg1);
 	public static IntPtr IntPtr_objc_msgSend_UIEdgeInsets_int (IntPtr receiver, IntPtr selector, MonoTouch.UIKit.UIEdgeInsets arg1, int arg2);
 	public static IntPtr IntPtr_objc_msgSend_UInt32_int_int (IntPtr receiver, IntPtr selector, uint arg1, int arg2, int arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_CMTime_out_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, out MonoTouch.CoreMedia.CMTime arg2);
 	public static IntPtr IntPtr_objc_msgSendSuper_int_int_int_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, int arg3, IntPtr arg4);
 	public static IntPtr IntPtr_objc_msgSendSuper_Int64_int (IntPtr receiver, IntPtr selector, long arg1, int arg2);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_int_int_IntPtr_int_float_float (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, int arg3, IntPtr arg4, int arg5, float arg6, float arg7);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_int_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3, int arg4);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_int_IntPtr_out_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3, out bool arg4, IntPtr arg5);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_IntPtr_RectangleF (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, System.Drawing.RectangleF arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_RectangleF_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, System.Drawing.RectangleF arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_UIEdgeInsets_int_Double (IntPtr receiver, IntPtr selector, IntPtr arg1, MonoTouch.UIKit.UIEdgeInsets arg2, int arg3, double arg4);
 	public static IntPtr IntPtr_objc_msgSendSuper_MKCoordinateSpan (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKCoordinateSpan arg1);
 	public static IntPtr IntPtr_objc_msgSendSuper_UIEdgeInsets_int (IntPtr receiver, IntPtr selector, MonoTouch.UIKit.UIEdgeInsets arg1, int arg2);
 	public static IntPtr IntPtr_objc_msgSendSuper_UInt32_int_int (IntPtr receiver, IntPtr selector, uint arg1, int arg2, int arg3);
 	public static void MKCoordinateSpan_objc_msgSend_stret (out MonoTouch.MapKit.MKCoordinateSpan retval, IntPtr receiver, IntPtr selector);
 	public static void MKCoordinateSpan_objc_msgSendSuper_stret (out MonoTouch.MapKit.MKCoordinateSpan retval, IntPtr receiver, IntPtr selector);
 	public static System.Drawing.PointF PointF_objc_msgSend_PointF (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static System.Drawing.PointF PointF_objc_msgSend_PointF_PointF (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, System.Drawing.PointF arg2);
 	public static void PointF_objc_msgSend_stret_PointF (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static void PointF_objc_msgSend_stret_PointF_PointF (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, System.Drawing.PointF arg2);
 	public static System.Drawing.PointF PointF_objc_msgSendSuper_PointF (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static System.Drawing.PointF PointF_objc_msgSendSuper_PointF_PointF (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, System.Drawing.PointF arg2);
 	public static void PointF_objc_msgSendSuper_stret_PointF (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static void PointF_objc_msgSendSuper_stret_PointF_PointF (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, System.Drawing.PointF arg2);
 	public static void RectangleF_objc_msgSend_stret_IntPtr_IntPtr_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static void RectangleF_objc_msgSend_stret_SizeF_UInt32_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, System.Drawing.SizeF arg1, uint arg2, IntPtr arg3);
 	public static void RectangleF_objc_msgSendSuper_stret_IntPtr_IntPtr_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static void RectangleF_objc_msgSendSuper_stret_SizeF_UInt32_IntPtr (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, System.Drawing.SizeF arg1, uint arg2, IntPtr arg3);
 	public static System.Drawing.SizeF SizeF_objc_msgSend_IntPtr_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static System.Drawing.SizeF SizeF_objc_msgSend_IntPtr_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static void SizeF_objc_msgSend_stret_IntPtr_IntPtr_int (out System.Drawing.SizeF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static void SizeF_objc_msgSend_stret_IntPtr_IntPtr_IntPtr (out System.Drawing.SizeF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static System.Drawing.SizeF SizeF_objc_msgSendSuper_IntPtr_IntPtr_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static System.Drawing.SizeF SizeF_objc_msgSendSuper_IntPtr_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static void SizeF_objc_msgSendSuper_stret_IntPtr_IntPtr_int (out System.Drawing.SizeF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static void SizeF_objc_msgSendSuper_stret_IntPtr_IntPtr_IntPtr (out System.Drawing.SizeF retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, IntPtr arg3);
 	public static void UIEdgeInsets_objc_msgSend_stret_IntPtr_IntPtr_int (out MonoTouch.UIKit.UIEdgeInsets retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static void UIEdgeInsets_objc_msgSendSuper_stret_IntPtr_IntPtr_int (out MonoTouch.UIKit.UIEdgeInsets retval, IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3);
 	public static void void_objc_msgSend_Double_Double (IntPtr receiver, IntPtr selector, double arg1, double arg2);
 	public static void void_objc_msgSend_Double_float (IntPtr receiver, IntPtr selector, double arg1, float arg2);
 	public static void void_objc_msgSend_float_CMTime_CMTime (IntPtr receiver, IntPtr selector, float arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static void void_objc_msgSend_int_IntPtr_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, IntPtr arg2, double arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSend_IntPtr_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, double arg2, IntPtr arg3, IntPtr arg4);
 	public static void void_objc_msgSend_IntPtr_IntPtr_Double_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, double arg3, IntPtr arg4);
 	public static void void_objc_msgSend_IntPtr_UInt32_int_int (IntPtr receiver, IntPtr selector, IntPtr arg1, uint arg2, int arg3, int arg4);
 	public static void void_objc_msgSend_RectangleF_UInt32_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, uint arg2, IntPtr arg3);
 	public static void void_objc_msgSendSuper_Double_Double (IntPtr receiver, IntPtr selector, double arg1, double arg2);
 	public static void void_objc_msgSendSuper_Double_float (IntPtr receiver, IntPtr selector, double arg1, float arg2);
 	public static void void_objc_msgSendSuper_float_CMTime_CMTime (IntPtr receiver, IntPtr selector, float arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static void void_objc_msgSendSuper_int_IntPtr_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, IntPtr arg2, double arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSendSuper_IntPtr_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, double arg2, IntPtr arg3, IntPtr arg4);
 	public static void void_objc_msgSendSuper_IntPtr_IntPtr_Double_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, double arg3, IntPtr arg4);
 	public static void void_objc_msgSendSuper_IntPtr_UInt32_int_int (IntPtr receiver, IntPtr selector, IntPtr arg1, uint arg2, int arg3, int arg4);
 	public static void void_objc_msgSendSuper_RectangleF_UInt32_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1, uint arg2, IntPtr arg3);

public class MountainLionAttribute : Attribute {
public MountainLionAttribute ();

}

public class PKAddPassesViewController : MonoTouch.UIKit.UIViewController {
public PKAddPassesViewController (MonoTouch.Foundation.NSCoder coder);
public PKAddPassesViewController (MonoTouch.Foundation.NSObjectFlag t);
public PKAddPassesViewController (IntPtr handle);
public PKAddPassesViewController (PKPass pass);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public PKAddPassesViewControllerDelegate Delegate {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public event EventHandler Finished;

}

public class PKAddPassesViewControllerDelegate : MonoTouch.Foundation.NSObject {
public PKAddPassesViewControllerDelegate ();
public PKAddPassesViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
public PKAddPassesViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
public PKAddPassesViewControllerDelegate (IntPtr handle);

public virtual void Finished (PKAddPassesViewController controller);

}

public class PKPass : MonoTouch.Foundation.NSObject {
public PKPass ();
public PKPass (MonoTouch.Foundation.NSCoder coder);
public PKPass (MonoTouch.Foundation.NSObjectFlag t);
public PKPass (IntPtr handle);
public PKPass (MonoTouch.Foundation.NSData data, out MonoTouch.Foundation.NSError error);

protected override void Dispose (bool disposing);
public virtual MonoTouch.Foundation.NSObject GetLocalizedValue (MonoTouch.Foundation.NSString key);

public static MonoTouch.Foundation.NSString ErrorDomain {
	get;
}
public virtual string AuthenticationToken {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.UIKit.UIImage Icon {
	get;
}
public virtual string LocalizedDescription {
	get;
}
public virtual string LocalizedName {
	get;
}
public virtual string OrganizationName {
	get;
}
public virtual string PassTypeIdentifier {
	get;
}
public virtual MonoTouch.Foundation.NSUrl PassUrl {
	get;
}
public virtual MonoTouch.Foundation.NSDate RelevantDate {
	get;
}
public virtual string SerialNumber {
	get;
}
public virtual MonoTouch.Foundation.NSUrl WebServiceUrl {
	get;
}

}

[Serializable]
public enum PKPassKitErrorCode {
	Unknown,
	None,
	InvalidData,
	UnsupportedVersion,
	CertificateRevoked
}

public class PKPassLibrary : MonoTouch.Foundation.NSObject {
public PKPassLibrary ();
public PKPassLibrary (MonoTouch.Foundation.NSCoder coder);
public PKPassLibrary (MonoTouch.Foundation.NSObjectFlag t);
public PKPassLibrary (IntPtr handle);

public virtual bool Contains (PKPass pass);
public virtual PKPass GetPass (string identifier, string serialNumber);
public virtual PKPass[] GetPasses ();
public virtual void Remove (PKPass pass);
public virtual bool Replace (PKPass pass);

public static MonoTouch.Foundation.NSString DidChangeNotification {
	get;
}
public static bool IsAvailable {
	get;
}
public override IntPtr ClassHandle {
	get;
}

public static class Notifications {
	
	public static MonoTouch.Foundation.NSObject ObserveDidChange (System.EventHandler<monotouch.foundation.nsnotificationeventargs> handler);
}

}
</monotouch.foundation.nsnotificationeventargs>

public static class PKPassLibraryUserInfoKey {
public static MonoTouch.Foundation.NSString AddedPasses {
	get;
}
public static MonoTouch.Foundation.NSString PassTypeIdentifier {
	get;
}
public static MonoTouch.Foundation.NSString RemovedPassInfos {
	get;
}
public static MonoTouch.Foundation.NSString ReplacementPasses {
	get;
}
public static MonoTouch.Foundation.NSString SerialNumber {
	get;
}

}

Removed:

 public delegate System.Drawing.RectangleF QLFrame (QLPreviewItem item, MonoTouch.UIKit.UIView view);

Added:

 public delegate System.Drawing.RectangleF QLFrame (QLPreviewController controller, QLPreviewItem item, ref MonoTouch.UIKit.UIView view);

Removed:

 	public virtual System.Drawing.RectangleF FrameForPreviewItem (QLPreviewItem item, MonoTouch.UIKit.UIView view);
 	public virtual MonoTouch.UIKit.UIImage TransitionImageForPreviewItem (QLPreviewItem item, System.Drawing.RectangleF contentRect);

Added:

 	public virtual System.Drawing.RectangleF FrameForPreviewItem (QLPreviewController controller, QLPreviewItem item, ref MonoTouch.UIKit.UIView view);
 	public virtual MonoTouch.UIKit.UIImage TransitionImageForPreviewItem (QLPreviewController controller, QLPreviewItem item, System.Drawing.RectangleF contentRect);

Removed:

 public delegate MonoTouch.UIKit.UIImage QLTransition (QLPreviewItem item, System.Drawing.RectangleF contentRect);

Added:

 public delegate MonoTouch.UIKit.UIImage QLTransition (QLPreviewController controller, QLPreviewItem item, System.Drawing.RectangleF contentRect);

Removed:

 	PKCS1SHA1

Added:

 	PKCS1SHA1,
 	PKCS1SHA224,
 	PKCS1SHA256,
 	PKCS1SHA384,
 	PKCS1SHA512

public class SLComposeViewController : MonoTouch.UIKit.UIViewController {
public SLComposeViewController ();
public SLComposeViewController (MonoTouch.Foundation.NSCoder coder);
public SLComposeViewController (MonoTouch.Foundation.NSObjectFlag t);
public SLComposeViewController (IntPtr handle);

public static SLComposeViewController FromService (MonoTouch.Foundation.NSString serviceType);
public static SLComposeViewController FromService (SLServiceKind serviceKind);
public static bool IsAvailable (MonoTouch.Foundation.NSString serviceType);
public static bool IsAvailable (SLServiceKind serviceKind);
public virtual bool AddImage (MonoTouch.UIKit.UIImage image);
public virtual bool AddUrl (MonoTouch.Foundation.NSUrl url);
protected override void Dispose (bool disposing);
public virtual bool RemoveAllImages ();
public virtual bool RemoveAllUrls ();
public virtual bool SetInitialText (string text);

public override IntPtr ClassHandle {
	get;
}
public virtual Action<slcomposeviewcontrollerresult> CompletionHandler {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSString ServiceType {
	get;
}

}

[Serializable]
public enum SLComposeViewControllerResult {
	Cancelled,
	Done
}

public class SLRequest : MonoTouch.Foundation.NSObject {
public SLRequest (MonoTouch.Foundation.NSCoder coder);
public SLRequest (MonoTouch.Foundation.NSObjectFlag t);
public SLRequest (IntPtr handle);

public static SLRequest Create (MonoTouch.Foundation.NSString serviceType, SLRequestMethod requestMethod, MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary parameters);
public static SLRequest Create (SLServiceKind serviceKind, SLRequestMethod method, MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary parameters);
public virtual void AddMultipartData (MonoTouch.Foundation.NSData data, string partName, string partType, string filename);
protected override void Dispose (bool disposing);
public virtual MonoTouch.Foundation.NSUrlRequest GetPreparedUrlRequest ();
public virtual void PerformRequest (System.Action<monotouch.foundation.nsdata,monotouch.foundation.nshttpurlresponse,monotouch.foundation.nserror> handler);

public virtual MonoTouch.Accounts.ACAccount Account {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSDictionary Parameters {
	get;
}
public virtual SLRequestMethod RequestMethod {
	get;
}
public virtual MonoTouch.Foundation.NSUrl Url {
	get;
}

}
</monotouch.foundation.nsdata,monotouch.foundation.nshttpurlresponse,monotouch.foundation.nserror>

[Serializable]
public enum SLRequestMethod {
	Get,
	Post,
	Delete
}

[Serializable]
public enum SLServiceKind {
	Facebook,
	Twitter,
	SinaWeibo
}

public static class SLServiceType {
public static MonoTouch.Foundation.NSString Facebook {
	get;
}
public static MonoTouch.Foundation.NSString SinaWeibo {
	get;
}
public static MonoTouch.Foundation.NSString Twitter {
	get;
}

}

public class SKDownload : MonoTouch.Foundation.NSObject {
public SKDownload ();
public SKDownload (MonoTouch.Foundation.NSCoder coder);
public SKDownload (MonoTouch.Foundation.NSObjectFlag t);
public SKDownload (IntPtr handle);

protected override void Dispose (bool disposing);

public static double TimeRemainingUnknown {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual string ContentIdentifier {
	get;
}
public virtual long ContentLength {
	get;
}
public virtual MonoTouch.Foundation.NSUrl ContentUrl {
	get;
}
public virtual string ContentVersion {
	get;
}
public virtual SKDownloadState DownloadState {
	get;
}
public virtual MonoTouch.Foundation.NSError Error {
	get;
}
public virtual float Progress {
	get;
}
public virtual double TimeRemaining {
	get;
}
public virtual SKPaymentTransaction Transaction {
	get;
}

}

[Serializable]
public enum SKDownloadState {
	Waiting,
	Active,
	Paused,
	Finished,
	Failed,
	Cancelled
}

Removed:

 	PaymentNotAllowed

Added:

 	PaymentNotAllowed,
 	ProductNotAvailable

Added:

 	public virtual void CancelDownloads (SKDownload[] downloads);
 	public virtual void PauseDownloads (SKDownload[] downloads);
 	public virtual void ResumeDownloads (SKDownload[] downloads);
 	public virtual void StartDownloads (SKDownload[] downloads);

Added:

 	public virtual SKDownload[] Downloads {
 		get;
 	}

Added:

 	public virtual void PaymentQueueUpdatedDownloads (SKPaymentQueue queue, SKDownload[] downloads);

Added:

 	public virtual bool Downloadable {
 		get;
 	}
 	public virtual MonoTouch.Foundation.NSNumber[] DownloadContentLengths {
 		get;
 	}
 	public virtual string DownloadContentVersion {
 		get;
 	}

public static class SKStoreProductParameterKey {
public static MonoTouch.Foundation.NSString ITunesItemIdentifier {
	get;
}

}

public class SKStoreProductViewController : MonoTouch.UIKit.UIViewController {
public SKStoreProductViewController ();
public SKStoreProductViewController (MonoTouch.Foundation.NSCoder coder);
public SKStoreProductViewController (MonoTouch.Foundation.NSObjectFlag t);
public SKStoreProductViewController (IntPtr handle);

protected override void Dispose (bool disposing);
public void LoadProduct (StoreProductParameters parameters, System.Action<bool,monotouch.foundation.nserror> callback);

public override IntPtr ClassHandle {
	get;
}
public SKStoreProductViewControllerDelegate Delegate {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public event EventHandler Finished;

}
</bool,monotouch.foundation.nserror>

public class SKStoreProductViewControllerDelegate : MonoTouch.Foundation.NSObject {
public SKStoreProductViewControllerDelegate ();
public SKStoreProductViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
public SKStoreProductViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
public SKStoreProductViewControllerDelegate (IntPtr handle);

public virtual void Finished (SKStoreProductViewController controller);

}

public class StoreProductParameters : MonoTouch.Foundation.DictionaryContainer {
public StoreProductParameters ();
public StoreProductParameters (MonoTouch.Foundation.NSDictionary dictionary);
public StoreProductParameters (int iTunesItemIdentifier);

public Nullable<int> ITunesItemIdentifier {
	get;
	set;
}

}

Removed:

 	ConnectionNoService

Added:

 	ConnectionNoService,
 	ConnectionIgnore

[Serializable]
public enum NSLayoutAttribute {
	NoAttribute,
	Left,
	Right,
	Top,
	Bottom,
	Leading,
	Trailing,
	Width,
	Height,
	CenterX,
	CenterY,
	Baseline
}

public class NSLayoutConstraint : MonoTouch.Foundation.NSObject {
public NSLayoutConstraint ();
public NSLayoutConstraint (MonoTouch.Foundation.NSCoder coder);
public NSLayoutConstraint (MonoTouch.Foundation.NSObjectFlag t);
public NSLayoutConstraint (IntPtr handle);

public static NSLayoutConstraint Create (MonoTouch.Foundation.NSObject view1, NSLayoutAttribute attribute1, NSLayoutRelation relation, MonoTouch.Foundation.NSObject view2, NSLayoutAttribute attribute2, float multiplier, float constant);
public static NSLayoutConstraint[] FromVisualFormat (string format, NSLayoutFormatOptions formatOptions, MonoTouch.Foundation.NSDictionary metrics, MonoTouch.Foundation.NSDictionary views);
protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual float Constant {
	get;
	set;
}
public virtual NSLayoutAttribute FirstAttribute {
	get;
}
public virtual MonoTouch.Foundation.NSObject FirstItem {
	get;
}
public virtual float Multiplier {
	get;
}
public virtual UILayoutPriority Priority {
	get;
	set;
}
public virtual NSLayoutRelation Relation {
	get;
}
public virtual NSLayoutAttribute SecondAttribute {
	get;
}
public virtual MonoTouch.Foundation.NSObject SecondItem {
	get;
}
public virtual bool ShouldBeArchived {
	get;
	set;
}

}

[Serializable]
public enum NSLayoutFormatOptions {
	AlignAllLeft,
	AlignAllRight,
	AlignAllTop,
	AlignAllBottom,
	AlignAllLeading,
	AlignAllTrailing,
	AlignAllCenterX,
	AlignAllCenterY,
	AlignAllBaseline,
	AlignmentMask,
	DirectionLeadingToTrailing,
	DirectionLeftToRight,
	DirectionRightToLeft,
	DirectionMask
}

[Serializable]
public enum NSLayoutRelation {
	LessThanOrEqual,
	Equal,
	GreaterThanOrEqual
}

public class NSMutableParagraphStyle : NSParagraphStyle {
public NSMutableParagraphStyle ();
public NSMutableParagraphStyle (MonoTouch.Foundation.NSCoder coder);
public NSMutableParagraphStyle (MonoTouch.Foundation.NSObjectFlag t);
public NSMutableParagraphStyle (IntPtr handle);

public override UITextAlignment Alignment {
	get;
	set;
}
public override MonoTouch.Foundation.NSWritingDirection BaseWritingDirection {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public override float FirstLineHeadIndent {
	get;
	set;
}
public override float HeadIndent {
	get;
	set;
}
public override float HyphenationFactor {
	get;
	set;
}
public override UILineBreakMode LineBreakMode {
	get;
	set;
}
public override float LineHeightMultiple {
	get;
	set;
}
public override float LineSpacing {
	get;
	set;
}
public override float MaximumLineHeight {
	get;
	set;
}
public override float MinimumLineHeight {
	get;
	set;
}
public override float ParagraphSpacing {
	get;
	set;
}
public override float ParagraphSpacingBefore {
	get;
	set;
}
public override float TailIndent {
	get;
	set;
}

}

public class NSParagraphStyle : MonoTouch.Foundation.NSObject {
public NSParagraphStyle ();
public NSParagraphStyle (MonoTouch.Foundation.NSCoder coder);
public NSParagraphStyle (MonoTouch.Foundation.NSObjectFlag t);
public NSParagraphStyle (IntPtr handle);

public static MonoTouch.Foundation.NSWritingDirection GetDefaultWritingDirection (string languageName);

public static NSParagraphStyle Default {
	get;
}
public virtual UITextAlignment Alignment {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSWritingDirection BaseWritingDirection {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual float FirstLineHeadIndent {
	get;
	set;
}
public virtual float HeadIndent {
	get;
	set;
}
public virtual float HyphenationFactor {
	get;
	set;
}
public virtual UILineBreakMode LineBreakMode {
	get;
	set;
}
public virtual float LineHeightMultiple {
	get;
	set;
}
public virtual float LineSpacing {
	get;
	set;
}
public virtual float MaximumLineHeight {
	get;
	set;
}
public virtual float MinimumLineHeight {
	get;
	set;
}
public virtual float ParagraphSpacing {
	get;
	set;
}
public virtual float ParagraphSpacingBefore {
	get;
	set;
}
public virtual float TailIndent {
	get;
	set;
}

}

public class NSShadow : MonoTouch.Foundation.NSObject {
public NSShadow ();
public NSShadow (MonoTouch.Foundation.NSCoder coder);
public NSShadow (MonoTouch.Foundation.NSObjectFlag t);
public NSShadow (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual float ShadowBlurRadius {
	get;
	set;
}
public virtual UIColor ShadowColor {
	get;
	set;
}
public virtual System.Drawing.SizeF ShadowOffset {
	get;
	set;
}

}

public class UIActivity : MonoTouch.Foundation.NSObject {
public UIActivity ();
public UIActivity (MonoTouch.Foundation.NSCoder coder);
public UIActivity (MonoTouch.Foundation.NSObjectFlag t);
public UIActivity (IntPtr handle);

public virtual bool CanPerform (MonoTouch.Foundation.NSObject[] activityItems);
protected override void Dispose (bool disposing);
public virtual void Finished (bool completed);
public virtual void Perform ();
public virtual void Prepare (MonoTouch.Foundation.NSObject[] activityItems);

public override IntPtr ClassHandle {
	get;
}
public virtual UIImage Image {
	get;
}
public virtual string Title {
	get;
}
public virtual MonoTouch.Foundation.NSString Type {
	get;
}
public virtual UIViewController ViewController {
	get;
}

}

public class UIActivityItemProvider : MonoTouch.Foundation.NSOperation {
public UIActivityItemProvider ();
public UIActivityItemProvider (MonoTouch.Foundation.NSCoder coder);
public UIActivityItemProvider (MonoTouch.Foundation.NSObjectFlag t);
public UIActivityItemProvider (IntPtr handle);
public UIActivityItemProvider (MonoTouch.Foundation.NSObject placeholderItem);

protected override void Dispose (bool disposing);

public virtual MonoTouch.Foundation.NSString ActivityType {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSObject Item {
	get;
}
public virtual MonoTouch.Foundation.NSObject PlaceholderItem {
	get;
}

}

public abstract class UIActivityItemSource : MonoTouch.Foundation.NSObject {
public UIActivityItemSource ();
public UIActivityItemSource (MonoTouch.Foundation.NSCoder coder);
public UIActivityItemSource (MonoTouch.Foundation.NSObjectFlag t);
public UIActivityItemSource (IntPtr handle);

public abstract MonoTouch.Foundation.NSObject GetItemForActivity (UIActivityViewController activityViewController, string activityType);
public abstract MonoTouch.Foundation.NSObject GetPlaceholderData (UIActivityViewController activityViewController);

}

public static class UIActivityType {
public static MonoTouch.Foundation.NSString AssignToContact {
	get;
}
public static MonoTouch.Foundation.NSString CopyToPasteboard {
	get;
}
public static MonoTouch.Foundation.NSString Mail {
	get;
}
public static MonoTouch.Foundation.NSString Message {
	get;
}
public static MonoTouch.Foundation.NSString PostToFacebook {
	get;
}
public static MonoTouch.Foundation.NSString PostToTwitter {
	get;
}
public static MonoTouch.Foundation.NSString PostToWeibo {
	get;
}
public static MonoTouch.Foundation.NSString Print {
	get;
}
public static MonoTouch.Foundation.NSString SaveToCameraRoll {
	get;
}

}

public class UIActivityViewController : UIViewController {
public UIActivityViewController ();
public UIActivityViewController (MonoTouch.Foundation.NSCoder coder);
public UIActivityViewController (MonoTouch.Foundation.NSObjectFlag t);
public UIActivityViewController (IntPtr handle);
public UIActivityViewController (MonoTouch.Foundation.NSObject[] activityItems, UIActivity[] applicationActivities);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual System.Action<monotouch.foundation.nsstring,bool> CompletionHandler {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSString[] ExcludedActivityTypes {
	get;
	set;
}

}
</monotouch.foundation.nsstring,bool>

Added:

 	public virtual void CompleteStateRestoration ();
 	public virtual void ExtendStateRestoration ();
 	public virtual UIInterfaceOrientationMask SupportedInterfaceOrientationsForWindow (UIWindow window);
 	public static MonoTouch.Foundation.NSString UITrackingRunLoopMode {
 		get;
 	}

Added:

 	public virtual void DidDecodeRestorableState (UIApplication application, MonoTouch.Foundation.NSCoder coder);
 	public virtual UIInterfaceOrientationMask GetSupportedInterfaceOrientations (UIApplication application, UIWindow forWindow);
 	public virtual UIViewController GetViewController (UIApplication application, string [] restorationIdentifierComponents, MonoTouch.Foundation.NSCoder coder);
 	public virtual bool ShouldRestoreApplicationState (UIApplication application, MonoTouch.Foundation.NSCoder coder);
 	public virtual bool ShouldSaveApplicationState (UIApplication application, MonoTouch.Foundation.NSCoder coder);
 	public virtual void WillEncodeRestorableState (UIApplication application, MonoTouch.Foundation.NSCoder coder);
 	public virtual bool WillFinishLaunching (UIApplication application, MonoTouch.Foundation.NSDictionary launchOptions);

Added:

 	public virtual UIImage GetBackgroundImage (UIControlState state, UIBarButtonItemStyle style, UIBarMetrics barMetrics);
 	public virtual void SetBackgroundImage (UIImage backgroundImage, UIControlState state, UIBarButtonItemStyle style, UIBarMetrics barMetrics);
 		public virtual UIImage GetBackgroundImage (UIControlState state, UIBarButtonItemStyle style, UIBarMetrics barMetrics);
 		public virtual void SetBackgroundImage (UIImage backgroundImage, UIControlState state, UIBarButtonItemStyle style, UIBarMetrics barMetrics);

Added:

 	public virtual UIBezierPath BezierPathByReversingPath ();

Added:

 	public virtual MonoTouch.Foundation.NSAttributedString GetAttributedTitle (UIControlState state);
 	public virtual void SetAttributedTitle (MonoTouch.Foundation.NSAttributedString title, UIControlState state);
 	public virtual MonoTouch.Foundation.NSAttributedString CurrentAttributedTitle {
 		get;
 	}

[Serializable]
public enum UICollectionElementCategory {
	Cell,
	SupplementaryView,
	DecorationView
}

public class UICollectionReusableView : UIView {
public UICollectionReusableView ();
public UICollectionReusableView (MonoTouch.Foundation.NSCoder coder);
public UICollectionReusableView (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionReusableView (IntPtr handle);
public UICollectionReusableView (System.Drawing.RectangleF frame);

public static UICollectionReusableViewAppearance AppearanceWhenContainedIn (params Type [] containers);
public virtual void ApplyLayoutAttributes (UICollectionViewLayoutAttributes layoutAttributes);
public virtual void DidTransition (UICollectionViewLayout oldLayout, UICollectionViewLayout newLayout);
protected override void Dispose (bool disposing);
public virtual void PrepareForReuse ();
public virtual void WillTransition (UICollectionViewLayout oldLayout, UICollectionViewLayout newLayout);

public static UICollectionReusableViewAppearance Appearance {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSString ReuseIdentifier {
	get;
}

public class UICollectionReusableViewAppearance : UIViewAppearance {
}

}

[Serializable]
public enum UICollectionUpdateAction {
	Insert,
	Delete,
	Reload,
	Move,
	None
}

public class UICollectionView : UIScrollView {
public UICollectionView (MonoTouch.Foundation.NSCoder coder);
public UICollectionView (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionView (IntPtr handle);
public UICollectionView (System.Drawing.RectangleF frame, UICollectionViewLayout layout);

public static UICollectionViewAppearance AppearanceWhenContainedIn (params Type [] containers);
public virtual UICollectionViewCell CellForItem (MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void DeleteItems (MonoTouch.Foundation.NSIndexPath[] indexPaths);
public virtual void DeleteSections (MonoTouch.Foundation.NSIndexSet sections);
public virtual MonoTouch.Foundation.NSObject DequeueReusableCell (MonoTouch.Foundation.NSString reuseIdentifier, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual MonoTouch.Foundation.NSObject DequeueReusableSupplementaryView (MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSString identifier, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void DeselectItem (MonoTouch.Foundation.NSIndexPath indexPath, bool animated);
protected override void Dispose (bool disposing);
public virtual MonoTouch.Foundation.NSIndexPath[] GetIndexPathsForSelectedItems ();
public virtual UICollectionViewLayoutAttributes GetLayoutAttributesForItem (MonoTouch.Foundation.NSIndexPath indexPath);
public virtual UICollectionViewLayoutAttributes GetLayoutAttributesForSupplementaryElement (MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual MonoTouch.Foundation.NSIndexPath IndexPathForCell (UICollectionViewCell cell);
public virtual MonoTouch.Foundation.NSIndexPath IndexPathForItemAtPoint (System.Drawing.PointF point);
public virtual void InsertItems (MonoTouch.Foundation.NSIndexPath[] indexPaths);
public virtual void InsertSections (MonoTouch.Foundation.NSIndexSet sections);
public virtual void MoveItem (MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSIndexPath newIndexPath);
public virtual void MoveSection (int section, int newSection);
public virtual int NumberOfItemsInSection (int section);
public virtual int NumberOfSections ();
public virtual void PerformBatchUpdates (MonoTouch.Foundation.NSAction updates, UICompletionHandler completed);
public void RegisterClassForCell (Type cellType, MonoTouch.Foundation.NSString reuseIdentifier);
public void RegisterClassForSupplementaryView (Type cellType, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSString reuseIdentifier);
public virtual void RegisterNibForCell (UINib nib, MonoTouch.Foundation.NSString reuseIdentifier);
public virtual void RegisterNibForSupplementaryView (UINib nib, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSString reuseIdentifier);
public virtual void ReloadData ();
public virtual void ReloadItems (MonoTouch.Foundation.NSIndexPath[] indexPaths);
public virtual void ReloadSections (MonoTouch.Foundation.NSIndexSet sections);
public virtual void ScrollToItem (MonoTouch.Foundation.NSIndexPath indexPath, UICollectionViewScrollPosition scrollPosition, bool animated);
public virtual void SelectItem (MonoTouch.Foundation.NSIndexPath indexPath, bool animated, UICollectionViewScrollPosition scrollPosition);
public virtual void SetCollectionViewLayout (UICollectionViewLayout layout, bool animated);

public static UICollectionViewAppearance Appearance {
	get;
}
public virtual bool AllowsMultipleSelection {
	get;
	set;
}
public virtual bool AllowsSelection {
	get;
	set;
}
public virtual UIView BackgroundView {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual UICollectionViewLayout CollectionViewLayout {
	get;
	set;
}
public UICollectionViewDataSource DataSource {
	get;
	set;
}
public UICollectionViewDelegate Delegate {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSIndexPath[] IndexPathsForVisibleItems {
	get;
}
public UICollectionViewSource Source {
	get;
	set;
}
public virtual UICollectionViewCell[] VisibleCells {
	get;
}
public virtual MonoTouch.Foundation.NSObject WeakDataSource {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSObject WeakDelegate {
	get;
	set;
}

public class UICollectionViewAppearance : UIScrollViewAppearance {
}

}

public class UICollectionViewCell : UICollectionReusableView {
public UICollectionViewCell ();
public UICollectionViewCell (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewCell (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewCell (IntPtr handle);
public UICollectionViewCell (System.Drawing.RectangleF frame);

public static UICollectionViewCellAppearance AppearanceWhenContainedIn (params Type [] containers);
protected override void Dispose (bool disposing);

public static UICollectionViewCellAppearance Appearance {
	get;
}
public virtual UIView BackgroundView {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual UIView ContentView {
	get;
}
public virtual bool Highlighted {
	get;
	set;
}
public virtual bool Selected {
	get;
	set;
}
public virtual UIView SelectedBackgroundView {
	get;
	set;
}

public class UICollectionViewCellAppearance : UICollectionReusableViewAppearance {
}

}

public class UICollectionViewController : UIViewController {
public UICollectionViewController ();
public UICollectionViewController (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewController (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewController (IntPtr handle);
public UICollectionViewController (string nibName, MonoTouch.Foundation.NSBundle bundle);
public UICollectionViewController (UICollectionViewLayout layout);

public virtual bool CanPerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual void CellDisplayingEnded (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
protected override void Dispose (bool disposing);
public virtual UICollectionViewCell GetCell (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual int GetItemsCount (UICollectionView collectionView, int section);
public virtual UICollectionReusableView GetViewForSupplementaryElement (UICollectionView collectionView, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemDeselected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemHighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemSelected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemUnhighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual int NumberOfSections (UICollectionView collectionView);
public virtual void PerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual bool ShouldDeselectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldHighlightItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldSelectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldShowMenu (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void SupplementaryViewDisplayingEnded (UICollectionView collectionView, UICollectionReusableView view, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

public override IntPtr ClassHandle {
	get;
}
public virtual bool ClearsSelectionOnViewWillAppear {
	get;
	set;
}
public virtual UICollectionView CollectionView {
	get;
	set;
}

}

public abstract class UICollectionViewDataSource : MonoTouch.Foundation.NSObject {
public UICollectionViewDataSource ();
public UICollectionViewDataSource (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewDataSource (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewDataSource (IntPtr handle);

public abstract UICollectionViewCell GetCell (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public abstract int GetItemsCount (UICollectionView collectionView, int section);
public virtual UICollectionReusableView GetViewForSupplementaryElement (UICollectionView collectionView, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual int NumberOfSections (UICollectionView collectionView);

}

public class UICollectionViewDelegate : MonoTouch.Foundation.NSObject {
public UICollectionViewDelegate ();
public UICollectionViewDelegate (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewDelegate (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewDelegate (IntPtr handle);

public virtual bool CanPerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual void CellDisplayingEnded (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemDeselected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemHighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemSelected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemUnhighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void PerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual bool ShouldDeselectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldHighlightItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldSelectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldShowMenu (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void SupplementaryViewDisplayingEnded (UICollectionView collectionView, UICollectionReusableView view, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

}

public class UICollectionViewDelegateFlowLayout : UICollectionViewDelegate {
public UICollectionViewDelegateFlowLayout ();
public UICollectionViewDelegateFlowLayout (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewDelegateFlowLayout (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewDelegateFlowLayout (IntPtr handle);

public override bool CanPerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public override void CellDisplayingEnded (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual UIEdgeInsets GetInsetForSection (UICollectionView collectionView, UICollectionViewLayout layout, int section);
public virtual float GetMinimumInteritemSpacingForSection (UICollectionView collectionView, UICollectionViewLayout layout, int section);
public virtual float GetMinimumLineSpacingForSection (UICollectionView collectionView, UICollectionViewLayout layout, int section);
public virtual System.Drawing.SizeF GetReferenceSizeForFooter (UICollectionView collectionView, UICollectionViewLayout layout, int section);
public virtual System.Drawing.SizeF GetReferenceSizeForHeader (UICollectionView collectionView, UICollectionViewLayout layout, int section);
public virtual System.Drawing.SizeF GetSizeForItem (UICollectionView collectionView, UICollectionViewLayout layout, MonoTouch.Foundation.NSIndexPath indexPath);
public override void ItemDeselected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override void ItemHighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override void ItemSelected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override void ItemUnhighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override void PerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public override bool ShouldDeselectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override bool ShouldHighlightItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override bool ShouldSelectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override bool ShouldShowMenu (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public override void SupplementaryViewDisplayingEnded (UICollectionView collectionView, UICollectionReusableView view, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

}

public class UICollectionViewFlowLayout : UICollectionViewLayout {
public UICollectionViewFlowLayout ();
public UICollectionViewFlowLayout (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewFlowLayout (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewFlowLayout (IntPtr handle);

public override IntPtr ClassHandle {
	get;
}
public virtual System.Drawing.SizeF FooterReferenceSize {
	get;
	set;
}
public virtual System.Drawing.SizeF HeaderReferenceSize {
	get;
	set;
}
public virtual System.Drawing.SizeF ItemSize {
	get;
	set;
}
public virtual float MinimumInteritemSpacing {
	get;
	set;
}
public virtual float MinimumLineSpacing {
	get;
	set;
}
public virtual UICollectionViewScrollDirection ScrollDirection {
	get;
	set;
}
public virtual UIEdgeInsets SectionInset {
	get;
	set;
}

}

public class UICollectionViewLayout : MonoTouch.Foundation.NSObject {
public UICollectionViewLayout ();
public UICollectionViewLayout (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewLayout (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewLayout (IntPtr handle);

protected override void Dispose (bool disposing);
public virtual void FinalizeAnimatedBoundsChange ();
public virtual void FinalizeCollectionViewUpdates ();
public virtual UICollectionViewLayoutAttributes FinalLayoutAttributesForDeletedItem (MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual UICollectionViewLayoutAttributes FinalLayoutAttributesForDeletedSupplementaryElement (string elementKind, MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual UICollectionViewLayoutAttributes FinalLayoutAttributesForDisappearingDecorationElement (string elementKind, MonoTouch.Foundation.NSIndexPath decorationIndexPath);
public virtual UICollectionViewLayoutAttributes FinalLayoutAttributesForDisappearingItem (MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual UICollectionViewLayoutAttributes FinalLayoutAttributesForDisappearingSupplementaryElement (string elementKind, MonoTouch.Foundation.NSIndexPath elementIndexPath);
public virtual UICollectionViewLayoutAttributes InitialLayoutAttributesForAppearingDecorationElement (string elementKind, MonoTouch.Foundation.NSIndexPath decorationIndexPath);
public virtual UICollectionViewLayoutAttributes InitialLayoutAttributesForAppearingItem (MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual UICollectionViewLayoutAttributes InitialLayoutAttributesForAppearingSupplementaryElement (string elementKind, MonoTouch.Foundation.NSIndexPath elementIndexPath);
public virtual UICollectionViewLayoutAttributes InitialLayoutAttributesForInsertedItem (MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual UICollectionViewLayoutAttributes InitialLayoutAttributesForInsertedSupplementaryELement (string elementKind, MonoTouch.Foundation.NSIndexPath itemIndexPath);
public virtual void InvalidateLayout ();
public virtual UICollectionViewLayoutAttributes LayoutAttributesForDecorationView (string decorationViewKind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual UICollectionViewLayoutAttributes[] LayoutAttributesForElementsInRect (System.Drawing.RectangleF rect);
public virtual UICollectionViewLayoutAttributes LayoutAttributesForItem (MonoTouch.Foundation.NSIndexPath indexPath);
public virtual UICollectionViewLayoutAttributes LayoutAttributesForSupplementaryView (MonoTouch.Foundation.NSString kind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void PrepareForAnimatedBoundsChange (System.Drawing.RectangleF oldBounds);
public virtual void PrepareForCollectionViewUpdates (UICollectionViewUpdateItem[] updateItems);
public virtual void PrepareLayout ();
public void RegisterClassForDecorationView (Type viewType, MonoTouch.Foundation.NSString reuseIdentifier);
public virtual void RegisterNibForDecorationView (UINib nib, MonoTouch.Foundation.NSString decorationViewKind);
public virtual bool ShouldInvalidateLayoutForBoundsChange (System.Drawing.RectangleF newBounds);
public virtual System.Drawing.PointF TargetContentOffset (System.Drawing.PointF proposedContentOffset, System.Drawing.PointF scrollingVelocity);

public static MonoTouch.ObjCRuntime.Class LayoutAttributesClass {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual UICollectionView CollectionView {
	get;
}
public virtual System.Drawing.SizeF CollectionViewContentSize {
	get;
}

}

public class UICollectionViewLayoutAttributes : MonoTouch.Foundation.NSObject {
public UICollectionViewLayoutAttributes ();
public UICollectionViewLayoutAttributes (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewLayoutAttributes (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewLayoutAttributes (IntPtr handle);

public static UICollectionViewLayoutAttributes CreateForCell (MonoTouch.Foundation.NSIndexPath indexPath);
public static UICollectionViewLayoutAttributes CreateForDecorationView (string decorationViewKind, MonoTouch.Foundation.NSIndexPath indexPath);
public static UICollectionViewLayoutAttributes CreateForSupplementaryView (string elementKind, MonoTouch.Foundation.NSIndexPath indexPath);
protected override void Dispose (bool disposing);

public virtual float Alpha {
	get;
	set;
}
public virtual System.Drawing.PointF Center {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual System.Drawing.RectangleF Frame {
	get;
	set;
}
public virtual bool Hidden {
	get;
	set;
}
public virtual MonoTouch.Foundation.NSIndexPath IndexPath {
	get;
	set;
}
public virtual UICollectionElementCategory RepresentedElementCategory {
	get;
}
public virtual string RepresentedElementKind {
	get;
}
public virtual System.Drawing.SizeF Size {
	get;
	set;
}
public virtual MonoTouch.CoreAnimation.CATransform3D Transform3D {
	get;
	set;
}
public virtual int ZIndex {
	get;
	set;
}

}

[Serializable]
public enum UICollectionViewScrollDirection {
	Vertical,
	Horizontal
}

[Serializable]
[Flags]
public enum UICollectionViewScrollPosition {
	None,
	Top,
	CenteredVertically,
	Bottom,
	Left,
	CenteredHorizontally,
	Right
}

public class UICollectionViewSource : MonoTouch.Foundation.NSObject {
public UICollectionViewSource ();
public UICollectionViewSource (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewSource (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewSource (IntPtr handle);

public virtual bool CanPerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual void CellDisplayingEnded (UICollectionView collectionView, UICollectionViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual UICollectionViewCell GetCell (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual int GetItemsCount (UICollectionView collectionView, int section);
public virtual UICollectionReusableView GetViewForSupplementaryElement (UICollectionView collectionView, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemDeselected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemHighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemSelected (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void ItemUnhighlighted (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual int NumberOfSections (UICollectionView collectionView);
public virtual void PerformAction (UICollectionView collectionView, MonoTouch.ObjCRuntime.Selector action, MonoTouch.Foundation.NSIndexPath indexPath, MonoTouch.Foundation.NSObject sender);
public virtual bool ShouldDeselectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldHighlightItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldSelectItem (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual bool ShouldShowMenu (UICollectionView collectionView, MonoTouch.Foundation.NSIndexPath indexPath);
public virtual void SupplementaryViewDisplayingEnded (UICollectionView collectionView, UICollectionReusableView view, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

}

public class UICollectionViewUpdateItem : MonoTouch.Foundation.NSObject {
public UICollectionViewUpdateItem ();
public UICollectionViewUpdateItem (MonoTouch.Foundation.NSCoder coder);
public UICollectionViewUpdateItem (MonoTouch.Foundation.NSObjectFlag t);
public UICollectionViewUpdateItem (IntPtr handle);

protected override void Dispose (bool disposing);

public override IntPtr ClassHandle {
	get;
}
public virtual MonoTouch.Foundation.NSIndexPath IndexPathAfterUpdate {
	get;
}
public virtual MonoTouch.Foundation.NSIndexPath IndexPathBeforeUpdate {
	get;
}
public virtual UICollectionUpdateAction UpdateAction {
	get;
}

}

Removed:

 	[Obsolete("Deprecated in iOS 5.0")]
	public virtual MonoTouch.Foundation.NSLocale Locale {

Added:

 	public virtual MonoTouch.Foundation.NSLocale Locale {

Added:

 	protected override void Dispose (bool disposing);
 	public virtual MonoTouch.Foundation.NSUuid IdentifierForVendor {
 		get;
 	}

Removed:

 	public virtual bool CanPerformAction (UIDocumentInteractionController controller, MonoTouch.ObjCRuntime.Selector action);
 	public virtual bool PerformAction (UIDocumentInteractionController controller, MonoTouch.ObjCRuntime.Selector action);

Added:

 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool CanPerformAction (UIDocumentInteractionController controller, MonoTouch.ObjCRuntime.Selector action);
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool PerformAction (UIDocumentInteractionController controller, MonoTouch.ObjCRuntime.Selector action);

Added:

 	public UIImage (MonoTouch.Foundation.NSData data, float scale);
 	public UIImage (MonoTouch.CoreImage.CIImage ciImage, float scale, UIImageOrientation orientation);
 	public UIImage (UIEdgeInsets capInsets, UIImageResizingMode resizingMode);
 	public static UIImage CreateAnimatedImage (string name, UIEdgeInsets capInsets, UIImageResizingMode resizingMode, double duration);
 	public static UIImage FromImage (MonoTouch.CoreImage.CIImage ciImage, float scale, UIImageOrientation orientation);
 	public static UIImage LoadFromData (MonoTouch.Foundation.NSData data, float scale);
 	public virtual UIImage ImageWithAlignmentRectInsets (UIEdgeInsets alignmentInsets);
 	public virtual UIEdgeInsets AlignmentRectInsets {
 		get;
 	}
 	public virtual UIImageResizingMode ResizingMode {
 		get;
 	}

[Serializable]
public enum UIImageResizingMode {
	Tile,
	Stretch
}

[Serializable]
[Flags]
public enum UIInterfaceOrientationMask {
	Portrait,
	LandscapeLeft,
	LandscapeRight,
	PortraitUpsideDown,
	Landscape,
	All,
	AllButUpsideDown
}

Removed:

 public class UIKeyboard {
public UIKeyboard ();

Added:

 public static class UIKeyboard {

Removed:

 	public virtual float MinimumFontSize {

Added:

 	public virtual bool AdjustsLetterSpacingToFitWidth {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSAttributedString AttributedText {
 		get;
 		set;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual float MinimumFontSize {
 		get;
 		set;
 	}
 	public virtual float MinimumScaleFactor {
 		get;
 		set;
 	}
 	public virtual float PreferredMaxLayoutWidth {

[Serializable]
public enum UILayoutConstraintAxis {
	Horizontal,
	Vertical
}

[Serializable]
public enum UILayoutPriority {
	Required,
	DefaultHigh,
	DefaultLow,
	FittingSizeLevel
}

Added:

 	public virtual UIImage ShadowImage {
 		get;
 		set;
 	}
 		public virtual UIImage ShadowImage {
 			get;
 			set;
 		}

Added:

 	public UINavigationController (Type navigationBarType, Type toolbarType);

Added:

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

Added:

 	protected override void Dispose (bool disposing);
 	public virtual UIColor CurrentPageIndicatorTintColor {
 		get;
 		set;
 	}
 	public virtual UIColor PageIndicatorTintColor {
 		get;
 		set;
 	}
	public virtual UIColor CurrentPageIndicatorTintColor {
		get;
		set;
	}
	public virtual UIColor PageIndicatorTintColor {
		get;
		set;
	}

Added:

 	public UIPageViewController (UIPageViewControllerTransitionStyle style, UIPageViewControllerNavigationOrientation navigationOrientation, UIPageViewControllerSpineLocation spineLocation, float interPageSpacing);
 	public UIPageViewGetNumber GetPresentationCount {
 		get;
 		set;
 	}
 	public UIPageViewGetNumber GetPresentationIndex {
 		get;
 		set;
 	}
 	public event EventHandler<UIPageViewControllerTransitionEventArgs> WillTransition;

Added:

 	public virtual int GetPresentationCount (UIPageViewController pageViewController);
 	public virtual int GetPresentationIndex (UIPageViewController pageViewController);

Added:

 	public virtual void WillTransition (UIPageViewController pageViewController, UIViewController[] pendingViewControllers);

public class UIPageViewControllerTransitionEventArgs : EventArgs {
public UIPageViewControllerTransitionEventArgs (UIViewController[] pendingViewControllers);

public UIViewController[] PendingViewControllers {
	get;
	set;
}

}

Removed:

 	PageCurl

Added:

 	PageCurl,
 	Scroll

[Serializable]
public delegate int UIPageViewGetNumber (UIPageViewController pageViewController);

Added:

 	public virtual MonoTouch.Foundation.NSAttributedString GetAttributedTitle (UIPickerView pickerView, int row, int component);

Added:

 	public static bool WantsDefaultContentAppearance {
 		get;
 	}

public class UIRefreshControl : UIControl {
public UIRefreshControl ();
public UIRefreshControl (MonoTouch.Foundation.NSCoder coder);
public UIRefreshControl (MonoTouch.Foundation.NSObjectFlag t);
public UIRefreshControl (IntPtr handle);

public static UIRefreshControlAppearance AppearanceWhenContainedIn (params Type [] containers);
public virtual void BeginRefreshing ();
protected override void Dispose (bool disposing);
public virtual void EndRefreshing ();

public static UIRefreshControlAppearance Appearance {
	get;
}
public virtual MonoTouch.Foundation.NSAttributedString AttributedTitle {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual bool Refreshing {
	get;
}
public virtual UIColor TintColor {
	get;
	set;
}

public class UIRefreshControlAppearance : UIControlAppearance {
	
	public virtual MonoTouch.Foundation.NSAttributedString AttributedTitle {
		get;
		set;
	}
	public virtual UIColor TintColor {
		get;
		set;
	}
}

}

Added:

 	public virtual void ToggleBoldface (MonoTouch.Foundation.NSObject sender);
 	public virtual void ToggleItalics (MonoTouch.Foundation.NSObject sender);
 	public virtual void ToggleUnderline (MonoTouch.Foundation.NSObject sender);

Added:

 	public virtual UIImage BackgroundImage (UIControlState state);
 	protected override void Dispose (bool disposing);
 	public virtual UIImage GetDecrementImage (UIControlState state);
 	public virtual UIImage GetDividerImage (UIControlState leftState, UIControlState rightState);
 	public virtual UIImage GetIncrementImage (UIControlState state);
 	public virtual void SetBackgroundImage (UIImage image, UIControlState state);
 	public virtual void SetDecrementImage (UIImage image, UIControlState state);
 	public virtual void SetDividerImage (UIImage image, UIControlState leftState, UIControlState rightState);
 	public virtual void SetIncrementImage (UIImage image, UIControlState state);
 	public virtual UIColor TintColor {
 		get;
 		set;
 	}
	public virtual UIImage BackgroundImage (UIControlState state);
	public virtual UIImage GetDecrementImage (UIControlState state);
	public virtual UIImage GetDividerImage (UIControlState leftState, UIControlState rightState);
	public virtual UIImage GetIncrementImage (UIControlState state);
	public virtual void SetBackgroundImage (UIImage image, UIControlState state);
	public virtual void SetDecrementImage (UIImage image, UIControlState state);
	public virtual void SetDividerImage (UIImage image, UIControlState leftState, UIControlState rightState);
	public virtual void SetIncrementImage (UIImage image, UIControlState state);
	
	public virtual UIColor TintColor {
		get;
		set;
	}

Added:

 	public static UIStoryboardSegue Create (string identifier, UIViewController source, UIViewController destination, MonoTouch.Foundation.NSAction performHandler);

public static class UIStringAttributeKey {
public static readonly MonoTouch.Foundation.NSString Font;
public static readonly MonoTouch.Foundation.NSString ForegroundColor;
public static readonly MonoTouch.Foundation.NSString BackgroundColor;
public static readonly MonoTouch.Foundation.NSString StrikethroughStyle;
public static readonly MonoTouch.Foundation.NSString StrokeColor;
public static readonly MonoTouch.Foundation.NSString Shadow;
public static readonly MonoTouch.Foundation.NSString ParagraphStyle;
public static readonly MonoTouch.Foundation.NSString Ligature;
public static readonly MonoTouch.Foundation.NSString KerningAdjustment;
public static readonly MonoTouch.Foundation.NSString UnderlineStyle;
public static readonly MonoTouch.Foundation.NSString StrokeWidth;
public static readonly MonoTouch.Foundation.NSString VerticalGlyphForm;

}

public class UIStringAttributes : MonoTouch.Foundation.DictionaryContainer {
public UIStringAttributes ();
public UIStringAttributes (MonoTouch.Foundation.NSDictionary dictionary);

public UIColor BackgroundColor {
	get;
	set;
}
public UIFont Font {
	get;
	set;
}
public UIColor ForegroundColor {
	get;
	set;
}
public Nullable<float> KerningAdjustment {
	get;
	set;
}
public System.Nullable<monotouch.foundation.nsligaturetype> Ligature {
	get;
	set;
}
public NSParagraphStyle ParagraphStyle {
	get;
	set;
}
public NSShadow Shadow {
	get;
	set;
}
public System.Nullable<monotouch.foundation.nsunderlinestyle> StrikethroughStyle {
	get;
	set;
}
public UIColor StrokeColor {
	get;
	set;
}
public Nullable<float> StrokeWidth {
	get;
	set;
}
public System.Nullable<monotouch.foundation.nsunderlinestyle> UnderlineStyle {
	get;
	set;
}

}
</monotouch.foundation.nsunderlinestyle></monotouch.foundation.nsunderlinestyle></monotouch.foundation.nsligaturetype>

Added:

 	public virtual UIImage OffImage {
 		get;
 		set;
 	}
 	public virtual UIImage OnImage {
 		get;
 		set;
 	}
 	public virtual UIColor ThumbTintColor {
 		get;
 		set;
 	}
 	public virtual UIColor TintColor {
 		get;
 		set;
 	}
 		public virtual UIImage OffImage {
 			get;
 			set;
 		}
 		public virtual UIImage OnImage {
 			get;
 			set;
 		}
 		public virtual UIColor ThumbTintColor {
 			get;
 			set;
 		}
 		public virtual UIColor TintColor {
 			get;
 			set;
 		}

Added:

 	public virtual UIImage ShadowImage {
 		get;
 		set;
 	}
 		public virtual UIImage ShadowImage {
 			get;
 			set;
 		}

Removed:

 	public virtual void RegisterNibforCellReuse (UINib nib, string reuseIdentifier);

Added:

 	public virtual MonoTouch.Foundation.NSObject DequeueReusableCell (MonoTouch.Foundation.NSString reuseIdentifier, MonoTouch.Foundation.NSIndexPath indexPath);
 	public virtual MonoTouch.Foundation.NSObject DequeueReusableHeaderFooterView (MonoTouch.Foundation.NSString reuseIdentifier);
 	public virtual UITableViewHeaderFooterView GetFooterView (int section);
 	public virtual UITableViewHeaderFooterView GetHeaderView (int section);
 	public void RegisterClassForCellReuse (Type cellType, MonoTouch.Foundation.NSString reuseIdentifier);
 	public void RegisterClassForHeaderFooterViewReuse (Type cellType, MonoTouch.Foundation.NSString reuseIdentifier);
 	[Obsolete("Use RegisterNibForCellReuse")]
	public void RegisterNibforCellReuse (UINib nib, string reuseIdentifier);
 	public virtual void RegisterNibForCellReuse (UINib nib, string reuseIdentifier);
 	public virtual void RegisterNibForHeaderFooterViewReuse (UINib nib, string identifier);
 	public virtual UIColor SectionIndexColor {
 		get;
 		set;
 	}
 	public virtual UIColor SectionIndexTrackingBackgroundColor {
 		get;
 		set;
 	}
	public virtual UIColor SectionIndexColor {
		get;
		set;
	}
	public virtual UIColor SectionIndexTrackingBackgroundColor {
		get;
		set;
	}

Added:

 	public virtual UIRefreshControl RefreshControl {
 		get;
 		set;
 	}

Added:

 	public virtual void CellDisplayingEnded (UITableView tableView, UITableViewCell cell, MonoTouch.Foundation.NSIndexPath indexPath);
 	public virtual void FooterViewDisplayingEnded (UITableView tableView, UIView footerView, int section);
 	public virtual void HeaderViewDisplayingEnded (UITableView tableView, UIView headerView, int section);
 	public virtual void RowHighlighted (UITableView tableView, MonoTouch.Foundation.NSIndexPath rowIndexPath);
 	public virtual void RowUnhighlighted (UITableView tableView, MonoTouch.Foundation.NSIndexPath rowIndexPath);
 	public virtual bool ShouldHighlightRow (UITableView tableView, MonoTouch.Foundation.NSIndexPath rowIndexPath);
 	public virtual void WillDisplayFooterView (UITableView tableView, UIView footerView, int section);
 	public virtual void WillDisplayHeaderView (UITableView tableView, UIView headerView, int section);

public class UITableViewHeaderFooterView : UIView {
public UITableViewHeaderFooterView ();
public UITableViewHeaderFooterView (MonoTouch.Foundation.NSCoder coder);
public UITableViewHeaderFooterView (MonoTouch.Foundation.NSObjectFlag t);
public UITableViewHeaderFooterView (IntPtr handle);
public UITableViewHeaderFooterView (System.Drawing.RectangleF frame);
public UITableViewHeaderFooterView (MonoTouch.Foundation.NSString reuseIdentifier);

public static UITableViewHeaderFooterViewAppearance AppearanceWhenContainedIn (params Type [] containers);
protected override void Dispose (bool disposing);
public virtual void PrepareForReuse ();

public static UITableViewHeaderFooterViewAppearance Appearance {
	get;
}
public virtual UIView BackgroundView {
	get;
	set;
}
public override IntPtr ClassHandle {
	get;
}
public virtual UIView ContentView {
	get;
}
public virtual UILabel DetailTextLabel {
	get;
}
public virtual MonoTouch.Foundation.NSString ReuseIdentifier {
	get;
}
public virtual UILabel TextLabel {
	get;
}
public virtual UIColor TintColor {
	get;
}

public class UITableViewHeaderFooterViewAppearance : UIViewAppearance {
	
	public virtual UIColor TintColor {
		get;
	}
}

}

Removed:

 	Right

Added:

 	Right,
 	Justified,
 	Natural

Added:

 	public virtual System.Drawing.RectangleF GetFrameForDictationResultPlaceholder (MonoTouch.Foundation.NSObject placeholder);
 	public virtual UITextSelectionRect[] GetSelectionRects (UITextRange range);
 	public virtual MonoTouch.Foundation.NSObject InsertDictationResultPlaceholder ();
 	public virtual void RemoveDictationResultPlaceholder (MonoTouch.Foundation.NSObject placeholder, bool willInsertResult);
 	public virtual bool ShouldChangeTextInRange (UITextRange inRange, string replacementText);
 	public virtual bool AllowsEditingTextAttributes {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSAttributedString AttributedPlaceholder {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSAttributedString AttributedText {
 		get;
 		set;
 	}
 	public virtual bool ClearsOnInsertion {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSDictionary TypingAttributes {
 		get;
 		set;
 	}

public class UITextSelectionRect : MonoTouch.Foundation.NSObject {
public UITextSelectionRect ();
public UITextSelectionRect (MonoTouch.Foundation.NSCoder coder);
public UITextSelectionRect (MonoTouch.Foundation.NSObjectFlag t);
public UITextSelectionRect (IntPtr handle);

public override IntPtr ClassHandle {
	get;
}
public virtual bool ContainsEnd {
	get;
}
public virtual bool ContainsStart {
	get;
}
public virtual bool IsVertical {
	get;
}
public virtual System.Drawing.RectangleF Rect {
	get;
}
public virtual UITextWritingDirection WritingDirection {
	get;
}

}

Added:

 	public virtual System.Drawing.RectangleF GetFrameForDictationResultPlaceholder (MonoTouch.Foundation.NSObject placeholder);
 	public virtual UITextSelectionRect[] GetSelectionRects (UITextRange range);
 	public virtual MonoTouch.Foundation.NSObject InsertDictationResultPlaceholder ();
 	public virtual void RemoveDictationResultPlaceholder (MonoTouch.Foundation.NSObject placeholder, bool willInsertResult);
 	public virtual bool ShouldChangeTextInRange (UITextRange inRange, string replacementText);
 	public virtual bool AllowsEditingTextAttributes {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSAttributedString AttributedText {
 		get;
 		set;
 	}
 	public virtual bool ClearsOnInsertion {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSDictionary TypingAttributes {
 		get;
 		set;
 	}

Added:

 	public virtual UIImage GetShadowImage (UIToolbarPosition topOrBottom);
 	public virtual void SetShadowImage (UIImage shadowImage, UIToolbarPosition topOrBottom);
 		public virtual UIImage GetShadowImage (UIToolbarPosition topOrBottom);
 		public virtual void SetShadowImage (UIImage shadowImage, UIToolbarPosition topOrBottom);

Removed:

 	public static void BeginAnimations (string s, IntPtr context);
 	public virtual System.Drawing.RectangleF ContentStretch {

Added:

 	public static void BeginAnimations (string animationID, IntPtr context);
 	public static bool RequiresConstraintBasedLayout ();
 	public virtual void AddConstraint (NSLayoutConstraint constraint);
 	public virtual void AddConstraints (NSLayoutConstraint[] constraints);
 	public virtual System.Drawing.RectangleF AlignmentRectForFrame (System.Drawing.RectangleF frame);
 	public virtual UILayoutPriority ContentCompressionResistancePriority (UILayoutConstraintAxis axis);
 	public virtual UILayoutPriority ContentHuggingPriority (UILayoutConstraintAxis axis);
 	public virtual void DecodeRestorableState (MonoTouch.Foundation.NSCoder coder);
 	public virtual void EncodeRestorableState (MonoTouch.Foundation.NSCoder coder);
 	public virtual void ExerciseAmbiguityInLayout ();
 	public virtual System.Drawing.RectangleF FrameForAlignmentRect (System.Drawing.RectangleF alignmentRect);
 	public virtual bool GestureRecognizerShouldBegin (UIGestureRecognizer gestureRecognizer);
 	public virtual NSLayoutConstraint[] GetConstraintsAffectingLayout (UILayoutConstraintAxis axis);
 	public virtual void InvalidateIntrinsicContentSize ();
 	public virtual bool NeedsUpdateConstraints ();
 	public virtual void RemoveConstraint (NSLayoutConstraint constraint);
 	public virtual void RemoveConstraints (NSLayoutConstraint[] constraints);
 	public virtual void SetContentCompressionResistancePriority (UILayoutPriority priority, UILayoutConstraintAxis axis);
 	public virtual void SetContentHuggingPriority (UILayoutPriority priority, UILayoutConstraintAxis axis);
 	public virtual void SetNeedsUpdateConstraints ();
 	public virtual System.Drawing.SizeF SystemLayoutSizeFittingSize (System.Drawing.SizeF size);
 	public virtual void UpdateConstraints ();
 	public virtual void UpdateConstraintsIfNeeded ();
 	public static float NoIntrinsicMetric {
 		get;
 	}
 	public static System.Drawing.SizeF UILayoutFittingCompressedSize {
 		get;
 	}
 	public static System.Drawing.SizeF UILayoutFittingExpandedSize {
 		get;
 	}
 	public virtual UIEdgeInsets AlignmentRectInsets {
 		get;
 	}
 	public virtual NSLayoutConstraint[] Constraints {
 		get;
 	}
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual System.Drawing.RectangleF ContentStretch {
 	public virtual bool HasAmbiguousLayout {
 		get;
 	}
 	public virtual System.Drawing.SizeF IntrinsicContentSize {
 		get;
 	}
 	public virtual string RestorationIdentifier {
 		get;
 	}
 	public virtual bool TranslatesAutoresizingMaskIntoConstrainst {
 		get;
 		set;
 	}
 	public virtual UIView ViewForBaselineLayout {
 		get;
 	}

Removed:

 	public virtual void DismissModalViewControllerAnimated (bool animated);
 	public virtual void PresentModalViewController (UIViewController modalViewController, bool animated);
 	public virtual bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation);
 	public virtual void ViewDidUnload ();
 	public virtual void ViewWillUnload ();
 	public virtual bool AutomaticallyForwardAppearanceAndRotationMethodsToChildViewControllers {
 	public virtual UIViewController ModalViewController {

Added:

 	public virtual void BeginAppearanceTransition (bool isAppearing, bool animated);
 	public virtual bool CanPerformUnwind (MonoTouch.ObjCRuntime.Selector segueAction, UIViewController fromViewController, MonoTouch.Foundation.NSObject sender);
 	public virtual void DecodeRestorableState (MonoTouch.Foundation.NSCoder coder);
 	[Obsolete("Deprecated in iOS 6.0, use DismissViewController (bool, NSAction) instead.")]
	public virtual void DismissModalViewControllerAnimated (bool animated);
 	public virtual void EncodeRestorableState (MonoTouch.Foundation.NSCoder coder);
 	public virtual void EndAppearanceTransition ();
 	public virtual UIStoryboardSegue GetSegueForUnwinding (UIViewController toViewController, UIViewController fromViewController, string identifier);
 	public virtual UIInterfaceOrientationMask GetSupportedInterfaceOrientations ();
 	public virtual UIViewController GetViewControllerForUnwind (MonoTouch.ObjCRuntime.Selector segueAction, UIViewController fromViewController, MonoTouch.Foundation.NSObject sender);
 	public virtual UIInterfaceOrientation PreferredInterfaceOrientationForPresentation ();
 	[Obsolete("Deprecated in iOS 6.0, use PresentViewController (UIViewController, bool, NSAction) instead.")]
	public virtual void PresentModalViewController (UIViewController modalViewController, bool animated);
 	public virtual bool ShouldAutorotate ();
 	[Obsolete("Derecated in IOS6")]
	public virtual bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation);
 	public virtual bool ShouldPerformSegue (string segueIdentifier, MonoTouch.Foundation.NSObject sender);
 	public virtual void UpdateViewConstraints ();
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void ViewDidUnload ();
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void ViewWillUnload ();
 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual bool AutomaticallyForwardAppearanceAndRotationMethodsToChildViewControllers {
 	[Obsolete("Deprecated in iOS 6.0, PresentedViewController")]
	public virtual UIViewController ModalViewController {
 	public virtual MonoTouch.ObjCRuntime.Class RestorationClass {
 		get;
 		set;
 	}
 	public virtual string RestorationIdentifier {
 		get;
 	}
 	public virtual bool ShouldAutomaticallyForwardAppearanceMethods {
 		get;
 	}
 	public virtual bool ShouldAutomaticallyForwardRotationMethods {
 		get;
 	}

Added:

 	public virtual bool KeyboardDisplayRequiresUserAction {
 		get;
 		set;
 	}
 	public virtual bool SuppressesIncrementalRendering {
 		get;
 		set;
 	}

[Serializable]
public enum ADAdType {
	Banner,
	MediumRectangle
}

Removed:

 	public static System.Drawing.SizeF SizeFromContentSizeIdentifier (string sizeIdentifier);
 	public virtual string CurrentContentSizeIdentifier {
 	public virtual MonoTouch.Foundation.NSSet RequiredContentSizeIdentifiers {

Added:

 	public ADBannerView (ADAdType type);
 	[Obsolete("Obsolete in iOS 6.0")]
	public static System.Drawing.SizeF SizeFromContentSizeIdentifier (string sizeIdentifier);
 	public virtual ADAdType AdType {
 		get;
 	}
 	[Obsolete("Obsolete in iOS 6.0")]
	public virtual string CurrentContentSizeIdentifier {
 	[Obsolete("Obsolete in iOS 6.0")]
	public virtual MonoTouch.Foundation.NSSet RequiredContentSizeIdentifiers {

Removed:

 	ApplicationInactive

Added:

 	ApplicationInactive,
 	AdUnloaded