Comparison between monotouch-202.dll and monotouch-303.dll

Namespace: MonoTouch

Type Changed: MonoTouch.Constants

Removed:

 	public const string Version = "2.0.2";

Added:

 	public const string Version = "3.0.3";
 	public const string FoundationLibrary = "/System/Library/Frameworks/Foundation.framework/Foundation";
 	public const string iAdLibrary = "/System/Library/Frameworks/AdLib.framework/AdLib";
 	public const string CoreTelephonyLibrary = "/System/Library/Frameworks/CoreTelephony.framework/CoreTelephony";
 	public const string CoreMediaLibrary = "/System/Library/Frameworks/CoreMedia.framework/CoreMedia";
 	public const string MapKitLibrary = "/System/Library/Frameworks/MapKit.framework/MapKit";

Namespace: MonoTouch.AVFoundation

New Type: MonoTouch.AVFoundation.AVAsset

public class AVAsset : MonoTouch.Foundation.NSObject {
	
	public AVAsset ();
	public AVAsset (MonoTouch.Foundation.NSCoder coder);
	public AVAsset (MonoTouch.Foundation.NSObjectFlag t);
	public AVAsset (IntPtr handle);
	
	public virtual void CancelLoading ();
	public virtual AVMetadataItem[] MetadataForFormat (string format);
	public virtual AVAssetTrack[] TracksWithMediaCharacteristic (string mediaCharacteristic);
	public virtual AVAssetTrack[] TracksWithMediaType (string mediaType);
	public virtual AVAssetTrack TrackWithTrackID (int trackID);
	
