.release-notes { }

.release-notes p { margin-left: 1em; margin-right: 1em; } pre { background-color: #eee; padding-top: .5em; padding-bottom: .5em; margin-left: 1em; margin-right: 1em; overflow: auto; }

p { max-width: 40em; } </style>

Removed:

 	public const string Version = "5.4.0";

Added:

 	public const string Version = "5.99.3";
 	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 [] preferredLanguages);
 	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;
 	}

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, MonoTouch.Foundation.NSError outError);

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

}

Removed:

 	public virtual bool FinishWriting ();

Added:

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

Added:

 	public AVAssetWriterInput (string mediaType, MonoTouch.Foundation.NSDictionary outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public static AVAssetWriterInput Create (string mediaType, MonoTouch.Foundation.NSDictionary outputSettings, MonoTouch.CoreMedia.CMFormatDescription sourceFormatHint);
 	public virtual MonoTouch.CoreMedia.CMFormatDescription SourceFormatHint {
 		get;
 	}

Added:

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

Added:

 	public virtual AVAudioSessionChannelDescription[] ChannelAssignments {
 		get;
 		set;
 	}

Removed:

 	public virtual void EndInterruption (AVAudioPlayer player);
 	public virtual void EndInterruption (AVAudioPlayer player, AVAudioSessionInterruptionFlags flags);

Added:

 	[Obsolete("Deprecated in iOS6")]
	public virtual void EndInterruption (AVAudioPlayer player);
 	[Obsolete("Deprecated in iOS6")]
	public virtual void EndInterruption (AVAudioPlayer player, AVAudioSessionInterruptionFlags flags);

Added:

 	public virtual void RecordAt (double time);
 	public virtual void RecordAt (double time, float duration);
 	public virtual AVAudioSessionChannelDescription[] ChannelAssignments {
 		get;
 		set;
 	}
 	public virtual double DeviceCurrentTime {
 		get;
 	}

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 TorchActive {
 		get;
 	}

[Serializable]
public enum AVCaptureDeviceTransportControlsPlaybackMode {
	NotPlaying,
	Playing
}

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

Removed:

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

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

Added:

 	ScreenCaptureFailed,
 	DisplayWasDisabled,
 	TorchLevelUnavailable,
 	OperationInterrupted,
 	IncompatibleAsset,
 	FailedToLoadMediaData,
 	ServerIncorrectlyConfigured

Removed:

 public class AVFileType {
public AVFileType ();

Added:

 public static class AVFileType {

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

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);
 	public virtual MonoTouch.CoreMedia.CMClock MasterClock {
 		get;
 	}
 	public virtual bool OutputObscuredDueToInsufficientExternalProtection {
 		get;
 	}

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 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);
public AVPlayerItemVideoOutput (MonoTouch.Foundation.NSDictionary pixelBufferAttributes);

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

}

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

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

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

}

Added:

 	public static MonoTouch.Foundation.NSString ReferenceRestrictionsKey {
 		get;
 	}
 	public virtual AVAssetResourceLoader ResourceLoader {
 		get;
 	}

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

Added:

 	public static AVVideoComposition FromAssetProperties (AVAsset asset);

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

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")]
	public virtual void RequestAccess (ACAccountType accountType, ACRequestCompletionHandler completionHandler);
 	public virtual void RequestAccessToAccount (ACAccountType accountType, MonoTouch.Foundation.NSDictionary options, ACRequestCompletionHandler completion);

Added:

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

Added:

 	AccessInfoInvalid

public static class ACFacebook {
public static MonoTouch.Foundation.NSString AppIdKey {
	get;
}
public static MonoTouch.Foundation.NSString AudienceKey {
	get;
}
public static MonoTouch.Foundation.NSString PermissionsKey {
	get;
}

}

public static class ACFacebookAudience {
public static MonoTouch.Foundation.NSString Everyone {
	get;
}
public static MonoTouch.Foundation.NSString Friends {
	get;
}
public static MonoTouch.Foundation.NSString OnlyMe {
	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);

Added:

 	NotPermittedByUserError

[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 abstract class DictionaryContainer {
protected DictionaryContainer ();
protected DictionaryContainer (MonoTouch.Foundation.NSDictionary dictionary);

protected string GetStringValue (MonoTouch.Foundation.NSString key);
protected void SetStringValue (MonoTouch.Foundation.NSString key, MonoTouch.Foundation.NSString value);
protected void SetStringValue (MonoTouch.Foundation.NSString key, string value);

public MonoTouch.Foundation.NSDictionary Dictionary {
	get;
}

}

public class InstantMessageService : 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 : 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 : 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
}

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

Added:

 	Varispeed,
 	DeferredRenderer,
 	Splitter,
 	Merger,
 	NewTimePitch,
 	AUiPodTimeOther

Added:

 	PeakLimiter,
 	DynamicsProcessor,
 	LowPassFilter,
 	HighPassFilter,
 	HighShelfFilter,
 	LowShelfFilter,
 	DCFilter,
 	ParametricEQ,
 	Delay,
 	Distortion,
 	BandPassFilter,
 	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<CBPeripheralEventArgs> 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;
}

}

Added:

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

}

Some of these errors were actually part of CBATTError:

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

public CBPeripheral Peripherals {
	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 virtual void StartAdvertising (MonoTouch.Foundation.NSDictionary advertisementData);
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 UpdatedState;
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 UpdatedState (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 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
}

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:

 	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:

 	[Obsolete("Deprecated in iOS 6.0")]
	public virtual void StartMonitoring (CLRegion region, double desiredAccuracy);
 	[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 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 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
}

Added:

 	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 {
public Nullable<bool> DependedOnByOthers {
	get;
	set;
}
public Nullable<bool> DependsOnOthers {
	get;
	set;
}
public MonoTouch.Foundation.NSDictionary Dictionary {
	get;
}
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
}

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

}

Added:

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

Added:

 	Composite,
 	Mask

Added:

 	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 {

Added:

 [Flags]
 	Embedding,
 	Override

Added:

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

Added:

 	public CVPixelBuffer (System.Drawing.Size size, CVPixelFormatType pixelFormat);
 	public static readonly MonoTouch.Foundation.NSString OpenGLESCompatibilityKey;

Added:

 	OneComponent16Half,
 	OneComponent32Float,
 	TwoComponent16Half,
 	TwoComponent32Float,
 	CV64RGBAHalf,
 	CV128RGBAFloat

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
}

Added:

 	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 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 virtual MonoTouch.Foundation.NSData WakeToken {
 		get;
 	}

Added:

 	public EAAccessory Selected {
 		get;
 	}

Added:

 	public virtual void ShowBluetoothAccessoryPicker (MonoTouch.Foundation.NSPredicate nameFilterPredicate, System.Action<MonoTouch.Foundation.NSError> completion);
 	public virtual void WakeAccessoryWithToken (MonoTouch.Foundation.NSData wakeToken);
 	public static MonoTouch.Foundation.NSString BluetoothAccessoryPickerErrorDomain {
 		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 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
}

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

Added:

 	UITracking,
 	Other

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:

 	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
}

Added:

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

Added:

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

}

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

protected override void Dispose (bool disposing);

public virtual MPMediaChapterType ChapterType {
	get;
}
public override IntPtr ClassHandle {
	get;
}
public virtual double PlaybackDuration {
	get;
}
public virtual double PlaybackTime {
	get;
}
public virtual MonoTouch.Foundation.NSObject Value {
	get;
}

}

[Serializable]
public enum MPMediaChapterType {
	PlaybackTime,
	Title,
	Artwork,
	Url,
	UrlDescription
}

Added:

 	public static MonoTouch.Foundation.NSString BookmarkTimeProperty {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString ChaptersProperty {
 		get;
 	}
 	public static MonoTouch.Foundation.NSString IsCloudItemProperty {
 		get;
 	}
 	public double BookmarkTime {
 		get;
 	}
 	public MPMediaChapter[] Chapters {
 		get;
 	}
 	public bool IsCloudItem {
 		get;
 	}

Added:

 	public virtual bool ShowsCloudItems {
 		get;
 		set;
 	}

Removed:

 	public virtual bool UseApplicationAudioSession {

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

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

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

Added:

 	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 FromServiceType (MonoTouch.Foundation.NSString serviceType);
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 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
}

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

Added:

 	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 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 (int iTunesItemIdentifier, System.Action<bool,monotouch.foundation.nserror> callback);
public virtual void LoadProduct (MonoTouch.Foundation.NSDictionary parameters, System.Action<bool,monotouch.foundation.nserror> callback);

public static MonoTouch.Foundation.NSString ITunesItemIdentifier {
	get;
}
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></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);

}

Added:

 	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 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;
}
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 MoveSectiontoSection (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 int GetSectionsCount (UICollectionView collectionView);
public virtual UICollectionReusableView GetView (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 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 int GetSectionsCount (UICollectionView collectionView);
public virtual UICollectionReusableView GetView (UICollectionView collectionView, MonoTouch.Foundation.NSString elementKind, MonoTouch.Foundation.NSIndexPath indexPath);

}

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 GetInsetForItem (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 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 int GetSectionsCount (UICollectionView collectionView);
public virtual UICollectionReusableView GetView (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 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 IdentifierForAdvertising {
 		get;
 	}
 	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;
}

}

Added:

 	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 {
public UIStringAttributes ();
public UIStringAttributes (MonoTouch.Foundation.NSDictionary dictionary);

public UIColor BackgroundColor {
	get;
	set;
}
public MonoTouch.Foundation.NSDictionary Dictionary {
	get;
}
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;
 		}

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

}

Added:

 	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 {

Added:

 	AdUnloaded