	public virtual string [] AvailableMetadataFormats {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVMetadataItem[] CommonMetadata {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime Duration {
		get;
	}
	public virtual string Lyrics {
		get;
	}
	public virtual System.Drawing.SizeF NaturalSize {
		get;
	}
	public virtual float PreferredRate {
		get;
	}
	public virtual MonoTouch.CoreGraphics.CGAffineTransform PreferredTransform {
		get;
	}
	public virtual float PreferredVolume {
		get;
	}
	public virtual bool ProvidesPreciseDurationAndTiming {
		get;
	}
	public virtual AVAssetTrack[] Tracks {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVAssetExportSession

public class AVAssetExportSession : MonoTouch.Foundation.NSObject {
	
	public AVAssetExportSession ();
	public AVAssetExportSession (MonoTouch.Foundation.NSCoder coder);
	public AVAssetExportSession (MonoTouch.Foundation.NSObjectFlag t);
	public AVAssetExportSession (IntPtr handle);
	public AVAssetExportSession (AVAsset asset, string presetName);
	
	public static string [] ExportPresetsCompatibleWithAsset (AVAsset asset);
	public static string LocalizedNameForExportPreset (string presetName);
	public virtual void CancelExport ();
	public virtual void ExportAsynchronously (AVErrorHandler errorHandler);
	
	public virtual string [] AllExportPresets {
		get;
	}
	public virtual AVAudioMix AudioMix {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual long FileLengthLimit {
		get;
		set;
	}
	public virtual string LocalizedExportSessionOutputSummary {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime MaxDuration {
		get;
	}
	public virtual AVMetadataItem[] Metadata {
		get;
		set;
	}
	public virtual string OutputFileType {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSUrl OutputUrl {
		get;
		set;
	}
	public virtual string PresetName {
		get;
	}
	public virtual float Progress {
		get;
	}
	public virtual bool ShouldOptimizeForNetworkUse {
		get;
		set;
	}
	public virtual AVAssetExportSessionStatus Status {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject[] SupportedFileTypes {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTimeRange TimeRange {
		get;
		set;
	}
	public virtual AVVideoComposition VideoComposition {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVAssetExportSessionStatus

[Serializable]
public enum AVAssetExportSessionStatus {
	Unknown,
	Exporting,
	Completed,
	Failed,
	Cancelled
}

New Type: MonoTouch.AVFoundation.AVAssetReaderStatus

[Serializable]
public enum AVAssetReaderStatus {
	Unknown,
	Reading,
	Completed,
	Failed,
	Cancelled
}

New Type: MonoTouch.AVFoundation.AVAssetTrack

public class AVAssetTrack : MonoTouch.Foundation.NSObject {
	
	public AVAssetTrack ();
	public AVAssetTrack (MonoTouch.Foundation.NSCoder coder);
	public AVAssetTrack (MonoTouch.Foundation.NSObjectFlag t);
	public AVAssetTrack (IntPtr handle);
	
	public virtual bool HasMediaCharacteristic (string mediaCharacteristic);
	public virtual AVMetadataItem[] MetadataForFormat (string format);
	public virtual MonoTouch.CoreMedia.CMTime SamplePresentationTimeForTrackTime (MonoTouch.CoreMedia.CMTime trackTime);
	public virtual AVAssetTrackSegment SegmentForTrackTime (MonoTouch.CoreMedia.CMTime trackTime);
	
	public virtual AVAsset Asset {
		get;
	}
	public virtual string [] AvailableMetadataFormats {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVMetadataItem[] CommonMetadata {
		get;
	}
	public virtual bool Enabled {
		get;
	}
	public virtual float EstimatedDataRate {
		get;
	}
	public virtual string ExtendedLanguageTag {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject[] FormatDescriptionsAsObjects {
		get;
	}
	public virtual string LanguageCode {
		get;
	}
	public virtual string MediaType {
		get;
	}
	public virtual System.Drawing.SizeF NaturalSize {
		get;
	}
	public virtual int NaturalTimeScale {
		get;
	}
	public virtual float NominalFrameRate {
		get;
	}
	public virtual MonoTouch.CoreGraphics.CGAffineTransform PreferredTransform {
		get;
	}
	public virtual float PreferredVolume {
		get;
	}
	public virtual AVAssetTrackSegment[] Segments {
		get;
	}
	public virtual bool SelfContained {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTimeRange TimeRange {
		get;
	}
	public virtual long TotalSampleDataLength {
		get;
	}
	public virtual int TrackID {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVAssetTrackSegment

public class AVAssetTrackSegment : MonoTouch.Foundation.NSObject {
	
	public AVAssetTrackSegment ();
	public AVAssetTrackSegment (MonoTouch.Foundation.NSCoder coder);
	public AVAssetTrackSegment (MonoTouch.Foundation.NSObjectFlag t);
	public AVAssetTrackSegment (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Empty {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTimeMapping TimeMapping {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVAsynchronousKeyValueLoading

public abstract class AVAsynchronousKeyValueLoading : MonoTouch.Foundation.NSObject {
	
	public AVAsynchronousKeyValueLoading ();
	public AVAsynchronousKeyValueLoading (MonoTouch.Foundation.NSCoder coder);
	public AVAsynchronousKeyValueLoading (MonoTouch.Foundation.NSObjectFlag t);
	public AVAsynchronousKeyValueLoading (IntPtr handle);
	
	public abstract void LoadValuesAsynchronously (string [] keys, MonoTouch.Foundation.NSAction handler);
	public abstract AVKeyValueStatus StatusOfValueForKeyerror (string key, IntPtr outError);
}

New Type: MonoTouch.AVFoundation.AVAudioMix

public class AVAudioMix : MonoTouch.Foundation.NSObject {
	
	public AVAudioMix ();
	public AVAudioMix (MonoTouch.Foundation.NSCoder coder);
	public AVAudioMix (MonoTouch.Foundation.NSObjectFlag t);
	public AVAudioMix (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVAudioMixInputParameters[] InputParameters {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVAudioMixInputParameters

public class AVAudioMixInputParameters : MonoTouch.Foundation.NSObject {
	
	public AVAudioMixInputParameters ();
	public AVAudioMixInputParameters (MonoTouch.Foundation.NSCoder coder);
	public AVAudioMixInputParameters (MonoTouch.Foundation.NSObjectFlag t);
	public AVAudioMixInputParameters (IntPtr handle);
	
	public virtual bool GetVolumeRamp (MonoTouch.CoreMedia.CMTime forTime, float startVolume, float endVolume, MonoTouch.CoreMedia.CMTimeRange timeRange);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int TrackID {
		get;
	}
}

Type Changed: MonoTouch.AVFoundation.AVAudioPlayer

Removed:

 	public AVAudioPlayer (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSError error);
 	public AVAudioPlayer (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSError error);

Added:

 	public AVAudioPlayer (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSError error);
 	public AVAudioPlayer (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSError error);
 	public virtual bool PlayAtTimetime (double time);
 	public virtual double DeviceCurrentTime {
 		get;
 	}
 	public virtual float Pan {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSDictionary Settings {
 		get;
 	}

Type Changed: MonoTouch.AVFoundation.AVAudioPlayerDelegate

Added:

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

Type Changed: MonoTouch.AVFoundation.AVAudioRecorder

Removed:

 	public AVAudioRecorder (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, MonoTouch.Foundation.NSError outError);

Added:

 	public AVAudioRecorder (MonoTouch.Foundation.NSUrl url, MonoTouch.Foundation.NSDictionary settings, MonoTouch.Foundation.NSError outError);

Type Changed: MonoTouch.AVFoundation.AVAudioRecorderDelegate

Added:

 	public virtual void EndInterruption (AVAudioRecorder recorder, AVAudioSessionInterruptionFlags flags);

Type Changed: MonoTouch.AVFoundation.AVAudioSession

Added:

 	public bool SetActive (bool beActive, AVAudioSessionFlags flags, out MonoTouch.Foundation.NSError outError);

Type Changed: MonoTouch.AVFoundation.AVAudioSessionDelegate

Removed:

 	public virtual void CategoryChanged (string category);

Added:

 	public virtual void EndInterruption (AVAudioSessionInterruptionFlags flags);

Type Changed: MonoTouch.AVFoundation.AVAudioSessionFlags

Removed:

 Could not find MonoTouch.AVFoundation.AVAudioSessionFlags

Added:

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

Type Changed: MonoTouch.AVFoundation.AVAudioSessionInterruptionFlags

Removed:

 Could not find MonoTouch.AVFoundation.AVAudioSessionInterruptionFlags

Added:

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

New Type: MonoTouch.AVFoundation.AVCaptureAudioChannel

public class AVCaptureAudioChannel : MonoTouch.Foundation.NSObject {
	
	public AVCaptureAudioChannel ();
	public AVCaptureAudioChannel (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureAudioChannel (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureAudioChannel (IntPtr handle);
	
	public virtual float AveragePowerLevel {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual float PeakHoldLevel {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureAudioDataOutput

public class AVCaptureAudioDataOutput : AVCaptureOutput {
	
	public AVCaptureAudioDataOutput ();
	public AVCaptureAudioDataOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureAudioDataOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureAudioDataOutput (IntPtr handle);
	
	public virtual void SetSampleBufferDelegatequeue (AVCaptureAudioDataOutputSampleBufferDelegate sampleBufferDelegate, IntPtr sampleBufferCallbackDispatchQueue);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual IntPtr SampleBufferCallbackQueue {
		get;
	}
	public virtual AVCaptureAudioDataOutputSampleBufferDelegate SampleBufferDelegate {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureAudioDataOutputSampleBufferDelegate

public class AVCaptureAudioDataOutputSampleBufferDelegate : MonoTouch.Foundation.NSObject {
	
	public AVCaptureAudioDataOutputSampleBufferDelegate ();
	public AVCaptureAudioDataOutputSampleBufferDelegate (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureAudioDataOutputSampleBufferDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureAudioDataOutputSampleBufferDelegate (IntPtr handle);
	
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, MonoTouch.CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}

New Type: MonoTouch.AVFoundation.AVCaptureCompletionHandler

[Serializable]
public delegate void AVCaptureCompletionHandler (MonoTouch.CoreMedia.CMSampleBuffer imageDataSampleBuffer, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.AVFoundation.AVCaptureConnection

public class AVCaptureConnection : MonoTouch.Foundation.NSObject {
	
	public AVCaptureConnection ();
	public AVCaptureConnection (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureConnection (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureConnection (IntPtr handle);
	
	public virtual bool Active {
		get;
	}
	public virtual AVCaptureAudioChannel AudioChannels {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Enabled {
		get;
		set;
	}
	public virtual AVCaptureInputPort[] inputPorts {
		get;
	}
	public virtual AVCaptureOutput Output {
		get;
	}
	public virtual bool VideoMirrored {
		get;
		set;
	}
	public virtual AVCaptureVideoOrientation VideoOrientation {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureDevice

public class AVCaptureDevice : MonoTouch.Foundation.NSObject {
	
	public AVCaptureDevice ();
	public AVCaptureDevice (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureDevice (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureDevice (IntPtr handle);
	
	public static AVCaptureDevice DefaultDeviceWithMediaType (string mediaType);
	public static AVCaptureDevice[] DevicesWithMediaType (string mediaType);
	public static AVCaptureDevice DeviceWithUniqueID (string deviceUniqueID);
	public virtual bool HasMediaType (string mediaType);
	public virtual bool IsFlashModeSupported (AVCaptureFlashMode flashMode);
	public virtual bool IsTorchModeSupported (AVCaptureTorchMode torchMode);
	public virtual bool LockForConfiguration (IntPtr ptrToHandleToError);
	public virtual bool SupportsAVCaptureSessionPreset (string preset);
	public virtual void UnlockForConfiguration ();
	
	public static AVCaptureDevice[] Devices {
		get;
	}
	public virtual bool AdjustingExposure {
		get;
	}
	public virtual bool AdjustingFocus {
		get;
	}
	public virtual bool AdjustingWhiteBalance {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Connected {
		get;
	}
	public virtual AVCaptureExposureMode ExposureMode {
		get;
		set;
	}
	public virtual System.Drawing.PointF ExposurePointOfInterest {
		get;
		set;
	}
	public virtual bool ExposurePointOfInterestSupported {
		get;
	}
	public virtual AVCaptureFlashMode FlashMode {
		get;
		set;
	}
	public virtual AVCaptureFocusMode FocusMode {
		get;
		set;
	}
	public virtual System.Drawing.PointF FocusPointOfInterest {
		get;
		set;
	}
	public virtual bool FocusPointOfInterestSupported {
		get;
	}
	public virtual string LocalizedName {
		get;
	}
	public virtual string ModelID {
		get;
	}
	public virtual AVCaptureDevicePosition Position {
		get;
	}
	public virtual AVCaptureTorchMode TorchMode {
		get;
		set;
	}
	public virtual string UniqueID {
		get;
	}
	public virtual AVCaptureWhiteBalanceMode WhiteBalanceMode {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureDeviceInput

public class AVCaptureDeviceInput : AVCaptureInput {
	
	public AVCaptureDeviceInput ();
	public AVCaptureDeviceInput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureDeviceInput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureDeviceInput (IntPtr handle);
	public AVCaptureDeviceInput (AVCaptureDevice device, IntPtr ptrToHandleToError);
	
	public static AVCaptureDeviceInput FromDevice (AVCaptureDevice device, IntPtr ptrToHandleToError);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVCaptureDevice Device {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureDevicePosition

[Serializable]
public enum AVCaptureDevicePosition {
	Back,
	Front
}

New Type: MonoTouch.AVFoundation.AVCaptureExposureMode

[Serializable]
public enum AVCaptureExposureMode {
	Locked,
	AutoExpose,
	ContinuousAutoExposure
}

New Type: MonoTouch.AVFoundation.AVCaptureFileOutput

public class AVCaptureFileOutput : AVCaptureOutput {
	
	public AVCaptureFileOutput ();
	public AVCaptureFileOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureFileOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureFileOutput (IntPtr handle);
	
	public virtual void StartRecordingToOutputFile (MonoTouch.Foundation.NSUrl outputFileUrl, AVCaptureFileOutputRecordingDelegate recordingDelegate);
	public virtual void StopRecording ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime MaxRecordedDuration {
		get;
		set;
	}
	public virtual long MaxRecordedFileSize {
		get;
		set;
	}
	public virtual long MinFreeDiskSpaceLimit {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSUrl OutputFileURL {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime RecordedDuration {
		get;
	}
	public virtual long RecordedFileSize {
		get;
	}
	public virtual bool Recording {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureFileOutputRecordingDelegate

public class AVCaptureFileOutputRecordingDelegate : MonoTouch.Foundation.NSObject {
	
	public AVCaptureFileOutputRecordingDelegate ();
	public AVCaptureFileOutputRecordingDelegate (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureFileOutputRecordingDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureFileOutputRecordingDelegate (IntPtr handle);
	
	public virtual void DidStartRecording (AVCaptureFileOutput captureOutput, MonoTouch.Foundation.NSUrl outputFileUrl, MonoTouch.Foundation.NSObject[] connections);
	public virtual void FinishedRecording (AVCaptureFileOutput captureOutput, MonoTouch.Foundation.NSUrl outputFileUrl, MonoTouch.Foundation.NSObject[] connections, MonoTouch.Foundation.NSError error);
}

New Type: MonoTouch.AVFoundation.AVCaptureFlashMode

[Serializable]
public enum AVCaptureFlashMode {
	Off,
	On,
	Auto
}

New Type: MonoTouch.AVFoundation.AVCaptureFocusMode

[Serializable]
public enum AVCaptureFocusMode {
	ModeLocked,
	ModeAutoFocus,
	ModeContinuousAutoFocus
}

New Type: MonoTouch.AVFoundation.AVCaptureInput

public class AVCaptureInput : MonoTouch.Foundation.NSObject {
	
	public AVCaptureInput ();
	public AVCaptureInput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureInput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureInput (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVCaptureInputPort[] Ports {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureInputPort

public class AVCaptureInputPort : MonoTouch.Foundation.NSObject {
	
	public AVCaptureInputPort ();
	public AVCaptureInputPort (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureInputPort (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureInputPort (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Enabled {
		get;
		set;
	}
	public virtual AVCaptureInput Input {
		get;
	}
	public virtual string MediaType {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureMovieFileOutput

public class AVCaptureMovieFileOutput : AVCaptureFileOutput {
	
	public AVCaptureMovieFileOutput ();
	public AVCaptureMovieFileOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureMovieFileOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureMovieFileOutput (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVMetadataItem[] Metadata {
		get;
		set;
	}
	public virtual MonoTouch.CoreMedia.CMTime MovieFragmentInterval {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureOutput

public class AVCaptureOutput : MonoTouch.Foundation.NSObject {
	
	public AVCaptureOutput ();
	public AVCaptureOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureOutput (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject[] Connections {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureSession

public class AVCaptureSession : MonoTouch.Foundation.NSObject {
	
	public AVCaptureSession ();
	public AVCaptureSession (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureSession (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureSession (IntPtr handle);
	
	public virtual void AddInput (AVCaptureInput input);
	public virtual void AddOutput (AVCaptureOutput output);
	public virtual void BeginConfiguration ();
	public virtual bool CanAddInput (AVCaptureInput input);
	public virtual bool CanAddOutput (AVCaptureOutput output);
	public virtual bool CanSetSessionPreset (string preset);
	public virtual void CommitConfiguration ();
	public virtual void RemoveInput (AVCaptureInput input);
	public virtual void RemoveOutput (AVCaptureOutput output);
	public virtual void StartRunning ();
	public virtual void StopRunning ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVCaptureInput[] Inputs {
		get;
	}
	public virtual bool Interrupted {
		get;
	}
	public virtual AVCaptureOutput[] Outputs {
		get;
	}
	public virtual bool Running {
		get;
	}
	public virtual string SessionPreset {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureStillImageOutput

public class AVCaptureStillImageOutput : AVCaptureOutput {
	
	public AVCaptureStillImageOutput ();
	public AVCaptureStillImageOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureStillImageOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureStillImageOutput (IntPtr handle);
	
	public static MonoTouch.Foundation.NSData JpegStillToNSData (MonoTouch.CoreMedia.CMSampleBuffer buffer);
	public virtual void CaptureStillImageAsynchronously (AVCaptureConnection connection, AVCaptureCompletionHandler completionHandler);
	public virtual MonoTouch.Foundation.NSDictionary OutputSettings ();
	
	public virtual string [] AvailableImageDataCodecTypes {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber[] AvailableImageDataCVPixelFormatTypes {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureTorchMode

[Serializable]
public enum AVCaptureTorchMode {
	Off,
	On,
	Auto
}

New Type: MonoTouch.AVFoundation.AVCaptureVideoDataOutput

public class AVCaptureVideoDataOutput : AVCaptureOutput {
	
	public AVCaptureVideoDataOutput ();
	public AVCaptureVideoDataOutput (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureVideoDataOutput (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureVideoDataOutput (IntPtr handle);
	
	public virtual void SetSampleBufferDelegatequeue (AVCaptureVideoDataOutputSampleBufferDelegate sampleBufferDelegate, IntPtr sampleBufferCallbackQueue);
	
	public virtual bool AlwaysDiscardsLateVideoFrames {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime MinFrameDuration {
		get;
		set;
	}
	public virtual IntPtr SampleBufferCallbackQueue {
		get;
	}
	public virtual AVCaptureVideoDataOutputSampleBufferDelegate SampleBufferDelegate {
		get;
	}
	public virtual MonoTouch.Foundation.NSDictionary VideoSettings {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureVideoDataOutputSampleBufferDelegate

public class AVCaptureVideoDataOutputSampleBufferDelegate : MonoTouch.Foundation.NSObject {
	
	public AVCaptureVideoDataOutputSampleBufferDelegate ();
	public AVCaptureVideoDataOutputSampleBufferDelegate (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureVideoDataOutputSampleBufferDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureVideoDataOutputSampleBufferDelegate (IntPtr handle);
	
	public virtual void DidOutputSampleBuffer (AVCaptureOutput captureOutput, MonoTouch.CoreMedia.CMSampleBuffer sampleBuffer, AVCaptureConnection connection);
}

New Type: MonoTouch.AVFoundation.AVCaptureVideoOrientation

[Serializable]
public enum AVCaptureVideoOrientation {
	Portrait,
	PortraitUpsideDown,
	LandscapeLeft,
	LandscapeRight
}

New Type: MonoTouch.AVFoundation.AVCaptureVideoPreviewLayer

public class AVCaptureVideoPreviewLayer : MonoTouch.CoreAnimation.CALayer {
	
	public AVCaptureVideoPreviewLayer ();
	public AVCaptureVideoPreviewLayer (MonoTouch.Foundation.NSCoder coder);
	public AVCaptureVideoPreviewLayer (MonoTouch.Foundation.NSObjectFlag t);
	public AVCaptureVideoPreviewLayer (IntPtr handle);
	public AVCaptureVideoPreviewLayer (AVCaptureSession session);
	
	public static AVCaptureVideoPreviewLayer FromSession (AVCaptureSession session);
	
	public virtual bool AutomaticallyAdjustsMirroring {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Mirrored {
		get;
		set;
	}
	public virtual AVCaptureVideoOrientation Orientation {
		get;
		set;
	}
	public virtual AVCaptureSession Session {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVCaptureWhiteBalanceMode

[Serializable]
public enum AVCaptureWhiteBalanceMode {
	Locked,
	AutoWhiteBalance,
	ContinuousAutoWhiteBalance
}

New Type: MonoTouch.AVFoundation.AVCompositionTrack

public class AVCompositionTrack : AVAssetTrack {
	
	public AVCompositionTrack ();
	public AVCompositionTrack (MonoTouch.Foundation.NSCoder coder);
	public AVCompositionTrack (MonoTouch.Foundation.NSObjectFlag t);
	public AVCompositionTrack (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVCompositionTrackSegment[] Segments {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVCompositionTrackSegment

public class AVCompositionTrackSegment : AVAssetTrackSegment {
	
	public AVCompositionTrackSegment ();
	public AVCompositionTrackSegment (MonoTouch.Foundation.NSCoder coder);
	public AVCompositionTrackSegment (MonoTouch.Foundation.NSObjectFlag t);
	public AVCompositionTrackSegment (IntPtr handle);
	public AVCompositionTrackSegment (MonoTouch.Foundation.NSUrl URL, int trackID, MonoTouch.CoreMedia.CMTimeRange sourceTimeRange, MonoTouch.CoreMedia.CMTimeRange targetTimeRange);
	public AVCompositionTrackSegment (MonoTouch.CoreMedia.CMTimeRange timeRange);
	
	public static IntPtr FromTimeRange (MonoTouch.CoreMedia.CMTimeRange timeRange);
	public static IntPtr FromUrl (MonoTouch.Foundation.NSUrl url, int trackID, MonoTouch.CoreMedia.CMTimeRange sourceTimeRange, MonoTouch.CoreMedia.CMTimeRange targetTimeRange);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int SourceTrackID {
		get;
	}
	public virtual MonoTouch.Foundation.NSUrl SourceUrl {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVError

[Serializable]
public enum AVError {
	Unknown,
	OutOfMemory,
	SessionNotRunning,
	DeviceAlreadyUsedByAnotherSession,
	NoDataCaptured,
	SessionConfigurationChanged,
	DiskFull,
	DeviceWasDisconnected,
	MediaChanged,
	MaximumDurationReached,
	MaximumFileSizeReached,
	MediaDiscontinuity,
	MaximumNumberOfSamplesForFileFormatReached,
	DeviceNotConnected,
	DeviceInUseByAnotherApplication,
	DeviceLockedForConfigurationByAnotherProcess,
	SessionWasInterrupted,
	DecodeFailed,
	ExportFailed,
	FileAlreadyExists,
	InvalidSourceMedia,
	CompositionTrackSegmentsNotContiguous,
	ContentIsProtected,
	FailedToParse,
	FormatNotRecognized,
	InvalidCompositionTrackSegmentDuration,
	InvalidCompositionTrackSegmentSourceStartTime,
	InvalidCompositionTrackSegmentSourceDuration,
	MaximumStillImageCaptureRequestsExceeded,
	NoImageAtTime,
	MediaServicesWereReset
}

New Type: MonoTouch.AVFoundation.AVErrorHandler

[Serializable]
public delegate void AVErrorHandler (MonoTouch.Foundation.NSError error);

New Type: MonoTouch.AVFoundation.AVFileType

public class AVFileType : MonoTouch.Foundation.NSObject {
	
	public AVFileType ();
	public AVFileType (MonoTouch.Foundation.NSCoder coder);
	public AVFileType (MonoTouch.Foundation.NSObjectFlag t);
	public AVFileType (IntPtr handle);
	
	public static string Aifc {
		get;
	}
	public static string Aiff {
		get;
	}
	public static string Amr {
		get;
	}
	public static string AppleM4V {
		get;
	}
	public static string CoreAudioFormat {
		get;
	}
	public static string Mpeg4 {
		get;
	}
	public static string Mpeg4Audio {
		get;
	}
	public static string QuickTimeMovie {
		get;
	}
	public static string ThreeGpp {
		get;
	}
	public static string Wave {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVKeyValueStatus

[Serializable]
public enum AVKeyValueStatus {
	Unknown,
	Loading,
	Loaded,
	Failed,
	Cancelled
}

New Type: MonoTouch.AVFoundation.AVMediaCharacteristic

public class AVMediaCharacteristic : MonoTouch.Foundation.NSObject {
	
	public AVMediaCharacteristic ();
	public AVMediaCharacteristic (MonoTouch.Foundation.NSCoder coder);
	public AVMediaCharacteristic (MonoTouch.Foundation.NSObjectFlag t);
	public AVMediaCharacteristic (IntPtr handle);
	
	public static string Audible {
		get;
	}
	public static string FrameBased {
		get;
	}
	public static string Legible {
		get;
	}
	public static string Visual {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVMediaType

public class AVMediaType : MonoTouch.Foundation.NSObject {
	
	public AVMediaType ();
	public AVMediaType (MonoTouch.Foundation.NSCoder coder);
	public AVMediaType (MonoTouch.Foundation.NSObjectFlag t);
	public AVMediaType (IntPtr handle);
	
	public static string Audio {
		get;
	}
	public static string ClosedCaption {
		get;
	}
	public static string Muxed {
		get;
	}
	public static string Subtitle {
		get;
	}
	public static string Text {
		get;
	}
	public static string Timecode {
		get;
	}
	public static string TimedMetadata {
		get;
	}
	public static string Video {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVMetadataItem

public class AVMetadataItem : MonoTouch.Foundation.NSObject {
	
	public AVMetadataItem ();
	public AVMetadataItem (MonoTouch.Foundation.NSCoder coder);
	public AVMetadataItem (MonoTouch.Foundation.NSObjectFlag t);
	public AVMetadataItem (IntPtr handle);
	
	public static AVMetadataItem[] FilterWithKey (AVMetadataItem[] array, MonoTouch.Foundation.NSObject key, string keySpace);
	public static AVMetadataItem[] FilterWithLocale (AVMetadataItem[] arrayToFilter, MonoTouch.Foundation.NSLocale locale);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string CommonKey {
		get;
	}
	public virtual MonoTouch.Foundation.NSData DataValue {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate DateValue {
		get;
	}
	public virtual MonoTouch.Foundation.NSDictionary ExtraAttributes {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject Key {
		get;
	}
	public virtual string KeySpace {
		get;
	}
	public virtual MonoTouch.Foundation.NSLocale Locale {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber NumberValue {
		get;
	}
	public virtual string StringValue {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime Time {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject Value {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableAudioMix

public class AVMutableAudioMix : AVAudioMix {
	
	public AVMutableAudioMix ();
	public AVMutableAudioMix (MonoTouch.Foundation.NSCoder coder);
	public AVMutableAudioMix (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableAudioMix (IntPtr handle);
	
	public static AVMutableAudioMix Create ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVAudioMixInputParameters[] InputParameters {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableAudioMixInputParameters

public class AVMutableAudioMixInputParameters : AVAudioMixInputParameters {
	
	public AVMutableAudioMixInputParameters ();
	public AVMutableAudioMixInputParameters (MonoTouch.Foundation.NSCoder coder);
	public AVMutableAudioMixInputParameters (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableAudioMixInputParameters (IntPtr handle);
	
	public static AVMutableAudioMixInputParameters Create ();
	public static AVMutableAudioMixInputParameters FromTrack (AVAssetTrack track);
	public virtual void SetVolume (float volume, MonoTouch.CoreMedia.CMTime atTime);
	public virtual void SetVolumeRamp (float startVolume, float endVolume, MonoTouch.CoreMedia.CMTimeRange timeRange);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int TrackID {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableCompositionTrack

public class AVMutableCompositionTrack : AVCompositionTrack {
	
	public AVMutableCompositionTrack ();
	public AVMutableCompositionTrack (MonoTouch.Foundation.NSCoder coder);
	public AVMutableCompositionTrack (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableCompositionTrack (IntPtr handle);
	
	public virtual void InsertEmptyTimeRange (MonoTouch.CoreMedia.CMTimeRange timeRange);
	public virtual void RemoveTimeRange (MonoTouch.CoreMedia.CMTimeRange timeRange);
	public virtual void ScaleTimeRange (MonoTouch.CoreMedia.CMTimeRange timeRange, MonoTouch.CoreMedia.CMTime duration);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string ExtendedLanguageTag {
		get;
		set;
	}
	public virtual string LanguageCode {
		get;
		set;
	}
	public virtual int NaturalTimeScale {
		get;
		set;
	}
	public virtual MonoTouch.CoreGraphics.CGAffineTransform PreferredTransform {
		get;
		set;
	}
	public virtual float PreferredVolume {
		get;
		set;
	}
	public virtual AVCompositionTrackSegment[] Segments {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableMetadataItem

public class AVMutableMetadataItem : AVMetadataItem {
	
	public AVMutableMetadataItem ();
	public AVMutableMetadataItem (MonoTouch.Foundation.NSCoder coder);
	public AVMutableMetadataItem (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableMetadataItem (IntPtr handle);
	
	public static AVMutableMetadataItem Create ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSDictionary ExtraAttributes {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject Key {
		get;
	}
	public virtual string KeySpace {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSLocale Locale {
		get;
		set;
	}
	public virtual MonoTouch.CoreMedia.CMTime Time {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject Value {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableVideoComposition

public class AVMutableVideoComposition : AVVideoComposition {
	
	public AVMutableVideoComposition ();
	public AVMutableVideoComposition (MonoTouch.Foundation.NSCoder coder);
	public AVMutableVideoComposition (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableVideoComposition (IntPtr handle);
	
	public static AVMutableVideoComposition Create ();
	
	public virtual AVVideoCompositionCoreAnimationTool AnimationTool {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime FrameDuration {
		get;
		set;
	}
	public virtual AVVideoCompositionInstruction[] Instructions {
		get;
		set;
	}
	public virtual float RenderScale {
		get;
	}
	public virtual System.Drawing.SizeF RenderSize {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableVideoCompositionInstruction

public class AVMutableVideoCompositionInstruction : AVVideoCompositionInstruction {
	
	public AVMutableVideoCompositionInstruction ();
	public AVMutableVideoCompositionInstruction (MonoTouch.Foundation.NSCoder coder);
	public AVMutableVideoCompositionInstruction (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableVideoCompositionInstruction (IntPtr handle);
	
	public virtual MonoTouch.CoreGraphics.CGColor BackgroundColor {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVVideoCompositionLayerInstruction[] LayerInstructions {
		get;
		set;
	}
	public virtual MonoTouch.CoreMedia.CMTimeRange TimeRange {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVMutableVideoCompositionLayerInstruction

public class AVMutableVideoCompositionLayerInstruction : AVVideoCompositionLayerInstruction {
	
	public AVMutableVideoCompositionLayerInstruction ();
	public AVMutableVideoCompositionLayerInstruction (MonoTouch.Foundation.NSCoder coder);
	public AVMutableVideoCompositionLayerInstruction (MonoTouch.Foundation.NSObjectFlag t);
	public AVMutableVideoCompositionLayerInstruction (IntPtr handle);
	
	public static AVMutableVideoCompositionLayerInstruction Create ();
	public static AVMutableVideoCompositionLayerInstruction FromAssetTrack (AVAssetTrack track);
	public virtual void SetOpacity (float opacity, MonoTouch.CoreMedia.CMTime time);
	public virtual void SetOpacityRamp (float startOpacity, float endOpacity, MonoTouch.CoreMedia.CMTimeRange timeRange);
	public virtual void SetTransform (MonoTouch.CoreGraphics.CGAffineTransform transform, MonoTouch.CoreMedia.CMTime atTime);
	public virtual void SetTransformRamp (MonoTouch.CoreGraphics.CGAffineTransform startTransform, MonoTouch.CoreGraphics.CGAffineTransform endTransform, MonoTouch.CoreMedia.CMTimeRange timeRange);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int TrackID {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVPlayer

public class AVPlayer : MonoTouch.Foundation.NSObject {
	
	public AVPlayer ();
	public AVPlayer (MonoTouch.Foundation.NSCoder coder);
	public AVPlayer (MonoTouch.Foundation.NSObjectFlag t);
	public AVPlayer (IntPtr handle);
	public AVPlayer (MonoTouch.Foundation.NSUrl URL);
	public AVPlayer (AVPlayerItem item);
	
	public static AVPlayer FromPlayerItem (AVPlayerItem item);
	public static AVPlayer FromUrl (MonoTouch.Foundation.NSUrl URL);
	public virtual MonoTouch.Foundation.NSObject AddBoundaryTimeObserver (MonoTouch.Foundation.NSValue[] times, MonoTouch.CoreFoundation.DispatchQueue queue, MonoTouch.Foundation.NSAction handler);
	public virtual MonoTouch.Foundation.NSObject AddPeriodicTimeObserver (MonoTouch.CoreMedia.CMTime interval, MonoTouch.CoreFoundation.DispatchQueue queue, AVTimeHandler handler);
	public virtual void Pause ();
	public virtual void Play ();
	public virtual void RemoveTimeObserver (MonoTouch.Foundation.NSObject observer);
	public virtual void ReplaceCurrentItemWithPlayerItem (AVPlayerItem item);
	public virtual void Seek (MonoTouch.CoreMedia.CMTime toTime);
	public virtual void Seek (MonoTouch.CoreMedia.CMTime toTime, MonoTouch.CoreMedia.CMTime toleranceBefore, MonoTouch.CoreMedia.CMTime toleranceAfter);
	
	public virtual AVPlayerActionAtItemEnd ActionAtItemEnd {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool ClosedCaptionDisplayEnabled {
		get;
		set;
	}
	public virtual AVPlayerItem CurrentItem {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime CurrentTime {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSError Error {
		get;
	}
	public virtual float Rate {
		get;
		set;
	}
	public virtual AVPlayerStatus Status {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVPlayerActionAtItemEnd

[Serializable]
public enum AVPlayerActionAtItemEnd {
	Pause,
	None
}

New Type: MonoTouch.AVFoundation.AVPlayerItem

public class AVPlayerItem : MonoTouch.Foundation.NSObject {
	
	public AVPlayerItem ();
	public AVPlayerItem (MonoTouch.Foundation.NSCoder coder);
	public AVPlayerItem (MonoTouch.Foundation.NSObjectFlag t);
	public AVPlayerItem (IntPtr handle);
	public AVPlayerItem (MonoTouch.Foundation.NSUrl URL);
	public AVPlayerItem (AVAsset asset);
	
	public static AVPlayerItem FromAsset (AVAsset asset);
	public static AVPlayerItem FromUrl (MonoTouch.Foundation.NSUrl URL);
	public virtual bool Seek (MonoTouch.CoreMedia.CMTime time);
	public virtual bool Seek (MonoTouch.Foundation.NSDate date);
	public virtual bool SeekToDate (MonoTouch.CoreMedia.CMTime time, MonoTouch.CoreMedia.CMTime toleranceBefore, MonoTouch.CoreMedia.CMTime toleranceAfter);
	public virtual void StepByCount (int stepCount);
	
	public virtual AVAsset Asset {
		get;
	}
	public virtual AVAudioMix AudioMix {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime CurrentTime {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSError Error {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime ForwardPlaybackEndTime {
		get;
		set;
	}
	public virtual System.Drawing.SizeF NaturalSize {
		get;
	}
	public virtual bool PlaybackBufferEmpty {
		get;
	}
	public virtual bool PlaybackBufferFull {
		get;
	}
	public virtual bool PlaybackLikelyToKeepUp {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime ReversePlaybackEndTime {
		get;
		set;
	}
	public virtual AVPlayerItemStatus Status {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject[] TimedMetadata {
		get;
	}
	public virtual AVPlayerItem[] Tracks {
		get;
	}
	public virtual AVVideoComposition VideoComposition {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVPlayerItemStatus

[Serializable]
public enum AVPlayerItemStatus {
	Unknown,
	ReadyToPlay,
	Failed
}

New Type: MonoTouch.AVFoundation.AVPlayerItemTrack

public class AVPlayerItemTrack : MonoTouch.Foundation.NSObject {
	
	public AVPlayerItemTrack ();
	public AVPlayerItemTrack (MonoTouch.Foundation.NSCoder coder);
	public AVPlayerItemTrack (MonoTouch.Foundation.NSObjectFlag t);
	public AVPlayerItemTrack (IntPtr handle);
	
	public virtual AVAssetTrack AssetTrack {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Enabled {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVPlayerLayer

public class AVPlayerLayer : MonoTouch.CoreAnimation.CALayer {
	
	public AVPlayerLayer ();
	public AVPlayerLayer (MonoTouch.Foundation.NSCoder coder);
	public AVPlayerLayer (MonoTouch.Foundation.NSObjectFlag t);
	public AVPlayerLayer (IntPtr handle);
	
	public static AVPlayerLayer FromPlayer (AVPlayer player);
	
	public static string VideoGravityResize {
		get;
	}
	public static string VideoGravityResizeAspect {
		get;
	}
	public static string VideoGravityResizeAspectFill {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVPlayer Player {
		get;
		set;
	}
	public virtual string VideoGravity {
		get;
		set;
	}
}

New Type: MonoTouch.AVFoundation.AVPlayerStatus

[Serializable]
public enum AVPlayerStatus {
	Unknown,
	ReadyToPlay,
	Failed
}

New Type: MonoTouch.AVFoundation.AVTimeHandler

[Serializable]
public delegate void AVTimeHandler (MonoTouch.CoreMedia.CMTime time);

New Type: MonoTouch.AVFoundation.AVUrlAsset

public class AVUrlAsset : AVAsset {
	
	public AVUrlAsset ();
	public AVUrlAsset (MonoTouch.Foundation.NSCoder coder);
	public AVUrlAsset (MonoTouch.Foundation.NSObjectFlag t);
	public AVUrlAsset (IntPtr handle);
	public AVUrlAsset (MonoTouch.Foundation.NSUrl URL, MonoTouch.Foundation.NSDictionary options);
	
	public static AVUrlAsset FromUrl (MonoTouch.Foundation.NSUrl URL, MonoTouch.Foundation.NSDictionary options);
	public virtual AVAssetTrack CompatibleTrack (AVCompositionTrack forCompositionTrack);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSUrl Url {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVVideoComposition

public class AVVideoComposition : MonoTouch.Foundation.NSObject {
	
	public AVVideoComposition ();
	public AVVideoComposition (MonoTouch.Foundation.NSCoder coder);
	public AVVideoComposition (MonoTouch.Foundation.NSObjectFlag t);
	public AVVideoComposition (IntPtr handle);
	
	public virtual AVVideoCompositionCoreAnimationTool AnimationTool {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTime FrameDuration {
		get;
	}
	public virtual AVVideoCompositionInstruction[] Instructions {
		get;
	}
	public virtual float RenderScale {
		get;
		set;
	}
	public virtual System.Drawing.SizeF RenderSize {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVVideoCompositionCoreAnimationTool

public class AVVideoCompositionCoreAnimationTool : MonoTouch.Foundation.NSObject {
	
	public AVVideoCompositionCoreAnimationTool ();
	public AVVideoCompositionCoreAnimationTool (MonoTouch.Foundation.NSCoder coder);
	public AVVideoCompositionCoreAnimationTool (MonoTouch.Foundation.NSObjectFlag t);
	public AVVideoCompositionCoreAnimationTool (IntPtr handle);
	
	public static AVVideoCompositionCoreAnimationTool FromLayer (MonoTouch.CoreAnimation.CALayer videoLayer, MonoTouch.CoreAnimation.CALayer animationLayer);
	public static AVVideoCompositionCoreAnimationTool FromLayer (MonoTouch.CoreAnimation.CALayer layer, int trackID);
	
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVVideoCompositionInstruction

public class AVVideoCompositionInstruction : MonoTouch.Foundation.NSObject {
	
	public AVVideoCompositionInstruction ();
	public AVVideoCompositionInstruction (MonoTouch.Foundation.NSCoder coder);
	public AVVideoCompositionInstruction (MonoTouch.Foundation.NSObjectFlag t);
	public AVVideoCompositionInstruction (IntPtr handle);
	
	public static AVVideoCompositionInstruction Create ();
	
	public virtual MonoTouch.CoreGraphics.CGColor BackgroundColor {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual AVVideoCompositionLayerInstruction[] LayerInstructions {
		get;
	}
	public virtual MonoTouch.CoreMedia.CMTimeRange TimeRange {
		get;
	}
}

New Type: MonoTouch.AVFoundation.AVVideoCompositionLayerInstruction

public class AVVideoCompositionLayerInstruction : MonoTouch.Foundation.NSObject {
	
	public AVVideoCompositionLayerInstruction ();
	public AVVideoCompositionLayerInstruction (MonoTouch.Foundation.NSCoder coder);
	public AVVideoCompositionLayerInstruction (MonoTouch.Foundation.NSObjectFlag t);
	public AVVideoCompositionLayerInstruction (IntPtr handle);
	
	public virtual bool GetOpacityRamp (MonoTouch.CoreMedia.CMTime time, float startOpacity, float endOpacity, MonoTouch.CoreMedia.CMTimeRange timeRange);
	public virtual bool GetTransformRamp (MonoTouch.CoreMedia.CMTime time, MonoTouch.CoreGraphics.CGAffineTransform startTransform, MonoTouch.CoreGraphics.CGAffineTransform endTransform, MonoTouch.CoreMedia.CMTimeRange timeRange);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int TrackID {
		get;
	}
}

Namespace: MonoTouch.AdLib

New Type: MonoTouch.AdLib.AdError

[Serializable]
public enum AdError {
	Unknown,
	ServerFailure,
	LoadingThrottled,
	InventoryUnavailable
}

Namespace: MonoTouch.AddressBook

Namespace: MonoTouch.AddressBookUI

Type Changed: MonoTouch.AddressBookUI.ABNewPersonViewController

Removed:

 	public virtual IntPtr _AddressBook {
 		get;
 		set;
 	}
 	public virtual IntPtr _DisplayedPerson {
 		get;
 		set;
 	}
 	public virtual IntPtr _ParentGroup {
 		get;
 		set;
 	}

Type Changed: MonoTouch.AddressBookUI.ABPeoplePickerNavigationController

Removed:

 	public virtual MonoTouch.Foundation.NSNumber[] _DisplayedProperties {
 		get;
 		set;
 	}

Type Changed: MonoTouch.AddressBookUI.ABPersonViewController

Removed:

 	public virtual IntPtr _AddressBook {
 		get;
 		set;
 	}
 	public virtual IntPtr _DisplayedPerson {
 		get;
 		set;
 	}
 	public virtual MonoTouch.Foundation.NSNumber[] _DisplayedProperties {
 		get;
 		set;
 	}

Type Changed: MonoTouch.AddressBookUI.ABUnknownPersonViewController

Removed:

 	public virtual IntPtr _AddressBook {
 		get;
 		set;
 	}
 	public virtual IntPtr _DisplayedPerson {
 		get;
 		set;
 	}

Namespace: MonoTouch.AudioToolbox

Type Changed: MonoTouch.AudioToolbox.AudioChannelLayout

Removed:

 	public int Tag;

Added:

 	public int Tag {
 		get;
 		set;
 	}
 	
 	public AudioChannelLayoutTag AudioTag;

Type Changed: MonoTouch.AudioToolbox.AudioChannelLayoutTag

Removed:

 Could not find MonoTouch.AudioToolbox.AudioChannelLayoutTag

Added:

 [Serializable]
 public enum AudioChannelLayoutTag {
 	UseChannelDescriptions,
 	UseChannelBitmap,
 	Mono,
 	Stereo,
 	StereoHeadphones,
 	MatrixStereo,
 	MidSide,
 	XY,
 	Binaural,
 	Ambisonic_B_Format,
 	Quadraphonic,
 	Pentagonal,
 	Hexagonal,
 	Octagonal,
 	Cube,
 	MPEG_1_0,
 	MPEG_2_0,
 	MPEG_3_0_A,
 	MPEG_3_0_B,
 	MPEG_4_0_A,
 	MPEG_4_0_B,
 	MPEG_5_0_A,
 	MPEG_5_0_B,
 	MPEG_5_0_C,
 	MPEG_5_0_D,
 	MPEG_5_1_A,
 	MPEG_5_1_B,
 	MPEG_5_1_C,
 	MPEG_5_1_D,
 	MPEG_6_1_A,
 	MPEG_7_1_A,
 	MPEG_7_1_B,
 	MPEG_7_1_C,
 	Emagic_Default_7_1,
 	SMPTE_DTV,
 	ITU_1_0,
 	ITU_2_0,
 	ITU_2_1,
 	ITU_2_2,
 	ITU_3_0,
 	ITU_3_1,
 	ITU_3_2,
 	ITU_3_2_1,
 	ITU_3_4_1,
 	DVD_0,
 	DVD_1,
 	DVD_2,
 	DVD_3,
 	DVD_4,
 	DVD_5,
 	DVD_6,
 	DVD_7,
 	DVD_8,
 	DVD_9,
 	DVD_10,
 	DVD_11,
 	DVD_12,
 	DVD_13,
 	DVD_14,
 	DVD_15,
 	DVD_16,
 	DVD_17,
 	DVD_18,
 	DVD_19,
 	DVD_20,
 	AudioUnit_4,
 	AudioUnit_5,
 	AudioUnit_6,
 	AudioUnit_8,
 	AudioUnit_5_0,
 	AudioUnit_6_0,
 	AudioUnit_7_0,
 	AudioUnit_7_0_Front,
 	AudioUnit_5_1,
 	AudioUnit_6_1,
 	AudioUnit_7_1,
 	AudioUnit_7_1_Front,
 	AAC_3_0,
 	AAC_Quadraphonic,
 	AAC_4_0,
 	AAC_5_0,
 	AAC_5_1,
 	AAC_6_0,
 	AAC_6_1,
 	AAC_7_0,
 	AAC_7_1,
 	AAC_Octagonal,
 	TMH_10_2_std,
 	TMH_10_2_full,
 	AC3_1_0_1,
 	AC3_3_0,
 	AC3_3_1,
 	AC3_3_0_1,
 	AC3_2_1_1,
 	AC3_3_1_1,
 	EAC_6_0_A,
 	EAC_7_0_A,
 	EAC3_6_1_A,
 	EAC3_6_1_B,
 	EAC3_6_1_C,
 	EAC3_7_1_A,
 	EAC3_7_1_B,
 	EAC3_7_1_C,
 	EAC3_7_1_D,
 	EAC3_7_1_E,
 	EAC3_7_1_F,
 	EAC3_7_1_G,
 	EAC3_7_1_H,
 	DTS_3_1,
 	DTS_4_1,
 	DTS_6_0_A,
 	DTS_6_0_B,
 	DTS_6_0_C,
 	DTS_6_1_A,
 	DTS_6_1_B,
 	DTS_6_1_C,
 	DTS_7_0,
 	DTS_7_1,
 	DTS_8_0_A,
 	DTS_8_0_B,
 	DTS_8_1_A,
 	DTS_8_1_B,
 	DTS_6_1_D,
 	DiscreteInOrder,
 	Unknown
 }

Type Changed: MonoTouch.AudioToolbox.AudioFormatType

Removed:

 	AES3

Added:

 	AES3,
 	MPEG4AAC_ELD

Type Changed: MonoTouch.AudioToolbox.AudioQueueParameter

Removed:

 	Volume

Added:

 	Volume,
 	Pan,
 	VolumeRampTime

Type Changed: MonoTouch.AudioToolbox.AudioSession

Added:

 	public static AudioSessionInterruptionType InterruptionType {
 		get;
 	}

Type Changed: MonoTouch.AudioToolbox.AudioSessionInterruptionType

Removed:

 Could not find MonoTouch.AudioToolbox.AudioSessionInterruptionType

Added:

 [Serializable]
 public enum AudioSessionInterruptionType {
 	ShouldResume,
 	ShouldNotResume
 }

Type Changed: MonoTouch.AudioToolbox.AudioSessionProperty

Removed:

 	OverrideCategoryMixWithOthers

Added:

 	OverrideCategoryMixWithOthers,
 	InterruptionType

Namespace: MonoTouch.CoreAnimation

Type Changed: MonoTouch.CoreAnimation.CAAnimation

Removed:

 	public virtual void DidChangeValueForKey (string key);
 	public virtual void WillChangeValueForKey (string key);

Added:

 	public virtual bool ShouldArchiveValueForKey (string key);

Type Changed: MonoTouch.CoreAnimation.CAGradientLayer

Removed:

 	public virtual IntPtr _Colors {
 		get;
 		set;
 	}

Added:

 	public virtual float ContentsScale {
 		get;
 		set;
 	}

Type Changed: MonoTouch.CoreAnimation.CAKeyFrameAnimation

Removed:

 	public virtual IntPtr _Path {
 		get;
 		set;
 	}
 	public virtual string rotationMode {

Added:

 	public virtual string RotationMode {

Type Changed: MonoTouch.CoreAnimation.CALayer

Removed:

 	public CALayer (CALayer other);

Added:

 	public CALayer (CALayer other);

Type Changed: MonoTouch.CoreAnimation.CATransaction

Added:

 	public static MonoTouch.Foundation.NSAction CompletionBlock {
 		set;
 	}

Namespace: MonoTouch.CoreFoundation

Type Changed: MonoTouch.CoreFoundation.CFRunLoop

Added:

 	public void Stop ();

New Type: MonoTouch.CoreFoundation.DispatchObject

public class DispatchObject : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
	
	public void Dispose ();
	protected virtual void Dispose (bool disposing);
	public override bool Equals (object other);
	protected override void Finalize ();
	public override int GetHashCode ();
	public void Resume ();
	public void Suspend ();
	
	public static bool operator == (DispatchObject a, DispatchObject b);
	public static bool operator != (DispatchObject a, DispatchObject b);
	
	public IntPtr Context {
		get;
		set;
	}
	public IntPtr Handle {
		get;
	}
}

New Type: MonoTouch.CoreFoundation.DispatchQueue

public class DispatchQueue : DispatchObject {
	
	public DispatchQueue (string label);
	
	public static DispatchQueue GetGlobalQueue (DispatchQueuePriority priority);
	public void DispatchAsync (MonoTouch.Foundation.NSAction action);
	public void DispatchSync (MonoTouch.Foundation.NSAction action);
	
	public static DispatchQueue CurrentQueue {
		get;
	}
	public static DispatchQueue DefaultGlobalQueue {
		get;
	}
	public static DispatchQueue MainQueue {
		get;
	}
	public string Label {
		get;
	}
}

New Type: MonoTouch.CoreFoundation.DispatchQueuePriority

[Serializable]
public enum DispatchQueuePriority {
	High,
	Default,
	Low
}

Namespace: MonoTouch.CoreGraphics

Type Changed: MonoTouch.CoreGraphics.CGContext

Added:

 	public CGPath CopyPath ();

Type Changed: MonoTouch.CoreGraphics.CGLayer

Added:

 	public CGContext Context {
 		get;
 	}

Namespace: MonoTouch.CoreLocation

New Type: MonoTouch.CoreLocation.CLDeviceOrientation

[Serializable]
public enum CLDeviceOrientation {
	Unknown,
	Portrait,
	PortraitUpsideDown,
	LandscapeLeft,
	LandscapeRight,
	FaceUp,
	FaceDown
}

Type Changed: MonoTouch.CoreLocation.CLError

Removed:

 	HeadingFailure

Added:

 	HeadingFailure,
 	RegionMonitoringDenied,
 	RegionMonitoringFailure,
 	RegionMonitoringSetupDelayed

Type Changed: MonoTouch.CoreLocation.CLLocationCoordinate2D

Added:

 	public bool IsValid ();
 	

Type Changed: MonoTouch.CoreLocation.CLLocationManager

Added:

 	public virtual void StartMonitoring (CLRegion region, double desiredAccuracy);
 	public virtual void StartMonitoringSignificantLocationChanges ();
 	public virtual void StopMonitoring (CLRegion region);
 	public virtual void StopMonitoringSignificantLocationChanges ();
 	public static bool RegionMonitoringAvailable {
 		get;
 	}
 	public static bool RegionMonitoringEnabled {
 		get;
 	}
 	public static bool SignificantLocationChangeMonitoringAvailable {
 		get;
 	}
 	public virtual CLHeading Heading {
 		get;
 	}
 	public virtual CLDeviceOrientation HeadingOrientation {
 		get;
 		set;
 	}
 	public virtual double MaximumRegionMonitoringDistance {
 		get;
 	}
 	public virtual MonoTouch.Foundation.NSSet MonitoredRegions {
 		get;
 	}

Type Changed: MonoTouch.CoreLocation.CLLocationManagerDelegate

Added:

 	public virtual void MonitoringFailed (CLLocationManager manager, CLRegion region, MonoTouch.Foundation.NSError error);
 	public virtual void RegionEntered (CLLocationManager manager, CLRegion region);
 	public virtual void RegionLeft (CLLocationManager manager, CLRegion region);

New Type: MonoTouch.CoreLocation.CLRegion

public class CLRegion : MonoTouch.Foundation.NSObject {
	
	public CLRegion ();
	public CLRegion (MonoTouch.Foundation.NSCoder coder);
	public CLRegion (MonoTouch.Foundation.NSObjectFlag t);
	public CLRegion (IntPtr handle);
	public CLRegion (CLLocationCoordinate2D center, double radius, string identifier);
	
	public virtual bool Contains (CLLocationCoordinate2D coordinate);
	
	public virtual CLLocationCoordinate2D Center {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Identifier {
		get;
	}
	public virtual double Radius {
		get;
	}
}

Namespace: MonoTouch.CoreMedia

New Type: MonoTouch.CoreMedia.CMSampleBuffer

public class CMSampleBuffer : IDisposable, MonoTouch.ObjCRuntime.INativeObject {
	
	public void Dispose ();
	protected virtual void Dispose (bool disposing);
	protected override void Finalize ();
	
	public IntPtr Handle {
		get;
	}
}

New Type: MonoTouch.CoreMedia.CMTime

public struct CMTime {
	
	public long Value;
	public int TimeScale;
	public int TimeFlags;
	public long TimeEpoch;
}

New Type: MonoTouch.CoreMedia.CMTimeMapping

public struct CMTimeMapping {
	
	public CMTime Source;
	public CMTime Target;
}

New Type: MonoTouch.CoreMedia.CMTimeRange

public struct CMTimeRange {
	
	public CMTime Start;
	public CMTime Duration;
}

Namespace: MonoTouch.CoreTelephony

New Type: MonoTouch.CoreTelephony.CTCall

public class CTCall : MonoTouch.Foundation.NSObject {
	
	public CTCall ();
	public CTCall (MonoTouch.Foundation.NSCoder coder);
	public CTCall (MonoTouch.Foundation.NSObjectFlag t);
	public CTCall (IntPtr handle);
	
	public virtual string CallID {
		get;
	}
	public virtual string CallState {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public string StateConnected {
		get;
	}
	public string StateDialing {
		get;
	}
	public string StateDisconnected {
		get;
	}
	public string StateIncoming {
		get;
	}
}

New Type: MonoTouch.CoreTelephony.CTCallCenter

public class CTCallCenter : MonoTouch.Foundation.NSObject {
	
	public CTCallCenter ();
	public CTCallCenter (MonoTouch.Foundation.NSCoder coder);
	public CTCallCenter (MonoTouch.Foundation.NSObjectFlag t);
	public CTCallCenter (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSSet CurrentCalls {
		get;
	}
}

New Type: MonoTouch.CoreTelephony.CTCallEventHandler

[Serializable]
public delegate void CTCallEventHandler (CTCall call);

New Type: MonoTouch.CoreTelephony.CTCarrier

public class CTCarrier : MonoTouch.Foundation.NSObject {
	
	public CTCarrier ();
	public CTCarrier (MonoTouch.Foundation.NSCoder coder);
	public CTCarrier (MonoTouch.Foundation.NSObjectFlag t);
	public CTCarrier (IntPtr handle);
	
	public virtual bool AllowsVoip {
		get;
	}
	public virtual string CarrierName {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string IsoCountryCode {
		get;
	}
	public virtual string MobileCountryCode {
		get;
	}
	public virtual string MobileNetworkCode {
		get;
	}
}

Namespace: MonoTouch.CoreText

Namespace: MonoTouch.EventKit

New Type: MonoTouch.EventKit.EKAlarm

public class EKAlarm : MonoTouch.Foundation.NSObject {
	
	public EKAlarm ();
	public EKAlarm (MonoTouch.Foundation.NSCoder coder);
	public EKAlarm (MonoTouch.Foundation.NSObjectFlag t);
	public EKAlarm (IntPtr handle);
	
	public static EKAlarm FromDate (MonoTouch.Foundation.NSDate date);
	public static EKAlarm FromTimeInterval (double offsetSeconds);
	
	public virtual MonoTouch.Foundation.NSDate AbsoluteDate {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual double RelativeOffset {
		get;
		set;
	}
}

New Type: MonoTouch.EventKit.EKCalendar

public class EKCalendar : MonoTouch.Foundation.NSObject {
	
	public EKCalendar ();
	public EKCalendar (MonoTouch.Foundation.NSCoder coder);
	public EKCalendar (MonoTouch.Foundation.NSObjectFlag t);
	public EKCalendar (IntPtr handle);
	
	public virtual bool AllowsContentModifications {
		get;
	}
	public virtual MonoTouch.CoreGraphics.CGColor CGColor {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual EKCalendarEventAvailability SupportedEventAvailabilities {
		get;
	}
	public virtual string Title {
		get;
	}
	public virtual EKCalendarType Type {
		get;
	}
}

New Type: MonoTouch.EventKit.EKCalendarEventAvailability

[Serializable]
[Flags]
public enum EKCalendarEventAvailability {
	None,
	Busy,
	Free,
	Tentative,
	Unavailable
}

New Type: MonoTouch.EventKit.EKCalendarType

[Serializable]
public enum EKCalendarType {
	Local,
	CalDav,
	Exchange,
	Subscription,
	Birthday
}

New Type: MonoTouch.EventKit.EKDay

[Serializable]
public enum EKDay {
	NotSet,
	Sunday,
	Monday,
	Tuesday,
	Wednesday,
	Thursday,
	Friday,
	Saturday
}

New Type: MonoTouch.EventKit.EKErrorCode

[Serializable]
public enum EKErrorCode {
	EventNotMutable,
	NoCalendar,
	NoStartDate,
	NoEndDate,
	DatesInverted,
	InternalFailure,
	CalendarReadOnly,
	DurationGreaterThanRecurrence,
	AlarmGreaterThanRecurrence,
	StartDateTooFarInFuture,
	StartDateCollidesWithOtherOccurrence,
	ObjectBelongsToDifferentStore,
	InvitesCannotBeMoved
}

New Type: MonoTouch.EventKit.EKEvent

public class EKEvent : MonoTouch.Foundation.NSObject {
	
	public EKEvent ();
	public EKEvent (MonoTouch.Foundation.NSCoder coder);
	public EKEvent (MonoTouch.Foundation.NSObjectFlag t);
	public EKEvent (IntPtr handle);
	
	public static EKEvent Create ();
	public static EKEvent FromStore (EKEventStore eventStore);
	public virtual void AddAlarm (EKAlarm alarm);
	public virtual MonoTouch.Foundation.NSComparisonResult CompareStartDateWithEvent (EKEvent other);
	public virtual bool Refresh ();
	public virtual void RemoveAlarm (EKAlarm alarm);
	
	public virtual EKAlarm[] Alarms {
		get;
		set;
	}
	public virtual bool AllDay {
		get;
		set;
	}
	public virtual EKParticipant[] Attendees {
		get;
	}
	public virtual EKEventAvailability Availability {
		get;
		set;
	}
	public virtual EKCalendar Calendar {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate EndDate {
		get;
		set;
	}
	public virtual string EventIdentifier {
		get;
	}
	public virtual bool IsDetached {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate LastModifiedDate {
		get;
	}
	public virtual string Location {
		get;
		set;
	}
	public virtual string Notes {
		get;
		set;
	}
	public virtual EKParticipant Organizer {
		get;
	}
	public virtual EKRecurrenceRule RecurrenceRule {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSDate StartDate {
		get;
		set;
	}
	public virtual EKEventStatus Status {
		get;
	}
	public virtual string Title {
		get;
	}
}

New Type: MonoTouch.EventKit.EKEventAvailability

[Serializable]
public enum EKEventAvailability {
	NotSupported,
	Busy,
	Free,
	Tentative,
	Unavailable
}

New Type: MonoTouch.EventKit.EKEventEditController

[Serializable]
public delegate EKCalendar EKEventEditController (EKEventEditViewController controller);

New Type: MonoTouch.EventKit.EKEventEditEventArgs

public class EKEventEditEventArgs : EventArgs {
	
	public EKEventEditEventArgs (EKEventEditViewAction action);
	
	public EKEventEditViewAction Action {
		get;
		set;
	}
}

New Type: MonoTouch.EventKit.EKEventEditViewAction

[Serializable]
public enum EKEventEditViewAction {
	Canceled,
	Saved,
	Deleted
}

New Type: MonoTouch.EventKit.EKEventEditViewController

public class EKEventEditViewController : MonoTouch.UIKit.UINavigationController {
	
	public EKEventEditViewController ();
	public EKEventEditViewController (MonoTouch.Foundation.NSCoder coder);
	public EKEventEditViewController (MonoTouch.Foundation.NSObjectFlag t);
	public EKEventEditViewController (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public EKEventEditViewDelegate EditViewDelegate {
		get;
		set;
	}
	public virtual EKEvent Event {
		get;
		set;
	}
	public virtual EKEventStore EventStore {
		get;
		set;
	}
	public EKEventEditController GetDefaultCalendarForNewEvents {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject WeakEditViewDelegate {
		get;
		set;
	}
	
	public event EventHandler Completed;
}

New Type: MonoTouch.EventKit.EKEventEditViewDelegate

public abstract class EKEventEditViewDelegate : MonoTouch.Foundation.NSObject {
	
	public EKEventEditViewDelegate ();
	public EKEventEditViewDelegate (MonoTouch.Foundation.NSCoder coder);
	public EKEventEditViewDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public EKEventEditViewDelegate (IntPtr handle);
	
	public abstract void Completed (EKEventEditViewController controller, EKEventEditViewAction action);
	public virtual EKCalendar GetDefaultCalendarForNewEvents (EKEventEditViewController controller);
}

New Type: MonoTouch.EventKit.EKEventSearchCallback

[Serializable]
public delegate void EKEventSearchCallback (EKEvent theEvent, ref bool stop);

New Type: MonoTouch.EventKit.EKEventStatus

[Serializable]
public enum EKEventStatus {
	None,
	Confirmed,
	Tentative,
	Cancelled
}

New Type: MonoTouch.EventKit.EKEventStore

public class EKEventStore : MonoTouch.Foundation.NSObject {
	
	public EKEventStore ();
	public EKEventStore (MonoTouch.Foundation.NSCoder coder);
	public EKEventStore (MonoTouch.Foundation.NSObjectFlag t);
	public EKEventStore (IntPtr handle);
	
	public virtual void EnumerateEvents (MonoTouch.Foundation.NSPredicate predicate, EKEventSearchCallback block);
	public virtual EKEvent EventFromIdentifier (string identifier);
	public virtual EKEvent[] EventsMatchin (MonoTouch.Foundation.NSPredicate predicate);
	public virtual MonoTouch.Foundation.NSPredicate PredicateForEvents (MonoTouch.Foundation.NSDate startDate, MonoTouch.Foundation.NSDate endDate, EKCalendar[] calendars);
	public virtual bool RemoveEvents (EKEvent theEvent, EKSpan span, IntPtr ptrToNserror);
	public virtual bool SaveEvent (EKEvent theEvent, EKSpan span, IntPtr ptrToNsError);
	
	public virtual EKCalendar[] Calendars {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual EKCalendar DefaultCalendarForNewEvents {
		get;
	}
	public virtual string EventStoreIdentifier {
		get;
	}
}

New Type: MonoTouch.EventKit.EKEventViewController

public class EKEventViewController : MonoTouch.UIKit.UIViewController {
	
	public EKEventViewController ();
	public EKEventViewController (MonoTouch.Foundation.NSCoder coder);
	public EKEventViewController (MonoTouch.Foundation.NSObjectFlag t);
	public EKEventViewController (IntPtr handle);
	
	public virtual bool AllowsCalendarPreview {
		get;
		set;
	}
	public virtual bool AllowsEditing {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual EKEvent Event {
		get;
		set;
	}
}

New Type: MonoTouch.EventKit.EKParticipant

public class EKParticipant : MonoTouch.Foundation.NSObject {
	
	public EKParticipant ();
	public EKParticipant (MonoTouch.Foundation.NSCoder coder);
	public EKParticipant (MonoTouch.Foundation.NSObjectFlag t);
	public EKParticipant (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Name {
		get;
	}
	public virtual EKParticipantRole ParticipantRole {
		get;
	}
	public virtual EKParticipantStatus ParticipantStatus {
		get;
	}
	public virtual EKParticipantType ParticipantType {
		get;
	}
	public virtual MonoTouch.Foundation.NSUrl Url {
		get;
	}
}

New Type: MonoTouch.EventKit.EKParticipantRole

[Serializable]
public enum EKParticipantRole {
	Unknown,
	Required,
	Optional,
	Chair,
	NonParticipant
}

New Type: MonoTouch.EventKit.EKParticipantStatus

[Serializable]
public enum EKParticipantStatus {
	Unknown,
	Pending,
	Accepted,
	Declined,
	Tentative,
	Delegated,
	Completed,
	InProcess
}

New Type: MonoTouch.EventKit.EKParticipantType

[Serializable]
public enum EKParticipantType {
	Unknown,
	Person,
	Room,
	Resource,
	Group
}

New Type: MonoTouch.EventKit.EKRecurrenceDayOfWeek

public class EKRecurrenceDayOfWeek : MonoTouch.Foundation.NSObject {
	
	public EKRecurrenceDayOfWeek ();
	public EKRecurrenceDayOfWeek (MonoTouch.Foundation.NSCoder coder);
	public EKRecurrenceDayOfWeek (MonoTouch.Foundation.NSObjectFlag t);
	public EKRecurrenceDayOfWeek (IntPtr handle);
	
	public static MonoTouch.Foundation.NSObject FromDay (EKDay dayOfTheWeek);
	public static MonoTouch.Foundation.NSObject FromDay (EKDay dayOfTheWeek, int weekNumber);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int DayOfTheWeek {
		get;
	}
	public virtual int WeekNumber {
		get;
	}
}

New Type: MonoTouch.EventKit.EKRecurrenceEnd

public class EKRecurrenceEnd : MonoTouch.Foundation.NSObject {
	
	public EKRecurrenceEnd ();
	public EKRecurrenceEnd (MonoTouch.Foundation.NSCoder coder);
	public EKRecurrenceEnd (MonoTouch.Foundation.NSObjectFlag t);
	public EKRecurrenceEnd (IntPtr handle);
	
	public static EKRecurrenceEnd FromEndDate (MonoTouch.Foundation.NSDate endDate);
	public static EKRecurrenceEnd FromOccurrenceCount (int occurrenceCount);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate EndDate {
		get;
	}
	public virtual int OccurrenceCount {
		get;
	}
}

New Type: MonoTouch.EventKit.EKRecurrenceFrequency

[Serializable]
public enum EKRecurrenceFrequency {
	Daily,
	Weekly,
	Monthly,
	Yearly
}

New Type: MonoTouch.EventKit.EKRecurrenceRule

public class EKRecurrenceRule : MonoTouch.Foundation.NSObject {
	
	public EKRecurrenceRule ();
	public EKRecurrenceRule (MonoTouch.Foundation.NSCoder coder);
	public EKRecurrenceRule (MonoTouch.Foundation.NSObjectFlag t);
	public EKRecurrenceRule (IntPtr handle);
	public EKRecurrenceRule (EKRecurrenceFrequency type, int interval, EKRecurrenceEnd end);
	public EKRecurrenceRule (EKRecurrenceFrequency type, int interval, EKRecurrenceDayOfWeek[] days, MonoTouch.Foundation.NSNumber[] monthDays, MonoTouch.Foundation.NSNumber[] months, MonoTouch.Foundation.NSNumber[] weeksOfTheYear, MonoTouch.Foundation.NSNumber[] daysOfTheYear, MonoTouch.Foundation.NSNumber[] setPositions, EKRecurrenceEnd end);
	
	public virtual string CalendarIdentifier {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber[] DaysOfTheMonth {
		get;
	}
	public virtual EKRecurrenceDayOfWeek[] DaysOfTheWeek {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber[] daysOfTheYear {
		get;
	}
	public virtual EKDay FirstDayOfTheWeek {
		get;
	}
	public virtual EKRecurrenceFrequency Frequency {
		get;
	}
	public virtual int Interval {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber[] monthsOfTheYear {
		get;
	}
	public virtual EKRecurrenceEnd RecurrenceEnd {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject[] SetPositions {
		get;
	}
	public virtual MonoTouch.Foundation.NSNumber[] WeeksOfTheYear {
		get;
	}
}

New Type: MonoTouch.EventKit.EKSpan

[Serializable]
public enum EKSpan {
	ThisEvent,
	FutureEvents
}

Namespace: MonoTouch.ExternalAccessory

New Type: MonoTouch.ExternalAccessory.EAAccessory

public class EAAccessory : MonoTouch.Foundation.NSObject {
	
	public EAAccessory ();
	public EAAccessory (MonoTouch.Foundation.NSCoder coder);
	public EAAccessory (MonoTouch.Foundation.NSObjectFlag t);
	public EAAccessory (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Connected {
		get;
	}
	public virtual uint ConnectionID {
		get;
	}
	public EAAccessoryDelegate Delegate {
		get;
		set;
	}
	public virtual string FirmwareRevision {
		get;
	}
	public virtual string HardwareRevision {
		get;
	}
	public virtual string Manufacturer {
		get;
	}
	public virtual string ModelNumber {
		get;
	}
	public virtual string Name {
		get;
	}
	public virtual string [] ProtocolStrings {
		get;
	}
	public virtual string SerialNumber {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler Disconnected;
}

New Type: MonoTouch.ExternalAccessory.EAAccessoryDelegate

public class EAAccessoryDelegate : MonoTouch.Foundation.NSObject {
	
	public EAAccessoryDelegate ();
	public EAAccessoryDelegate (MonoTouch.Foundation.NSCoder coder);
	public EAAccessoryDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public EAAccessoryDelegate (IntPtr handle);
	
	public virtual void Disconnected (EAAccessory accessory);
}

New Type: MonoTouch.ExternalAccessory.EAAccessoryManager

public class EAAccessoryManager : MonoTouch.Foundation.NSObject {
	
	public EAAccessoryManager ();
	public EAAccessoryManager (MonoTouch.Foundation.NSCoder coder);
	public EAAccessoryManager (MonoTouch.Foundation.NSObjectFlag t);
	public EAAccessoryManager (IntPtr handle);
	
	public virtual void RegisterForLocalNotifications ();
	public virtual void UnregisterForLocalNotifications ();
	
	public static EAAccessoryManager SharedAccessoryManager {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual EAAccessory[] ConnectedAccessories {
		get;
	}
}

New Type: MonoTouch.ExternalAccessory.EASession

public class EASession : MonoTouch.Foundation.NSObject {
	
	public EASession ();
	public EASession (MonoTouch.Foundation.NSCoder coder);
	public EASession (MonoTouch.Foundation.NSObjectFlag t);
	public EASession (IntPtr handle);
	public EASession (EAAccessory accessory, string protocol);
	
	public virtual EAAccessory Accessory {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSInputStream InputStream {
		get;
	}
	public virtual MonoTouch.Foundation.NSOutputStream OutputStream {
		get;
	}
	public virtual string ProtocolString {
		get;
	}
}

Namespace: MonoTouch.Foundation

Type Changed: MonoTouch.Foundation.NSAttributedString

Removed:

 	public NSAttributedString (string str, MonoTouch.CoreText.CTStringAttributes attributes);

Added:

 	public NSAttributedString (string str, MonoTouch.CoreText.CTStringAttributes attributes);
 	public static string FontAttributeName {
 		get;
 	}
 	public static string ParagraphStyleAttributeName {
 		get;
 	}

New Type: MonoTouch.Foundation.NSBlockOperation

public class NSBlockOperation : NSOperation {
	
	public NSBlockOperation ();
	public NSBlockOperation (NSCoder coder);
	public NSBlockOperation (NSObjectFlag t);
	public NSBlockOperation (IntPtr handle);
	
	public static NSBlockOperation Create (NSAction method);
	public virtual void AddExecutionBlock (NSAction method);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual NSObject[] ExecutionBlocks {
		get;
	}
}

New Type: MonoTouch.Foundation.NSCache

public class NSCache : NSObject {
	
	public NSCache ();
	public NSCache (NSCoder coder);
	public NSCache (NSObjectFlag t);
	public NSCache (IntPtr handle);
	
	public virtual NSObject ObjectForKey (NSObject key);
	public virtual void RemoveAllObjects ();
	public virtual void RemoveObjectForKey (NSObject key);
	public virtual void SetCost (NSObject obj, NSObject key, uint cost);
	public virtual void SetObjectforKey (NSObject obj, NSObject key);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual uint CountLimit {
		get;
		set;
	}
	public NSCacheDelegate Delegate {
		get;
		set;
	}
	public virtual bool EvictsObjectsWithDiscardedContent {
		get;
		set;
	}
	public virtual string Name {
		get;
		set;
	}
	public virtual uint TotalCostLimit {
		get;
		set;
	}
	public virtual NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler WillEvictObject;
}

New Type: MonoTouch.Foundation.NSCacheDelegate

public class NSCacheDelegate : NSObject {
	
	public NSCacheDelegate ();
	public NSCacheDelegate (NSCoder coder);
	public NSCacheDelegate (NSObjectFlag t);
	public NSCacheDelegate (IntPtr handle);
	
	public virtual void WillEvictObject (NSCache cache, NSObject obj);
}

Type Changed: MonoTouch.Foundation.NSCalendarUnit

Removed:

 Could not find MonoTouch.Foundation.NSCalendarUnit

Added:

 [Serializable]
 [Flags]
 public enum NSCalendarUnit {
 	NSEra,
 	NSYear,
 	NSMonth,
 	NSDay,
 	NSHour,
 	NSMinute,
 	NSSecond,
 	NSWeek,
 	NSWeekday,
 	NSWeekdayOrdinal,
 	NSQuarter,
 	NSCalendar,
 	NSTimeZone
 }

Type Changed: MonoTouch.Foundation.NSData

Added:

 	public bool Save (string file, NSDataWritingOptions options, out NSError error);

Type Changed: MonoTouch.Foundation.NSDataWritingOptions

Removed:

 Could not find MonoTouch.Foundation.NSDataWritingOptions

Added:

 [Serializable]
 [Flags]
 public enum NSDataWritingOptions : uint {
 	Atomic,
 	FileProtectionNone,
 	FileProtectionComplete,
 	NSDataWritingFileProtectionMask
 }

Type Changed: MonoTouch.Foundation.NSMutableAttributedString

Removed:

 	public NSMutableAttributedString (string str, MonoTouch.CoreText.CTStringAttributes attributes);

Added:

 	public NSMutableAttributedString (string str, MonoTouch.CoreText.CTStringAttributes attributes);

New Type: MonoTouch.Foundation.NSMutableSet

public class NSMutableSet : NSSet {
	
	public NSMutableSet ();
	public NSMutableSet (NSCoder coder);
	public NSMutableSet (NSObjectFlag t);
	public NSMutableSet (IntPtr handle);
	
	public virtual void Add (NSObject nso);
	public virtual void Remove (NSObject nso);
	
	public override IntPtr ClassHandle {
		get;
	}
}

Type Changed: MonoTouch.Foundation.NSNotificationCenter

Added:

 	public virtual void AddObserver (string name, NSObject obj, NSOperationQueue queue, NSNotificationHandler handler);

Type Changed: MonoTouch.Foundation.NSNotificationHandler

Removed:

 internal class NSNotificationHandler : NSObject {
 	
 	public NSNotificationHandler (Action<NSNotification> notify);
 	
 	public void Post (NSNotification s);
 }

Added:

 [Serializable]
 public delegate void NSNotificationHandler (NSNotification notification);

New Type: MonoTouch.Foundation.NSOperation

public class NSOperation : NSObject {
	
	public NSOperation ();
	public NSOperation (NSCoder coder);
	public NSOperation (NSObjectFlag t);
	public NSOperation (IntPtr handle);
	
	public virtual void AddDependency (NSOperation op);
	public virtual void Cancel ();
	public virtual void Main ();
	public virtual void RemoveDependency (NSOperation op);
	public virtual void Start ();
	public virtual void WaitUntilFinishedNS ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual NSOperation[] Dependencies {
		get;
	}
	public virtual bool IsCancelled {
		get;
	}
	public virtual bool IsConcurrent {
		get;
	}
	public virtual bool IsExecuting {
		get;
	}
	public virtual bool IsFinished {
		get;
	}
	public virtual bool IsReady {
		get;
	}
	public virtual NSOperationQueuePriority QueuePriority {
		get;
		set;
	}
	public virtual double ThreadPriority {
		get;
		set;
	}
}

New Type: MonoTouch.Foundation.NSOperationQueue

public class NSOperationQueue : NSObject {
	
	public NSOperationQueue ();
	public NSOperationQueue (NSCoder coder);
	public NSOperationQueue (NSObjectFlag t);
	public NSOperationQueue (IntPtr handle);
	
	public virtual void AddOperation (NSAction operation);
	public virtual void AddOperation (NSOperation op);
	public virtual void AddOperations (NSOperation[] operations, bool waitUntilFinished);
	public virtual void CancelAllOperations ();
	public virtual void WaitUntilAllOperationsAreFinished ();
	
	public static NSOperationQueue CurrentQueue {
		get;
	}
	public static NSOperationQueue MainQueue {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int MaxConcurrentOperationCount {
		get;
		set;
	}
	public virtual string Name {
		get;
		set;
	}
	public virtual int OperationCount {
		get;
	}
	public virtual NSOperation[] Operations {
		get;
	}
	public virtual bool Suspended {
		get;
		set;
	}
}

New Type: MonoTouch.Foundation.NSOperationQueuePriority

[Serializable]
public enum NSOperationQueuePriority {
	VeryLow,
	Low,
	Normal,
	High,
	VeryHigh
}

New Type: MonoTouch.Foundation.NSPredicate

public class NSPredicate : NSObject {
	
	public NSPredicate ();
	public NSPredicate (NSCoder coder);
	public NSPredicate (NSObjectFlag t);
	public NSPredicate (IntPtr handle);
	
	public virtual bool EvaluateWithObject (NSObject obj);
	
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.Foundation.NSPurgeableData

public class NSPurgeableData : NSMutableData {
	
	public NSPurgeableData ();
	public NSPurgeableData (NSCoder coder);
	public NSPurgeableData (NSObjectFlag t);
	public NSPurgeableData (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
}

Type Changed: MonoTouch.Foundation.NSSetEnumerator

Removed:

 Could not find MonoTouch.Foundation.NSSetEnumerator

Added:

 [Serializable]
 public delegate void NSSetEnumerator (NSObject obj, ref bool stop);

New Type: MonoTouch.Foundation.NSSortDescriptor

public class NSSortDescriptor : NSObject {
	
	public NSSortDescriptor ();
	public NSSortDescriptor (NSCoder coder);
	public NSSortDescriptor (NSObjectFlag t);
	public NSSortDescriptor (IntPtr handle);
	public NSSortDescriptor (string key, bool ascending);
	public NSSortDescriptor (string key, bool ascending, MonoTouch.ObjCRuntime.Selector selector);
	
	public virtual NSComparisonResult Compare (NSObject object1, NSObject object2);
	
	public virtual bool Ascending {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Key {
		get;
	}
	public virtual NSObject ReversedSortDescriptor {
		get;
	}
	public virtual MonoTouch.ObjCRuntime.Selector Selector {
		get;
	}
}

Type Changed: MonoTouch.Foundation.NSString

Added:

 	public string Format (MonoTouch.UIKit.UIFont withFont, float width, MonoTouch.UIKit.UILineBreakMode breakMode);

Type Changed: MonoTouch.Foundation.NSTimer

Removed:

 	public NSTimer (NSDate date, TimeSpan when, NSAction action, bool repeats);

Added:

 	public NSTimer (NSDate date, TimeSpan when, NSAction action, bool repeats);

Namespace: MonoTouch.GameKit

New Type: MonoTouch.GameKit.GKAchievement

public class GKAchievement : MonoTouch.Foundation.NSObject {
	
	public GKAchievement ();
	public GKAchievement (MonoTouch.Foundation.NSCoder coder);
	public GKAchievement (MonoTouch.Foundation.NSObjectFlag t);
	public GKAchievement (IntPtr handle);
	public GKAchievement (string identifier);
	
	public static void LoadAchievements (GKCompletionHandler completionHandler);
	public virtual void ReportAchievement (GKNotificationHandler handler);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Completed {
		get;
		set;
	}
	public virtual string Identifier {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSDate LastReportedDate {
		get;
		set;
	}
	public virtual double PercentComplete {
		get;
		set;
	}
	public virtual int Points {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKAchievementDescription

public class GKAchievementDescription : MonoTouch.Foundation.NSObject {
	
	public GKAchievementDescription ();
	public GKAchievementDescription (MonoTouch.Foundation.NSCoder coder);
	public GKAchievementDescription (MonoTouch.Foundation.NSObjectFlag t);
	public GKAchievementDescription (IntPtr handle);
	
	public static void LoadAchievementDescriptions (GKAchievementDescriptionHandler handler);
	public virtual void LoadImage (GKImageLoadedHandler imageLoadedHandler);
	
	public static MonoTouch.UIKit.UIImage PlaceholderCompletedAchievementImage {
		get;
	}
	public virtual string AchievedDescription {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Identifier {
		get;
		set;
	}
	public virtual MonoTouch.UIKit.UIImage Image {
		get;
		set;
	}
	public virtual MonoTouch.UIKit.UIImage IncompleteAchievementImage {
		get;
	}
	public virtual int MaximumPoints {
		get;
		set;
	}
	public virtual bool ShouldDisplayIfNotStarted {
		get;
		set;
	}
	public virtual string Title {
		get;
		set;
	}
	public virtual string UnachievedDescription {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKAchievementDescriptionHandler

[Serializable]
public delegate void GKAchievementDescriptionHandler (GKAchievementDescription[] descriptions, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKAchievementViewController

public class GKAchievementViewController : MonoTouch.UIKit.UINavigationController {
	
	public GKAchievementViewController ();
	public GKAchievementViewController (MonoTouch.Foundation.NSCoder coder);
	public GKAchievementViewController (MonoTouch.Foundation.NSObjectFlag t);
	public GKAchievementViewController (IntPtr handle);
	
	public virtual void SetDelegate (GKAchievementViewControllerDelegate target);
	
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.GameKit.GKAchievementViewControllerDelegate

public class GKAchievementViewControllerDelegate : MonoTouch.Foundation.NSObject {
	
	public GKAchievementViewControllerDelegate ();
	public GKAchievementViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
	public GKAchievementViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public GKAchievementViewControllerDelegate (IntPtr handle);
	
	public virtual void DidPressDismiss ();
}

New Type: MonoTouch.GameKit.GKCompletionHandler

[Serializable]
public delegate void GKCompletionHandler (GKAchievement[] achivements, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKDataEventArgs

public class GKDataEventArgs : EventArgs {
	
	public GKDataEventArgs (MonoTouch.Foundation.NSData data, GKPlayer player);
	
	public MonoTouch.Foundation.NSData Data {
		get;
		set;
	}
	public GKPlayer Player {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKError

[Serializable]
public enum GKError {
	Unknown,
	Cancelled,
	CommunicationsFailure,
	UserDenied,
	InvalidCredentials,
	NotAuthenticated,
	InvalidPlayer,
	ScoreNotSet,
	ParentalControlsBlocked,
	PlayerStatusExceedsMaximumLength,
	PlayerStatusInvalid,
	MatchRequestInvalid,
	FeatureNotAvailableInPreview
}

New Type: MonoTouch.GameKit.GKErrorEventArgs

public class GKErrorEventArgs : EventArgs {
	
	public GKErrorEventArgs (MonoTouch.Foundation.NSError error);
	
	public MonoTouch.Foundation.NSError Error {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKFriendsHandler

[Serializable]
public delegate void GKFriendsHandler (GKPlayer[] friends, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKImageLoadedHandler

[Serializable]
public delegate void GKImageLoadedHandler (MonoTouch.UIKit.UIImage image, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKInvite

public class GKInvite : MonoTouch.Foundation.NSObject {
	
	public GKInvite ();
	public GKInvite (MonoTouch.Foundation.NSCoder coder);
	public GKInvite (MonoTouch.Foundation.NSObjectFlag t);
	public GKInvite (IntPtr handle);
	
	public virtual bool Cancelled {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool Hosted {
		get;
	}
	public virtual GKPlayer Inviter {
		get;
	}
}

New Type: MonoTouch.GameKit.GKInviteHandler

[Serializable]
public delegate void GKInviteHandler (GKInvite invite);

New Type: MonoTouch.GameKit.GKLeaderboard

public class GKLeaderboard : MonoTouch.Foundation.NSObject {
	
	public GKLeaderboard ();
	public GKLeaderboard (MonoTouch.Foundation.NSCoder coder);
	public GKLeaderboard (MonoTouch.Foundation.NSObjectFlag t);
	public GKLeaderboard (IntPtr handle);
	public GKLeaderboard (GKPlayer[] players);
	
	public virtual void LoadScores (GKScoresLoadedHandler scoresLoadedHandler);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual GKScore LocalPlayerScore {
		get;
	}
	public virtual int MaxRange {
		get;
	}
	public virtual GKLeaderboardPlayerScope PlayerScope {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSRange Range {
		get;
		set;
	}
	public virtual GKScore[] Scores {
		get;
	}
	public virtual GKLeaderboardTimeScope TimeScope {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKLeaderboardPlayerScope

[Serializable]
public enum GKLeaderboardPlayerScope {
	Global,
	FriendsOnly
}

New Type: MonoTouch.GameKit.GKLeaderboardTimeScope

[Serializable]
public enum GKLeaderboardTimeScope {
	Today,
	Week,
	AllTime
}

New Type: MonoTouch.GameKit.GKLeaderboardViewController

public class GKLeaderboardViewController : MonoTouch.UIKit.UINavigationController {
	
	public GKLeaderboardViewController ();
	public GKLeaderboardViewController (MonoTouch.Foundation.NSCoder coder);
	public GKLeaderboardViewController (MonoTouch.Foundation.NSObjectFlag t);
	public GKLeaderboardViewController (IntPtr handle);
	public GKLeaderboardViewController (GKLeaderboardTimeScope timeScope, GKLeaderboardPlayerScope playerScope);
	
	public virtual void SetLeaderboardDelegate (GKLeaderboardViewController ldel);
	
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.GameKit.GKLeaderboardViewControllerDelegate

public class GKLeaderboardViewControllerDelegate : MonoTouch.Foundation.NSObject {
	
	public GKLeaderboardViewControllerDelegate ();
	public GKLeaderboardViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
	public GKLeaderboardViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public GKLeaderboardViewControllerDelegate (IntPtr handle);
	
	public virtual void LeaderboardDidPressDismiss ();
}

New Type: MonoTouch.GameKit.GKLocalPlayer

public class GKLocalPlayer : GKPlayer {
	
	public GKLocalPlayer ();
	public GKLocalPlayer (MonoTouch.Foundation.NSCoder coder);
	public GKLocalPlayer (MonoTouch.Foundation.NSObjectFlag t);
	public GKLocalPlayer (IntPtr handle);
	
	public virtual void Authenticate (GKNotificationHandler handler);
	public virtual void LoadFriends (GKFriendsHandler handler);
	public virtual void SetStatus (string status, GKNotificationHandler errorHandler);
	
	public virtual bool Authenticated {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual GKPlayer[] Friends {
		get;
	}
	public virtual GKLocalPlayer LocalPlayer {
		get;
	}
	public virtual string Status {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKMatch

public class GKMatch : MonoTouch.Foundation.NSObject {
	
	public GKMatch ();
	public GKMatch (MonoTouch.Foundation.NSCoder coder);
	public GKMatch (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatch (IntPtr handle);
	
	public virtual void Disconnect ();
	public virtual bool SendData (MonoTouch.Foundation.NSData data, GKPlayer[] players, GKMatchSendDataMode mode, MonoTouch.Foundation.NSError error);
	public virtual bool SendDataToAllPlayerswithDataModeerror (MonoTouch.Foundation.NSData data, GKMatchSendDataMode mode, IntPtr ptrToNSErrorHandle);
	public virtual GKVoiceChat VoiceChatWithName (string name);
	
	public override IntPtr ClassHandle {
		get;
	}
	public GKMatchDelegate Delegate {
		get;
		set;
	}
	public virtual int ExpectedPlayerCount {
		get;
	}
	public virtual GKPlayer[] Players {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler ConnectionFailed;
	public event EventHandler DataReceived;
	public event EventHandler Failed;
	public event EventHandler StateChanged;
}

New Type: MonoTouch.GameKit.GKMatchDelegate

public abstract class GKMatchDelegate : MonoTouch.Foundation.NSObject {
	
	public GKMatchDelegate ();
	public GKMatchDelegate (MonoTouch.Foundation.NSCoder coder);
	public GKMatchDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatchDelegate (IntPtr handle);
	
	public abstract void ConnectionFailed (GKMatch match, GKPlayer player, MonoTouch.Foundation.NSError error);
	public abstract void DataReceived (GKMatch match, MonoTouch.Foundation.NSData data, GKPlayer player);
	public abstract void Failed (GKMatch match, MonoTouch.Foundation.NSError error);
	public abstract void StateChanged (GKMatch match, GKPlayer player, GKPlayerConnectionState state);
}

New Type: MonoTouch.GameKit.GKMatchEventArgs

public class GKMatchEventArgs : EventArgs {
	
	public GKMatchEventArgs (GKMatch match);
	
	public GKMatch Match {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKMatchmaker

public class GKMatchmaker : MonoTouch.Foundation.NSObject {
	
	public GKMatchmaker ();
	public GKMatchmaker (MonoTouch.Foundation.NSCoder coder);
	public GKMatchmaker (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatchmaker (IntPtr handle);
	
	public virtual void AddPlayers (GKMatch toMatch, GKMatchRequest matchRequest, GKNotificationHandler completionHandler);
	public virtual void Cancel ();
	public virtual void CreateMatch (GKMatchRequest request, GKNotificationMatch completionHandler);
	public virtual void FindPlayers (GKMatchRequest request, GKFriendsHandler handler);
	public virtual void QueryPlayerGroupActivity (int playerGroup, GKQueryHandler handler);
	public virtual void SetInviteHandler (GKInviteHandler handler);
	
	public static GKMatchmaker SharedMatchmaker {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.GameKit.GKMatchmakerViewController

public class GKMatchmakerViewController : MonoTouch.UIKit.UIViewController {
	
	public GKMatchmakerViewController ();
	public GKMatchmakerViewController (MonoTouch.Foundation.NSCoder coder);
	public GKMatchmakerViewController (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatchmakerViewController (IntPtr handle);
	public GKMatchmakerViewController (GKMatchRequest request);
	public GKMatchmakerViewController (GKMatchRequest request, GKPlayer[] players);
	public GKMatchmakerViewController (GKInvite invite);
	
	public virtual void SetHostedPlayerReady (GKPlayer player);
	
	public override IntPtr ClassHandle {
		get;
	}
	public GKMatchmakerViewControllerDelegate Delegate {
		get;
		set;
	}
	public virtual bool Hosted {
		get;
		set;
	}
	public virtual GKMatchRequest MatchRequest {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler Cancelled;
	public event EventHandler Failed;
	public event EventHandler MatchCreated;
	public event EventHandler PlayersFound;
}

New Type: MonoTouch.GameKit.GKMatchmakerViewControllerDelegate

public abstract class GKMatchmakerViewControllerDelegate : MonoTouch.Foundation.NSObject {
	
	public GKMatchmakerViewControllerDelegate ();
	public GKMatchmakerViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
	public GKMatchmakerViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatchmakerViewControllerDelegate (IntPtr handle);
	
	public abstract void Cancelled (GKMatchmakerViewController viewController);
	public abstract void Failed (GKMatchmakerViewController viewController, MonoTouch.Foundation.NSError error);
	public abstract void MatchCreated (GKMatchmakerViewController viewController, GKMatch match);
	public abstract void PlayersFound (GKMatchmakerViewController viewController, GKPlayer[] players);
}

New Type: MonoTouch.GameKit.GKMatchRequest

public class GKMatchRequest : MonoTouch.Foundation.NSObject {
	
	public GKMatchRequest ();
	public GKMatchRequest (MonoTouch.Foundation.NSCoder coder);
	public GKMatchRequest (MonoTouch.Foundation.NSObjectFlag t);
	public GKMatchRequest (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int MaxPlayers {
		get;
		set;
	}
	public virtual int PlayerGroup {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKMatchSendDataMode

[Serializable]
public enum GKMatchSendDataMode {
	Reliable,
	Unreliable
}

New Type: MonoTouch.GameKit.GKNotificationHandler

[Serializable]
public delegate void GKNotificationHandler (MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKNotificationMatch

[Serializable]
public delegate void GKNotificationMatch (GKMatch match, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKPlayer

public class GKPlayer : MonoTouch.Foundation.NSObject {
	
	public GKPlayer ();
	public GKPlayer (MonoTouch.Foundation.NSCoder coder);
	public GKPlayer (MonoTouch.Foundation.NSObjectFlag t);
	public GKPlayer (IntPtr handle);
	
	public virtual string Alias {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual bool IsFriend {
		get;
	}
	public virtual string PlayerID {
		get;
	}
	public virtual string Status {
		get;
	}
}

New Type: MonoTouch.GameKit.GKPlayerConnectionState

[Serializable]
public enum GKPlayerConnectionState {
	Unknown,
	Connected,
	Disconnected
}

New Type: MonoTouch.GameKit.GKPlayerErrorEventArgs

public class GKPlayerErrorEventArgs : EventArgs {
	
	public GKPlayerErrorEventArgs (GKPlayer player, MonoTouch.Foundation.NSError error);
	
	public MonoTouch.Foundation.NSError Error {
		get;
		set;
	}
	public GKPlayer Player {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKPlayersEventArgs

public class GKPlayersEventArgs : EventArgs {
	
	public GKPlayersEventArgs (GKPlayer[] players);
	
	public GKPlayer[] Players {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKQueryHandler

[Serializable]
public delegate void GKQueryHandler (int activity, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKScore

public class GKScore : MonoTouch.Foundation.NSObject {
	
	public GKScore ();
	public GKScore (MonoTouch.Foundation.NSCoder coder);
	public GKScore (MonoTouch.Foundation.NSObjectFlag t);
	public GKScore (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate Date {
		get;
		set;
	}
	public virtual string FormattedValue {
		get;
	}
	public virtual GKPlayer Player {
		get;
	}
	public virtual int Rank {
		get;
	}
	public virtual int Value {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKScoresLoadedHandler

[Serializable]
public delegate void GKScoresLoadedHandler (GKScore[] scoreArray, MonoTouch.Foundation.NSError error);

New Type: MonoTouch.GameKit.GKStateEventArgs

public class GKStateEventArgs : EventArgs {
	
	public GKStateEventArgs (GKPlayer player, GKPlayerConnectionState state);
	
	public GKPlayer Player {
		get;
		set;
	}
	public GKPlayerConnectionState State {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKVoiceChat

public class GKVoiceChat : MonoTouch.Foundation.NSObject {
	
	public GKVoiceChat ();
	public GKVoiceChat (MonoTouch.Foundation.NSCoder coder);
	public GKVoiceChat (MonoTouch.Foundation.NSObjectFlag t);
	public GKVoiceChat (IntPtr handle);
	
	public virtual void SetMute (bool isMuted, GKPlayer player);
	public virtual void Start ();
	public virtual void Stop ();
	
	public virtual bool Active {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Name {
		get;
	}
	public virtual float Volume {
		get;
		set;
	}
}

New Type: MonoTouch.GameKit.GKVoiceChatPlayerState

[Serializable]
public enum GKVoiceChatPlayerState {
	Connected,
	Disconnected,
	Speaking,
	Silent
}

Namespace: MonoTouch.MapKit

Type Changed: MonoTouch.MapKit.MKAnnotation

Added:

 		set;

Type Changed: MonoTouch.MapKit.MKAnnotationViewDragState

Removed:

 Could not find MonoTouch.MapKit.MKAnnotationViewDragState

Added:

 [Serializable]
 public enum MKAnnotationViewDragState {
 	None,
 	Starting,
 	Dragging,
 	Canceling,
 	Ending
 }

Type Changed: MonoTouch.MapKit.MKAnnotationViewEventArgs

Removed:

 Could not find MonoTouch.MapKit.MKAnnotationViewEventArgs

Added:

 public class MKAnnotationViewEventArgs : EventArgs {
 	
 	public MKAnnotationViewEventArgs (MKAnnotationView view);
 	
 	public MKAnnotationView View {
 		get;
 		set;
 	}
 }

New Type: MonoTouch.MapKit.MKCircle

public class MKCircle : MKShape {
	
	public MKCircle ();
	public MKCircle (MonoTouch.Foundation.NSCoder coder);
	public MKCircle (MonoTouch.Foundation.NSObjectFlag t);
	public MKCircle (IntPtr handle);
	
	public static MKCircle Circle (MonoTouch.CoreLocation.CLLocationCoordinate2D withcenterCoordinate, double radius);
	public static MKCircle CircleWithMapRect (MKMapRect mapRect);
	
	public virtual MKMapRect BoundingMap {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
		get;
	}
	public virtual double Radius {
		get;
	}
}

New Type: MonoTouch.MapKit.MKCircleView

public class MKCircleView : MKOverlayPathView {
	
	public MKCircleView ();
	public MKCircleView (MonoTouch.Foundation.NSCoder coder);
	public MKCircleView (MonoTouch.Foundation.NSObjectFlag t);
	public MKCircleView (IntPtr handle);
	public MKCircleView (MKCircle circle);
	
	public virtual MKCircle Circle {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.MapKit.MKMapPoint

public struct MKMapPoint {
	
	public MKMapPoint (double x, double y);
	
	public override bool Equals (object other);
	
	public static bool operator == (MKMapPoint a, MKMapPoint b);
	public static bool operator != (MKMapPoint a, MKMapPoint b);
	
	public double X;
	public double Y;
}

New Type: MonoTouch.MapKit.MKMapRect

public struct MKMapRect {
	
	public MKMapRect (MKMapPoint origin, MKMapSize size);
	public MKMapRect (double x, double y, double width, double height);
	
	public double Height {
		get;
	}
	public bool IsEmpty {
		get;
	}
	public bool IsNull {
		get;
	}
	public double MaxX {
		get;
	}
	public double MaxY {
		get;
	}
	public double MidX {
		get;
	}
	public double MidY {
		get;
	}
	public double MinX {
		get;
	}
	public double MinY {
		get;
	}
	public double Width {
		get;
	}
	
	public MKMapPoint Origin;
	public MKMapSize Size;
}

New Type: MonoTouch.MapKit.MKMapSize

public struct MKMapSize {
	
	public MKMapSize (double width, double height);
	
	public double Width;
	public double Height;
}

Type Changed: MonoTouch.MapKit.MKMapView

Added:

 	public virtual void AddOverlay (MKOverlay overlay);
 	public virtual void AddOverlays (MKOverlay[] overlays);
 	public virtual void ExchangeOverlays (int index1, int index2);
 	public virtual void InsertOverlay (MKOverlay overlay, int index);
 	public virtual void InsertOverlayAbove (MKOverlay overlay, MKOverlay sibling);
 	public virtual void InsertOverlayBelow (MKOverlay overlay, MKOverlay sibling);
 	public virtual MKMapRect MapRectThatFits (MKMapRect mapRect);
 	public virtual MKMapRect MapRectThatFits (MKMapRect mapRect, MonoTouch.UIKit.UIEdgeInsets edgePadding);
 	public virtual void RemoveOverlay (MKOverlay overlay);
 	public virtual void RemoveOverlays (MKOverlay[] overlays);
 	public virtual void SetVisibleMapRect (MKMapRect mapRect, bool animate);
 	public virtual void SetVisibleMapRect (MKMapRect mapRect, MonoTouch.UIKit.UIEdgeInsets edgePadding, bool animate);
 	public virtual MKOverlayView ViewForOverlay (MKOverlay overlay);
 	public MKMapViewOverlay GetViewForOverlay {
 		get;
 		set;
 	}
 	public virtual MKOverlay[] Overlays {
 		get;
 	}
 	public virtual MKMapRect visibleMapRect {
 		get;
 		set;
 	}
 	public event EventHandler<MKMapViewDragStateEventArgs> ChangedDragState;
 	public event EventHandler<MKOverlayViewsEventArgs> DidAddOverlayViews;
 	public event EventHandler<MKAnnotationViewEventArgs> DidDeselectAnnotationView;
 	public event System.EventHandler<MonoTouch.Foundation.NSErrorEventArgs> DidFailToLocateUser;
 	public event EventHandler<MKAnnotationViewEventArgs> DidSelectAnnotationView;
 	public event EventHandler DidStopLocatingUser;
 	public event EventHandler<MKUserLocationEventArgs> DidUpdateUserLocation;
 	public event EventHandler WillStartLocatingUser;

Type Changed: MonoTouch.MapKit.MKMapViewDelegate

Added:

 	public virtual void ChangedDragState (MKMapView mapView, MKAnnotationView annotationView, MKAnnotationViewDragState newState, MKAnnotationViewDragState oldState);
 	public virtual void DidAddOverlayViews (MKMapView mapView, MKOverlayView overlayViews);
 	public virtual void DidDeselectAnnotationView (MKMapView mapView, MKAnnotationView view);
 	public virtual void DidFailToLocateUser (MKMapView mapView, MonoTouch.Foundation.NSError error);
 	public virtual void DidSelectAnnotationView (MKMapView mapView, MKAnnotationView view);
 	public virtual void DidStopLocatingUser (MKMapView mapView);
 	public virtual void DidUpdateUserLocation (MKMapView mapView, MKUserLocation userLocation);
 	public virtual MKOverlayView GetViewForOverlay (MKMapView mapView, MKOverlay overlay);
 	public virtual void WillStartLocatingUser (MKMapView mapView);

Type Changed: MonoTouch.MapKit.MKMapViewDragStateEventArgs

Removed:

 Could not find MonoTouch.MapKit.MKMapViewDragStateEventArgs

Added:

 public class MKMapViewDragStateEventArgs : EventArgs {
 	
 	public MKMapViewDragStateEventArgs (MKAnnotationView annotationView, MKAnnotationViewDragState newState, MKAnnotationViewDragState oldState);
 	
 	public MKAnnotationView AnnotationView {
 		get;
 		set;
 	}
 	public MKAnnotationViewDragState NewState {
 		get;
 		set;
 	}
 	public MKAnnotationViewDragState OldState {
 		get;
 		set;
 	}
 }

Type Changed: MonoTouch.MapKit.MKMapViewOverlay

Removed:

 Could not find MonoTouch.MapKit.MKMapViewOverlay

Added:

 [Serializable]
 public delegate MKOverlayView MKMapViewOverlay (MKMapView mapView, MKOverlay overlay);

New Type: MonoTouch.MapKit.MKMultiPoint

public class MKMultiPoint : MKShape {
	
	public MKMultiPoint ();
	public MKMultiPoint (MonoTouch.Foundation.NSCoder coder);
	public MKMultiPoint (MonoTouch.Foundation.NSObjectFlag t);
	public MKMultiPoint (IntPtr handle);
	
	public MonoTouch.CoreLocation.CLLocationCoordinate2D[] GetCoordinates (int first, int count);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual int PointCount {
		get;
	}
	public MKMapPoint[] Points {
		get;
	}
}

New Type: MonoTouch.MapKit.MKOverlay

public abstract class MKOverlay : MonoTouch.Foundation.NSObject {
	
	public MKOverlay ();
	public MKOverlay (MonoTouch.Foundation.NSCoder coder);
	public MKOverlay (MonoTouch.Foundation.NSObjectFlag t);
	public MKOverlay (IntPtr handle);
	
	public abstract bool IntersectsMapRect (MKMapRect mapRect);
	
	public abstract MKMapRect BoundingMapRect {
		get;
	}
	public abstract MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
		get;
	}
}

New Type: MonoTouch.MapKit.MKOverlayPathView

public class MKOverlayPathView : MKOverlayView {
	
	public MKOverlayPathView ();
	public MKOverlayPathView (MonoTouch.Foundation.NSCoder coder);
	public MKOverlayPathView (MonoTouch.Foundation.NSObjectFlag t);
	public MKOverlayPathView (IntPtr handle);
	
	public virtual void ApplyFillProperties (MonoTouch.CoreGraphics.CGContext context, float zoomScale);
	public virtual void ApplyStrokeProperties (MonoTouch.CoreGraphics.CGContext context, float zoomScale);
	public virtual void CreatePath ();
	public virtual void FillPath (MonoTouch.CoreGraphics.CGPath path, MonoTouch.CoreGraphics.CGContext context);
	public virtual void InvalidatePath ();
	public virtual void StrokePath (MonoTouch.CoreGraphics.CGPath path, MonoTouch.CoreGraphics.CGContext context);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.UIKit.UIColor FillColor {
		get;
		set;
	}
	public virtual MonoTouch.CoreGraphics.CGLineCap Linecap {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSNumber[] LineDashPattern {
		get;
		set;
	}
	public virtual float LineDashPhase {
		get;
		set;
	}
	public virtual MonoTouch.CoreGraphics.CGLineJoin LineJoin {
		get;
		set;
	}
	public virtual float LineWidth {
		get;
		set;
	}
	public virtual float MiterLimit {
		get;
		set;
	}
	public virtual MonoTouch.CoreGraphics.CGPath Path {
		get;
		set;
	}
	public virtual MonoTouch.UIKit.UIColor StrokeColor {
		get;
		set;
	}
}

New Type: MonoTouch.MapKit.MKOverlayView

public class MKOverlayView : MonoTouch.UIKit.UIView {
	
	public MKOverlayView ();
	public MKOverlayView (MonoTouch.Foundation.NSCoder coder);
	public MKOverlayView (MonoTouch.Foundation.NSObjectFlag t);
	public MKOverlayView (IntPtr handle);
	public MKOverlayView (MKOverlay overlay);
	
	public static float MKRoadWidthAtZoomScale (float zoomScale);
	public virtual bool CanDrawMapRect (MKMapRect mapRect, float zoomScale);
	public virtual void DrawMapRect (MKMapRect mapRect, float zoomScale, MonoTouch.CoreGraphics.CGContext context);
	public virtual MKMapPoint MapPointForPoint (System.Drawing.PointF point);
	public virtual MKMapRect MapRectForRect (System.Drawing.RectangleF rect);
	public virtual System.Drawing.PointF PointForMapPoint (MKMapPoint mapPoint);
	public virtual System.Drawing.RectangleF RectForMapRect (MKMapRect mapRect);
	public virtual void SetNeedsDisplay (MKMapRect mapRect);
	public virtual void SetNeedsDisplay (MKMapRect mapRect, float zoomScale);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MKOverlay Overlay {
		get;
	}
}

New Type: MonoTouch.MapKit.MKOverlayViewsEventArgs

public class MKOverlayViewsEventArgs : EventArgs {
	
	public MKOverlayViewsEventArgs (MKOverlayView overlayViews);
	
	public MKOverlayView OverlayViews {
		get;
		set;
	}
}

Type Changed: MonoTouch.MapKit.MKPinAnnotationView

Added:

 	public virtual bool Draggable {
 		get;
 		set;
 	}
 	public virtual MKAnnotationViewDragState DragState {
 		get;
 		set;
 	}

New Type: MonoTouch.MapKit.MKPointAnnotation

public class MKPointAnnotation : MKShape {
	
	public MKPointAnnotation ();
	public MKPointAnnotation (MonoTouch.Foundation.NSCoder coder);
	public MKPointAnnotation (MonoTouch.Foundation.NSObjectFlag t);
	public MKPointAnnotation (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.CoreLocation.CLLocationCoordinate2D Coordinate {
		get;
		set;
	}
}

New Type: MonoTouch.MapKit.MKPolygon

public class MKPolygon : MKMultiPoint {
	
	public MKPolygon ();
	public MKPolygon (MonoTouch.Foundation.NSCoder coder);
	public MKPolygon (MonoTouch.Foundation.NSObjectFlag t);
	public MKPolygon (IntPtr handle);
	
	public static MKPolygon _FromPoints (IntPtr points, int count, MKPolygon[] interiorPolygons);
	public static MKPolygon FromCoordinates (MonoTouch.CoreLocation.CLLocationCoordinate2D[] coords);
	public static MKPolygon FromCoordinates (MonoTouch.CoreLocation.CLLocationCoordinate2D[] coords, MKPolygon[] interiorPolygons);
	public static MKPolygon FromPoints (MKMapPoint[] points);
	public static MKPolygon FromPoints (MKMapPoint[] points, MKPolygon[] interiorPolygons);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MKPolygon InteriorPolygons {
		get;
	}
}

New Type: MonoTouch.MapKit.MKPolygonView

public class MKPolygonView : MKOverlayPathView {
	
	public MKPolygonView ();
	public MKPolygonView (MonoTouch.Foundation.NSCoder coder);
	public MKPolygonView (MonoTouch.Foundation.NSObjectFlag t);
	public MKPolygonView (IntPtr handle);
	public MKPolygonView (MKPolygon polygon);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MKPolygon Polygon {
		get;
	}
}

New Type: MonoTouch.MapKit.MKPolyline

public class MKPolyline : MKMultiPoint {
	
	public MKPolyline ();
	public MKPolyline (MonoTouch.Foundation.NSCoder coder);
	public MKPolyline (MonoTouch.Foundation.NSObjectFlag t);
	public MKPolyline (IntPtr handle);
	
	public static MKPolyline FromCoordinates (MonoTouch.CoreLocation.CLLocationCoordinate2D[] coords);
	
	public override IntPtr ClassHandle {
		get;
	}
}

New Type: MonoTouch.MapKit.MKPolylineView

public class MKPolylineView : MKOverlayPathView {
	
	public MKPolylineView ();
	public MKPolylineView (MonoTouch.Foundation.NSCoder coder);
	public MKPolylineView (MonoTouch.Foundation.NSObjectFlag t);
	public MKPolylineView (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MKPolyline Polyline {
		get;
	}
}

New Type: MonoTouch.MapKit.MKShape

public class MKShape : MonoTouch.Foundation.NSObject {
	
	public MKShape ();
	public MKShape (MonoTouch.Foundation.NSCoder coder);
	public MKShape (MonoTouch.Foundation.NSObjectFlag t);
	public MKShape (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Subtitle {
		get;
		set;
	}
	public virtual string Title {
		get;
		set;
	}
}

Type Changed: MonoTouch.MapKit.MKUserLocationEventArgs

Removed:

 Could not find MonoTouch.MapKit.MKUserLocationEventArgs

Added:

 public class MKUserLocationEventArgs : EventArgs {
 	
 	public MKUserLocationEventArgs (MKUserLocation userLocation);
 	
 	public MKUserLocation UserLocation {
 		get;
 		set;
 	}
 }

Namespace: MonoTouch.MediaPlayer

Type Changed: MonoTouch.MediaPlayer.ItemsPickedEventArgs

Added:

 		set;

Type Changed: MonoTouch.MediaPlayer.MPMediaItem

Added:

 	public virtual void EnumerateValues (MonoTouch.Foundation.NSSet propertiesToEnumerate, MPMediaItemEnumerator enumerator);

Type Changed: MonoTouch.MediaPlayer.MPMediaItemEnumerator

Removed:

 Could not find MonoTouch.MediaPlayer.MPMediaItemEnumerator

Added:

 [Serializable]
 public delegate void MPMediaItemEnumerator (string property, MonoTouch.Foundation.NSObject value, ref bool stop);

Type Changed: MonoTouch.MediaPlayer.MPMediaItemProperty

Added:

 	public const string BeatsPerMinute = "beatsPerMinute";
 	public const string Comments = "comments";
 	public const string AssetUrl = "assetURL";
 	public const string ReleaseDate = "releaseDate";
 	public const string UserGrouping = "userGrouping";

Type Changed: MonoTouch.MediaPlayer.MPMoviePlayerController

Added:

 	public virtual MPTimedMetadata[] TimedMetadata {
 		get;
 	}

New Type: MonoTouch.MediaPlayer.MPTimedMetadata

public class MPTimedMetadata : MonoTouch.Foundation.NSObject {
	
	public MPTimedMetadata ();
	public MPTimedMetadata (MonoTouch.Foundation.NSCoder coder);
	public MPTimedMetadata (MonoTouch.Foundation.NSObjectFlag t);
	public MPTimedMetadata (IntPtr handle);
	
	public virtual MonoTouch.Foundation.NSDictionary AllMetadata {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string Key {
		get;
	}
	public virtual string Keyspace {
		get;
	}
	public virtual double Timestamp {
		get;
	}
	public virtual MonoTouch.Foundation.NSObject value {
		get;
	}
}

Namespace: MonoTouch.MessageUI

New Type: MonoTouch.MessageUI.MessageComposeResult

[Serializable]
public enum MessageComposeResult {
	Cancelled,
	Sent,
	Failed
}

New Type: MonoTouch.MessageUI.MFMessageComposeViewController

public class MFMessageComposeViewController : MonoTouch.UIKit.UINavigationController {
	
	public MFMessageComposeViewController ();
	public MFMessageComposeViewController (MonoTouch.Foundation.NSCoder coder);
	public MFMessageComposeViewController (MonoTouch.Foundation.NSObjectFlag t);
	public MFMessageComposeViewController (IntPtr handle);
	
	public static bool CanSendText {
		get;
	}
	public virtual string Body {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public MFMessageComposeViewControllerDelegate MessageComposeDelegate {
		get;
		set;
	}
	public virtual string [] Recipients {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject WeakMessageComposeDelegate {
		get;
		set;
	}
}

New Type: MonoTouch.MessageUI.MFMessageComposeViewControllerDelegate

public abstract class MFMessageComposeViewControllerDelegate : MonoTouch.Foundation.NSObject {
	
	public MFMessageComposeViewControllerDelegate ();
	public MFMessageComposeViewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
	public MFMessageComposeViewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public MFMessageComposeViewControllerDelegate (IntPtr handle);
	
	public abstract void Finished (MFMessageComposeViewController controller, MessageComposeResult result);
}

Namespace: MonoTouch.ObjCRuntime

New Type: MonoTouch.ObjCRuntime.BlockDescriptor

public struct BlockDescriptor {
	
	public int reserved;
	public int size;
	public IntPtr copy_helper;
	public IntPtr dispose;
}

New Type: MonoTouch.ObjCRuntime.BlockLiteral

public struct BlockLiteral {
	
	public static IntPtr CreateBlock (Delegate trampoline, Delegate userDelegate);
	
	public IntPtr isa;
	public int flags;
	public int reserved;
	public IntPtr invoke;
	public IntPtr block_descriptor;
	public IntPtr handle;
}

Type Changed: MonoTouch.ObjCRuntime.Messaging

Removed:

 	public static bool Boolean_objc_msgSend_Boolean_int (IntPtr receiver, IntPtr selector, bool arg1, int arg2);
 	public static bool Boolean_objc_msgSendSuper_Boolean_int (IntPtr receiver, IntPtr selector, bool arg1, int arg2);

Added:

 	public static bool Boolean_objc_msgSend_Boolean_int_IntPtr (IntPtr receiver, IntPtr selector, bool arg1, int arg2, IntPtr arg3);
 	public static bool Boolean_objc_msgSend_CLLocationCoordinate2D (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1);
 	public static bool Boolean_objc_msgSend_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static bool Boolean_objc_msgSend_CMTime_CGAffineTransform_CGAffineTransform_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreGraphics.CGAffineTransform arg2, MonoTouch.CoreGraphics.CGAffineTransform arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static bool Boolean_objc_msgSend_CMTime_CMTime_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static bool Boolean_objc_msgSend_CMTime_float_float_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, float arg2, float arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static bool Boolean_objc_msgSend_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static bool Boolean_objc_msgSend_MKMapRect_float (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2);
 	public static bool Boolean_objc_msgSendSuper_Boolean_int_IntPtr (IntPtr receiver, IntPtr selector, bool arg1, int arg2, IntPtr arg3);
 	public static bool Boolean_objc_msgSendSuper_CLLocationCoordinate2D (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1);
 	public static bool Boolean_objc_msgSendSuper_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static bool Boolean_objc_msgSendSuper_CMTime_CGAffineTransform_CGAffineTransform_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreGraphics.CGAffineTransform arg2, MonoTouch.CoreGraphics.CGAffineTransform arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static bool Boolean_objc_msgSendSuper_CMTime_CMTime_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static bool Boolean_objc_msgSendSuper_CMTime_float_float_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, float arg2, float arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static bool Boolean_objc_msgSendSuper_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static bool Boolean_objc_msgSendSuper_MKMapRect_float (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2);
 	public static void CMTime_objc_msgSend_stret (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector);
 	public static void CMTime_objc_msgSend_stret_CMTime (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static void CMTime_objc_msgSendSuper_stret (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector);
 	public static void CMTime_objc_msgSendSuper_stret_CMTime (out MonoTouch.CoreMedia.CMTime retval, IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static void CMTimeMapping_objc_msgSend_stret (out MonoTouch.CoreMedia.CMTimeMapping retval, IntPtr receiver, IntPtr selector);
 	public static void CMTimeMapping_objc_msgSendSuper_stret (out MonoTouch.CoreMedia.CMTimeMapping retval, IntPtr receiver, IntPtr selector);
 	public static void CMTimeRange_objc_msgSend_stret (out MonoTouch.CoreMedia.CMTimeRange retval, IntPtr receiver, IntPtr selector);
 	public static void CMTimeRange_objc_msgSendSuper_stret (out MonoTouch.CoreMedia.CMTimeRange retval, IntPtr receiver, IntPtr selector);
 	public static IntPtr IntPtr_objc_msgSend_CLLocationCoordinate2D_Double (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2);
 	public static IntPtr IntPtr_objc_msgSend_CLLocationCoordinate2D_Double_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static IntPtr IntPtr_objc_msgSend_CMTime_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, IntPtr arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1);
 	public static IntPtr IntPtr_objc_msgSend_int_int_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_int_int_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, IntPtr arg3, IntPtr arg4, IntPtr arg5, IntPtr arg6, IntPtr arg7, IntPtr arg8, IntPtr arg9);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, bool arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_float_int (IntPtr receiver, IntPtr selector, IntPtr arg1, float arg2, int arg3);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_int_CMTimeRange_CMTimeRange (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, MonoTouch.CoreMedia.CMTimeRange arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static IntPtr IntPtr_objc_msgSend_IntPtr_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSend_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static IntPtr IntPtr_objc_msgSendSuper_CLLocationCoordinate2D_Double (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2);
 	public static IntPtr IntPtr_objc_msgSendSuper_CLLocationCoordinate2D_Double_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreLocation.CLLocationCoordinate2D arg1, double arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static IntPtr IntPtr_objc_msgSendSuper_CMTime_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, IntPtr arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1);
 	public static IntPtr IntPtr_objc_msgSendSuper_int_int_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_int_int_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, int arg1, int arg2, IntPtr arg3, IntPtr arg4, IntPtr arg5, IntPtr arg6, IntPtr arg7, IntPtr arg8, IntPtr arg9);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_Boolean_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, bool arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_float_int (IntPtr receiver, IntPtr selector, IntPtr arg1, float arg2, int arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_int_CMTimeRange_CMTimeRange (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, MonoTouch.CoreMedia.CMTimeRange arg3, MonoTouch.CoreMedia.CMTimeRange arg4);
 	public static IntPtr IntPtr_objc_msgSendSuper_IntPtr_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, int arg2, IntPtr arg3);
 	public static IntPtr IntPtr_objc_msgSendSuper_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void MKMapPoint_objc_msgSend_stret_PointF (out MonoTouch.MapKit.MKMapPoint retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static void MKMapPoint_objc_msgSendSuper_stret_PointF (out MonoTouch.MapKit.MKMapPoint retval, IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1);
 	public static void MKMapRect_objc_msgSend_stret (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector);
 	public static void MKMapRect_objc_msgSend_stret_MKMapRect (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void MKMapRect_objc_msgSend_stret_MKMapRect_UIEdgeInsets (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, MonoTouch.UIKit.UIEdgeInsets arg2);
 	public static void MKMapRect_objc_msgSend_stret_RectangleF (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1);
 	public static void MKMapRect_objc_msgSendSuper_stret (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector);
 	public static void MKMapRect_objc_msgSendSuper_stret_MKMapRect (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void MKMapRect_objc_msgSendSuper_stret_MKMapRect_UIEdgeInsets (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, MonoTouch.UIKit.UIEdgeInsets arg2);
 	public static void MKMapRect_objc_msgSendSuper_stret_RectangleF (out MonoTouch.MapKit.MKMapRect retval, IntPtr receiver, IntPtr selector, System.Drawing.RectangleF arg1);
 	public static System.Drawing.PointF PointF_objc_msgSend_MKMapPoint (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapPoint arg1);
 	public static void PointF_objc_msgSend_stret_MKMapPoint (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapPoint arg1);
 	public static System.Drawing.PointF PointF_objc_msgSendSuper_MKMapPoint (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapPoint arg1);
 	public static void PointF_objc_msgSendSuper_stret_MKMapPoint (out System.Drawing.PointF retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapPoint arg1);
 	public static void RectangleF_objc_msgSend_stret_MKMapRect (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void RectangleF_objc_msgSendSuper_stret_MKMapRect (out System.Drawing.RectangleF retval, IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void void_objc_msgSend_CGAffineTransform_CGAffineTransform_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreGraphics.CGAffineTransform arg1, MonoTouch.CoreGraphics.CGAffineTransform arg2, MonoTouch.CoreMedia.CMTimeRange arg3);
 	public static void void_objc_msgSend_CGAffineTransform_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreGraphics.CGAffineTransform arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSend_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static void void_objc_msgSend_CMTime_CMTime_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static void void_objc_msgSend_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1);
 	public static void void_objc_msgSend_CMTimeRange_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSend_Double_Double_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, double arg1, double arg2, int arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSend_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, double arg1, IntPtr arg2, IntPtr arg3);
 	public static void void_objc_msgSend_float_CMTime (IntPtr receiver, IntPtr selector, float arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSend_float_float_CMTimeRange (IntPtr receiver, IntPtr selector, float arg1, float arg2, MonoTouch.CoreMedia.CMTimeRange arg3);
 	public static void void_objc_msgSend_Int64 (IntPtr receiver, IntPtr selector, long arg1);
 	public static void void_objc_msgSend_IntPtr_Double_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, double arg2, int arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSend_IntPtr_float (IntPtr receiver, IntPtr selector, IntPtr arg1, float arg2);
 	public static void void_objc_msgSend_IntPtr_IntPtr_Double_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, double arg3, int arg4, IntPtr arg5);
 	public static void void_objc_msgSend_IntPtr_IntPtr_int_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3, int arg4);
 	public static void void_objc_msgSend_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void void_objc_msgSend_MKMapRect_Boolean (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, bool arg2);
 	public static void void_objc_msgSend_MKMapRect_float (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2);
 	public static void void_objc_msgSend_MKMapRect_float_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2, IntPtr arg3);
 	public static void void_objc_msgSend_MKMapRect_UIEdgeInsets_Boolean (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, MonoTouch.UIKit.UIEdgeInsets arg2, bool arg3);
 	public static void void_objc_msgSend_PointF_float_float_float_Boolean (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, float arg2, float arg3, float arg4, bool arg5);
 	public static void void_objc_msgSend_PointF_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, IntPtr arg2);
 	public static void void_objc_msgSendSuper_CGAffineTransform_CGAffineTransform_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreGraphics.CGAffineTransform arg1, MonoTouch.CoreGraphics.CGAffineTransform arg2, MonoTouch.CoreMedia.CMTimeRange arg3);
 	public static void void_objc_msgSendSuper_CGAffineTransform_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreGraphics.CGAffineTransform arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSendSuper_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1);
 	public static void void_objc_msgSendSuper_CMTime_CMTime_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTime arg1, MonoTouch.CoreMedia.CMTime arg2, MonoTouch.CoreMedia.CMTime arg3);
 	public static void void_objc_msgSendSuper_CMTimeRange (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1);
 	public static void void_objc_msgSendSuper_CMTimeRange_CMTime (IntPtr receiver, IntPtr selector, MonoTouch.CoreMedia.CMTimeRange arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSendSuper_Double_Double_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, double arg1, double arg2, int arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSendSuper_Double_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, double arg1, IntPtr arg2, IntPtr arg3);
 	public static void void_objc_msgSendSuper_float_CMTime (IntPtr receiver, IntPtr selector, float arg1, MonoTouch.CoreMedia.CMTime arg2);
 	public static void void_objc_msgSendSuper_float_float_CMTimeRange (IntPtr receiver, IntPtr selector, float arg1, float arg2, MonoTouch.CoreMedia.CMTimeRange arg3);
 	public static void void_objc_msgSendSuper_Int64 (IntPtr receiver, IntPtr selector, long arg1);
 	public static void void_objc_msgSendSuper_IntPtr_Double_int_IntPtr_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, double arg2, int arg3, IntPtr arg4, IntPtr arg5);
 	public static void void_objc_msgSendSuper_IntPtr_float (IntPtr receiver, IntPtr selector, IntPtr arg1, float arg2);
 	public static void void_objc_msgSendSuper_IntPtr_IntPtr_Double_int_IntPtr (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, double arg3, int arg4, IntPtr arg5);
 	public static void void_objc_msgSendSuper_IntPtr_IntPtr_int_int (IntPtr receiver, IntPtr selector, IntPtr arg1, IntPtr arg2, int arg3, int arg4);
 	public static void void_objc_msgSendSuper_MKMapRect (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1);
 	public static void void_objc_msgSendSuper_MKMapRect_Boolean (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, bool arg2);
 	public static void void_objc_msgSendSuper_MKMapRect_float (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2);
 	public static void void_objc_msgSendSuper_MKMapRect_float_IntPtr (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, float arg2, IntPtr arg3);
 	public static void void_objc_msgSendSuper_MKMapRect_UIEdgeInsets_Boolean (IntPtr receiver, IntPtr selector, MonoTouch.MapKit.MKMapRect arg1, MonoTouch.UIKit.UIEdgeInsets arg2, bool arg3);
 	public static void void_objc_msgSendSuper_PointF_float_float_float_Boolean (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, float arg2, float arg3, float arg4, bool arg5);
 	public static void void_objc_msgSendSuper_PointF_IntPtr (IntPtr receiver, IntPtr selector, System.Drawing.PointF arg1, IntPtr arg2);

New Type: MonoTouch.ObjCRuntime.SinceAttribute

public class SinceAttribute : Attribute {
	
	public SinceAttribute (byte major, byte minor);
	
	public byte Major;
	public byte Minor;
}

Namespace: MonoTouch.OpenGLES

Namespace: MonoTouch.QuickLook

New Type: MonoTouch.QuickLook.QLOpenUrl

[Serializable]
public delegate bool QLOpenUrl (QLPreviewController controller, MonoTouch.Foundation.NSUrl url, QLPreviewItem item);

New Type: MonoTouch.QuickLook.QLPreviewController

public class QLPreviewController : MonoTouch.UIKit.UIViewController {
	
	public QLPreviewController ();
	public QLPreviewController (MonoTouch.Foundation.NSCoder coder);
	public QLPreviewController (MonoTouch.Foundation.NSObjectFlag t);
	public QLPreviewController (IntPtr handle);
	
	public static bool CanPreviewItem (QLPreviewItem item);
	public virtual void RefreshCurrentPreviewItem ();
	public virtual void ReloadData ();
	
	public override IntPtr ClassHandle {
		get;
	}
	public virtual QLPreviewItem CurrentPreviewItem {
		get;
	}
	public virtual int CurrentPreviewItemIndex {
		get;
		set;
	}
	public QLPreviewControllerDataSource DataSource {
		get;
		set;
	}
	public QLPreviewControllerDelegate Delegate {
		get;
		set;
	}
	public QLOpenUrl ShouldOpenUrl {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDataSource {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler DidDismiss;
	public event EventHandler WillDismiss;
}

New Type: MonoTouch.QuickLook.QLPreviewControllerDataSource

public abstract class QLPreviewControllerDataSource : MonoTouch.Foundation.NSObject {
	
	public QLPreviewControllerDataSource ();
	public QLPreviewControllerDataSource (MonoTouch.Foundation.NSCoder coder);
	public QLPreviewControllerDataSource (MonoTouch.Foundation.NSObjectFlag t);
	public QLPreviewControllerDataSource (IntPtr handle);
	
	public abstract QLPreviewItem GetPreviewItem (QLPreviewController controller, int index);
	public abstract int PreviewItemCount (QLPreviewController controller);
}

New Type: MonoTouch.QuickLook.QLPreviewControllerDelegate

public class QLPreviewControllerDelegate : MonoTouch.Foundation.NSObject {
	
	public QLPreviewControllerDelegate ();
	public QLPreviewControllerDelegate (MonoTouch.Foundation.NSCoder coder);
	public QLPreviewControllerDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public QLPreviewControllerDelegate (IntPtr handle);
	
	public virtual void DidDismiss (QLPreviewController controller);
	public virtual bool ShouldOpenUrl (QLPreviewController controller, MonoTouch.Foundation.NSUrl url, QLPreviewItem item);
	public virtual void WillDismiss (QLPreviewController controller);
}

New Type: MonoTouch.QuickLook.QLPreviewItem

public abstract class QLPreviewItem : MonoTouch.Foundation.NSObject {
	
	public QLPreviewItem ();
	public QLPreviewItem (MonoTouch.Foundation.NSCoder coder);
	public QLPreviewItem (MonoTouch.Foundation.NSObjectFlag t);
	public QLPreviewItem (IntPtr handle);
	
	public abstract string ItemTitle {
		get;
	}
	public abstract MonoTouch.Foundation.NSUrl ItemUrl {
		get;
	}
}

Namespace: MonoTouch.StoreKit

Namespace: MonoTouch.SystemConfiguration

Namespace: MonoTouch.UIKit

Type Changed: MonoTouch.UIKit.UIActionSheet

Removed:

 	public UIActionSheet (string title, UIActionSheetDelegate del, string cancelTitle, string destroy, params string [] other);
 	public UIActionSheet (string title, UIActionSheetDelegate del);
 	public UIActionSheet (string title);

Added:

 	public UIActionSheet (string title, UIActionSheetDelegate del, string cancelTitle, string destroy, params string [] other);
 	public UIActionSheet (string title, UIActionSheetDelegate del);
 	public UIActionSheet (string title);
 	public virtual void ShowFrom (System.Drawing.RectangleF rect, UIView inView, bool animated);
 	public virtual void ShowFrom (UIBarButtonItem item, bool animated);

Type Changed: MonoTouch.UIKit.UIAlertView

Removed:

 	public UIAlertView (string title, string message, UIAlertViewDelegate del, string cancelButtonTitle, params string [] otherButtons);
 	public virtual void ShowFrom (System.Drawing.RectangleF rect, UIView inView, bool animated);
 	public virtual void ShowFrom (UIBarButtonItem item);
 	public virtual void ShowFrom (UIBarButtonItem item, bool animated);

Added:

 	public UIAlertView (string title, string message, UIAlertViewDelegate del, string cancelButtonTitle, params string [] otherButtons);

Type Changed: MonoTouch.UIKit.UIApplication

Removed:

 	public virtual bool SetStatusBarHidden (bool state, UIStatusBarAnimation animation);

Added:

 	public virtual int BeginBackgroundTask (MonoTouch.Foundation.NSAction backgroundTimeExpired);
 	public virtual void BeginReceivingRemoteControlEvents ();
 	public virtual void CancelAllLocalNotification (UILocalNotification notification);
 	public virtual void CancelLocalNotification (UILocalNotification notification);
 	public virtual void ClearKeepAliveTimeout ();
 	public virtual void EndBackgroundTask (int taskId);
 	public virtual void EndReceivingRemoteControlEvents ();
 	public virtual void PresentLocationNotificationNow (UILocalNotification notification);
 	public virtual void ScheduleLocalNotification (UILocalNotification notification);
 	public virtual bool SetKeepAliveTimout (double timeout, MonoTouch.Foundation.NSAction handler);
 	public virtual void SetStatusBarHidden (bool state, UIStatusBarAnimation animation);
 	public static string DidBecomeActiveNotification {
 		get;
 	}
 	public static string DidChangeStatusBarFrameNotification {
 		get;
 	}
 	public static string DidChangeStatusBarOrientationNotification {
 		get;
 	}
 	public static string DidEnterBackgroundNotification {
 		get;
 	}
 	public static string DidFinishLaunchingNotification {
 		get;
 	}
 	public static string DidReceiveMemoryWarningNotification {
 		get;
 	}
 	public static int InvalidBackgroundTaskIdentifier {
 		get;
 	}
 	public static string LaunchOptionsAnnotationKey {
 		get;
 	}
 	public static string LaunchOptionsLocalNotificationKey {
 		get;
 	}
 	public static string LaunchOptionsLocationKey {
 		get;
 	}
 	public static string LaunchOptionsRemoteNotificationKey {
 		get;
 	}
 	public static string LaunchOptionsSourceApplicationKey {
 		get;
 	}
 	public static string LaunchOptionsUrlKey {
 		get;
 	}
 	public static double MinimumKeepAliveTimeout {
 		get;
 	}
 	public static string ProtectedDataDidBecomeAvailable {
 		get;
 	}
 	public static string ProtectedDataWillBecomeUnavailable {
 		get;
 	}
 	public static string SignificantTimeChangeNotification {
 		get;
 	}
 	public static string StatusBarFrameUserInfoKey {
 		get;
 	}
 	public static string StatusBarOrientationUserInfoKey {
 		get;
 	}
 	public static string WillChangeStatusBarFrameNotification {
 		get;
 	}
 	public static string WillChangeStatusBarOrientationNotification {
 		get;
 	}
 	public static string WillEnterForegroundNotification {
 		get;
 	}
 	public static string WillResignActiveNotification {
 		get;
 	}
 	public static string WillTerminateNotification {
 		get;
 	}
 	public virtual UIApplicationState ApplicationState {
 		get;
 	}
 	public virtual double BackgroundTimeRemaining {
 		get;
 	}
 	public virtual bool ProtectedDataAvailable {
 		get;
 		set;
 	}
 	public virtual UILocalNotification[] ScheduledLocalNotifications {
 		get;
 	}

Type Changed: MonoTouch.UIKit.UIApplicationDelegate

Added:

 	public virtual void DidEnterBackground (UIApplication application);
 	public virtual void ProtectedDataDidBecomeUnavailable (UIApplication application);
 	public virtual void ProtectedDataWillBecomeUnavailable (UIApplication application);
 	public virtual void ReceivedLocalNotification (UIApplication application, UILocalNotification notification);
 	public virtual void WillEnterForeground (UIApplication application);

Type Changed: MonoTouch.UIKit.UIApplicationState

Removed:

 Could not find MonoTouch.UIKit.UIApplicationState

Added:

 [Serializable]
 public enum UIApplicationState {
 	Active,
 	Inactive,
 	Background
 }

Type Changed: MonoTouch.UIKit.UIBarButtonItem

Removed:

 	public UIBarButtonItem (UIImage image, UIBarButtonItemStyle style, EventHandler handler);
 	public UIBarButtonItem (string title, UIBarButtonItemStyle style, EventHandler handler);
 	public UIBarButtonItem (UIBarButtonSystemItem systemItem, EventHandler handler);
 	public UIBarButtonItem (UIBarButtonSystemItem systemItem);

Added:

 	public UIBarButtonItem (UIImage image, UIBarButtonItemStyle style, EventHandler handler);
 	public UIBarButtonItem (string title, UIBarButtonItemStyle style, EventHandler handler);
 	public UIBarButtonItem (UIBarButtonSystemItem systemItem, EventHandler handler);
 	public UIBarButtonItem (UIBarButtonSystemItem systemItem);

Type Changed: MonoTouch.UIKit.UIBarButtonSystemItem

Removed:

 	Redo

Added:

 	Redo,
 	PageCurl

Type Changed: MonoTouch.UIKit.UIBezierPath

Added:

 	public virtual void AddArc (System.Drawing.PointF center, float radius, float startAngle, float endAngle, bool clockWise);

Type Changed: MonoTouch.UIKit.UIColor

Added:

 	public void GetHSBA (out float hue, out float saturation, out float brightness, out float alpha);
 	public void GetRGBA (out float red, out float green, out float blue, out float alpha);

Type Changed: MonoTouch.UIKit.UIDataDetectorType

Added:

 	Address,
 	CalendarEvent,

Type Changed: MonoTouch.UIKit.UIDevice

Removed:

 	public virtual UIUserInterfaceIdiom _UserInterfaceIdiom {
 		get;
 	}

Added:

 	public bool IsMultitaskingSupported {
 		get;
 	}

Type Changed: MonoTouch.UIKit.UIEventSubtype

Removed:

 	MotionShake

Added:

 	MotionShake,
 	RemoteControlPlay,
 	RemoteControlPause,
 	RemoteControlStop,
 	RemoteControlTogglePlayPause,
 	RemoteControlNextTrack,
 	RemoteControlPreviousTrack,
 	RemoteControlBeginSeekingBackward,
 	RemoteControlEndSeekingBackward,
 	RemoteControlBeginSeekingForward,
 	RemoteControlEndSeekingForward

Type Changed: MonoTouch.UIKit.UIEventType

Removed:

 	Motion

Added:

 	Motion,
 	RemoteControl

Type Changed: MonoTouch.UIKit.UIFont

Added:

 	public override string ToString ();
 	public virtual float LineHeight {
 		get;
 	}

Type Changed: MonoTouch.UIKit.UIGraphics

Added:

 	public static void BeginImageContextWithOptions (System.Drawing.SizeF size, bool opaque, float scale);

Type Changed: MonoTouch.UIKit.UIImage

Added:

 	public UIImage (string filename);
 	public UIImage (MonoTouch.Foundation.NSData data);
 	public static UIImage FromBundle (string name);
 	public UIImage Scale (System.Drawing.SizeF newSize);
 	public virtual float CurrentScale {
 		get;
 	}

Type Changed: MonoTouch.UIKit.UIImagePickerController

Added:

 	public virtual bool StartVideoCapture ();
 	public virtual bool StopVideoCapture ();
 	public virtual UIImagePickerControllerCameraCaptureMode CameraCaptureMode {
 		get;
 		set;
 	}

Type Changed: MonoTouch.UIKit.UIImagePickerControllerCameraCaptureMode

Removed:

 Could not find MonoTouch.UIKit.UIImagePickerControllerCameraCaptureMode

Added:

 [Serializable]
 public enum UIImagePickerControllerCameraCaptureMode {
 	Photo,
 	Video
 }

Type Changed: MonoTouch.UIKit.UIImagePickerControllerQualityType

Removed:

 	Low

Added:

 	Low,
 	At640x480

New Type: MonoTouch.UIKit.UILocalNotification

public class UILocalNotification : MonoTouch.Foundation.NSObject {
	
	public UILocalNotification ();
	public UILocalNotification (MonoTouch.Foundation.NSCoder coder);
	public UILocalNotification (MonoTouch.Foundation.NSObjectFlag t);
	public UILocalNotification (IntPtr handle);
	
	public virtual string AlertAction {
		get;
		set;
	}
	public virtual string AlertBody {
		get;
		set;
	}
	public virtual string AlertLaunchImage {
		get;
		set;
	}
	public virtual int ApplicationIconBadgeNumber {
		get;
		set;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual MonoTouch.Foundation.NSDate FireDate {
		get;
		set;
	}
	public virtual bool HasAction {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSCalendar RepeatCalendar {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSCalendarUnit RepeatInterval {
		get;
		set;
	}
	public virtual string SoundName {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSTimeZone TimeZone {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSDictionary UserInfo {
		get;
		set;
	}
}

New Type: MonoTouch.UIKit.UINib

public class UINib : MonoTouch.Foundation.NSObject {
	
	public UINib ();
	public UINib (MonoTouch.Foundation.NSCoder coder);
	public UINib (MonoTouch.Foundation.NSObjectFlag t);
	public UINib (IntPtr handle);
	
	public static UINib FromData (MonoTouch.Foundation.NSData data, MonoTouch.Foundation.NSBundle bundleOrNil);
	public static UINib FromName (string name, MonoTouch.Foundation.NSBundle bundleOrNil);
	public virtual MonoTouch.Foundation.NSObject[] InstantiateWithOwneroptions (MonoTouch.Foundation.NSObject ownerOrNil, MonoTouch.Foundation.NSDictionary optionsOrNil);
	
	public override IntPtr ClassHandle {
		get;
	}
}

Type Changed: MonoTouch.UIKit.UIPanGestureRecognizer

Removed:

 	public virtual uint MaximumNumberOfTouchesRequired {
 	public virtual uint MinimumNumberOfTouchesRequired {
 		get;
 		set;
 	}
 	public virtual System.Drawing.PointF Translation {
 		get;
 		set;
 	}
 	public virtual System.Drawing.PointF Velocity {

Added:

 	public virtual void SetTranslation (System.Drawing.PointF translation, UIView view);
 	public virtual System.Drawing.PointF TranslationInView (UIView view);
 	public virtual System.Drawing.PointF VelocityInView (UIView view);
 	
 	public virtual uint MaximumNumberOfTouches {
 	public virtual uint MinimumNumberOfTouches {

Type Changed: MonoTouch.UIKit.UIResponder

Added:

 	public virtual void RemoteControlReceived (UIEvent theEvent);

Type Changed: MonoTouch.UIKit.UIScreen

Added:

 	public virtual MonoTouch.CoreAnimation.CADisplayLink DisplayLink (MonoTouch.Foundation.NSObject target, MonoTouch.ObjCRuntime.Selector sel);
 	
 	public virtual float Scale {
 		get;
 	}

Type Changed: MonoTouch.UIKit.UISegmentedControl

Removed:

 	public UISegmentedControl (object [] args);

Added:

 	public UISegmentedControl (object [] args);

Type Changed: MonoTouch.UIKit.UISegmentedControlStyle

Removed:

 	Bar

Added:

 	Bar,
 	Bezeled

Type Changed: MonoTouch.UIKit.UITableViewCell

Removed:

 	public UITableViewCell (UITableViewCellStyle style, string reuseIdentifier);

Added:

 	public UITableViewCell (UITableViewCellStyle style, string reuseIdentifier);

Type Changed: MonoTouch.UIKit.UIView

Added:

 	public static void Animate (double duration, MonoTouch.Foundation.NSAction animation);
 	public static void Animate (double duration, MonoTouch.Foundation.NSAction animation, MonoTouch.Foundation.NSAction completion);
 	public static void Animate (double duration, double delay, UIViewAnimationOptions options, MonoTouch.Foundation.NSAction animation, MonoTouch.Foundation.NSAction completion);
 	public static void Transition (UIView withView, double duration, UIViewAnimationOptions options, MonoTouch.Foundation.NSAction animation, MonoTouch.Foundation.NSAction completion);
 	public static void Transition (UIView fromView, UIView toView, double duration, UIViewAnimationOptions options, MonoTouch.Foundation.NSAction completion);
 	public virtual float ContentScaleFactor {
 		get;
 		set;
 	}

Type Changed: MonoTouch.UIKit.UIViewAnimationOptions

Removed:

 Could not find MonoTouch.UIKit.UIViewAnimationOptions

Added:

 [Serializable]
 [Flags]
 public enum UIViewAnimationOptions {
 	LayoutSubviews,
 	AllowUserInteraction,
 	BeginFromCurrentState,
 	Repeat,
 	Autoreverse,
 	OverrideInheritedDuration,
 	OverrideInheritedCurve,
 	AllowAnimatedContent,
 	ShowHideTransitionViews,
 	CurveEaseInOut,
 	CurveEaseIn,
 	CurveEaseOut,
 	CurveLinear,
 	TransitionNone,
 	TransitionFlipFromLeft,
 	TransitionFlipFromRight,
 	TransitionCurlUp,
 	TransitionCurlDown
 }

Type Changed: MonoTouch.UIKit.UIWebView

Added:

 	public virtual bool AllowsInlineMediaPlayback {
 		get;
 		set;
 	}
 	public virtual bool MediaPlaybackRequiresUserAction {
 		get;
 		set;
 	}

Type Changed: MonoTouch.UIKit.UIWindow

Added:

 	public virtual UIViewController RootViewController {
 		get;
 		set;
 	}

Namespace: MonoTouch.iAd

New Type: MonoTouch.iAd.AdAction

[Serializable]
public delegate bool AdAction (ADBannerView banner, bool willLeaveApplication);

New Type: MonoTouch.iAd.ADBannerView

public class ADBannerView : MonoTouch.UIKit.UIView {
	
	public ADBannerView ();
	public ADBannerView (MonoTouch.Foundation.NSCoder coder);
	public ADBannerView (MonoTouch.Foundation.NSObjectFlag t);
	public ADBannerView (IntPtr handle);
	
	public static System.Drawing.SizeF SizeFromContentSizeIdentifier (string sizeIdentifier);
	public virtual void CancelBannerViewAction ();
	
	public static string SizeIdentifier320x50 {
		get;
	}
	public static string SizeIdentifier480x32 {
		get;
	}
	public AdAction ActionShouldBegin {
		get;
		set;
	}
	public virtual string AdvertisingSection {
		get;
		set;
	}
	public virtual bool BannerLoaded {
		get;
	}
	public virtual bool BannerViewActionInProgress {
		get;
	}
	public override IntPtr ClassHandle {
		get;
	}
	public virtual string CurrentContentSizeIdentifier {
		get;
	}
	public ADBannerViewDelegate Delegate {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSSet RequiredContentSizeIdentifiers {
		get;
		set;
	}
	public virtual MonoTouch.Foundation.NSObject WeakDelegate {
		get;
		set;
	}
	
	public event EventHandler ActionFinished;
	public event EventHandler AdLoaded;
	public event EventHandler FailedToReceiveAd;
}

New Type: MonoTouch.iAd.ADBannerViewDelegate

public class ADBannerViewDelegate : MonoTouch.Foundation.NSObject {
	
	public ADBannerViewDelegate ();
	public ADBannerViewDelegate (MonoTouch.Foundation.NSCoder coder);
	public ADBannerViewDelegate (MonoTouch.Foundation.NSObjectFlag t);
	public ADBannerViewDelegate (IntPtr handle);
	
	public virtual void ActionFinished (ADBannerView banner);
	public virtual bool ActionShouldBegin (ADBannerView banner, bool willLeaveApplication);
	public virtual void AdLoaded (ADBannerView banner);
	public virtual void FailedToReceiveAd (ADBannerView banner, MonoTouch.Foundation.NSError error);
}

New Type: MonoTouch.iAd.AdErrorEventArgs

public class AdErrorEventArgs : EventArgs {
	
	public AdErrorEventArgs (MonoTouch.Foundation.NSError error);
	
	public MonoTouch.Foundation.NSError Error {
		get;
		set;
	}
}

New Type: MonoTouch.iAd.ADManager

public class ADManager : MonoTouch.Foundation.NSObject {
	
	public ADManager ();
	public ADManager (MonoTouch.Foundation.NSCoder coder);
	public ADManager (MonoTouch.Foundation.NSObjectFlag t);
	public ADManager (IntPtr handle);
	
	public override IntPtr ClassHandle {
		get;
	}
}

Namespace: System.Drawing

Xamarin Workbook

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