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

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

}

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

}

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

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

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

}

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

}

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

}

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

}

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

}

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

Added:

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

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

Added:

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

Added:

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

Removed:

 	public virtual void CategoryChanged (string category);

Added:

 	public virtual void EndInterruption (AVAudioSessionInterruptionFlags flags);

Removed:

 Could not find MonoTouch.AVFoundation.AVAudioSessionFlags

Added:

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

Removed:

 Could not find MonoTouch.AVFoundation.AVAudioSessionInterruptionFlags

Added:

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

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

}

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

}

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

}

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

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

}

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

}

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

}

[Serializable]
public enum AVCaptureDevicePosition {
	Back,
	Front
}

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

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

}

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

}

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

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

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

}

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

}

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

}

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

}

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

}

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

}

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

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

}

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

}

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

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

}

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

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

}

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

}

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

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

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

}

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

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

[Serializable]
public enum AVPlayerActionAtItemEnd {
	Pause,
	None
}

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

}

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

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

}

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

}

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

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

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

}

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

}

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

}

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

}

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

}

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

Removed:

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

Removed:

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

Removed:

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

Removed:

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

Removed:

 	public int Tag;

Added:

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

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
 }

Removed:

 	AES3

Added:

 	AES3,
 	MPEG4AAC_ELD

Removed:

 	Volume

Added:

 	Volume,
 	Pan,
 	VolumeRampTime

Added:

 	public static AudioSessionInterruptionType InterruptionType {
 		get;
 	}

Removed:

 Could not find MonoTouch.AudioToolbox.AudioSessionInterruptionType

Added:

 [Serializable]
 public enum AudioSessionInterruptionType {
 	ShouldResume,
 	ShouldNotResume
 }

Removed:

 	OverrideCategoryMixWithOthers

Added:

 	OverrideCategoryMixWithOthers,
 	InterruptionType

Removed:

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

Added:

 	public virtual bool ShouldArchiveValueForKey (string key);

Removed:

 	public virtual IntPtr _Colors {
 		get;
 		set;
 	}

Added:

 	public virtual float ContentsScale {
 		get;
 		set;
 	}

Removed:

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

Added:

 	public virtual string RotationMode {

Removed:

 	public CALayer (CALayer other);

Added:

 	public CALayer (CALayer other);

Added:

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

Added:

 	public void Stop ();

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

}

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

}

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

Added:

 	public CGPath CopyPath ();

Added:

 	public CGContext Context {
 		get;
 	}

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

Removed:

 	HeadingFailure

Added:

 	HeadingFailure,
 	RegionMonitoringDenied,
 	RegionMonitoringFailure,
 	RegionMonitoringSetupDelayed

Added:

 	public bool IsValid ();

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

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

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

}

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

public IntPtr Handle {
	get;
}

}

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

}

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

}

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

}

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

}

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

}

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

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

}

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

}

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

}

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

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

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

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

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

}

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

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

public class EKEventEditEventArgs : EventArgs {
public EKEventEditEventArgs (EKEventEditViewAction action);

public EKEventEditViewAction Action {
	get;
	set;
}

}

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

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<ekeventediteventargs> Completed;

}

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

}

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

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

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

}

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

}

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

}

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

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

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

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

}

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

}

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

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

}

[Serializable]
public enum EKSpan {
	ThisEvent,
	FutureEvents
}

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;

}

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

}

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

}

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

}

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

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

}

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<nsobjecteventargs> WillEvictObject;

}

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

}

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
 }

Added:

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

Removed:

 Could not find MonoTouch.Foundation.NSDataWritingOptions

Added:

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

Removed:

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

Added:

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

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

}

Added:

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

Removed:

 internal class NSNotificationHandler : NSObject {
public NSNotificationHandler (Action<NSNotification> notify);

public void Post (NSNotification s);

}

Added:

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

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

}

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

}

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

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

}

public class NSPurgeableData : NSMutableData {
public NSPurgeableData ();
public NSPurgeableData (NSCoder coder);
public NSPurgeableData (NSObjectFlag t);
public NSPurgeableData (IntPtr handle);

public override IntPtr ClassHandle {
	get;
}

}

Removed:

 Could not find MonoTouch.Foundation.NSSetEnumerator

Added:

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

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

}

Added:

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

Removed:

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

Added:

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

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

}

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

}

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

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

}

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

}

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

public class GKDataEventArgs : EventArgs {
public GKDataEventArgs (MonoTouch.Foundation.NSData data, GKPlayer player);

public MonoTouch.Foundation.NSData Data {
	get;
	set;
}
public GKPlayer Player {
	get;
	set;
}

}

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

public class GKErrorEventArgs : EventArgs {
public GKErrorEventArgs (MonoTouch.Foundation.NSError error);

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

}

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

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

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

}

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

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

}

[Serializable]
public enum GKLeaderboardPlayerScope {
	Global,
	FriendsOnly
}

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

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

}

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

}

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

}

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<gkplayererroreventargs> ConnectionFailed;
public event EventHandler<gkdataeventargs> DataReceived;
public event EventHandler<gkerroreventargs> Failed;
public event EventHandler<gkstateeventargs> StateChanged;

}

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

}

public class GKMatchEventArgs : EventArgs {
public GKMatchEventArgs (GKMatch match);

public GKMatch Match {
	get;
	set;
}

}

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

}

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<gkerroreventargs> Failed;
public event EventHandler<gkmatcheventargs> MatchCreated;
public event EventHandler<gkplayerseventargs> PlayersFound;

}

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

}

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

}

[Serializable]
public enum GKMatchSendDataMode {
	Reliable,
	Unreliable
}

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

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

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

}

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

public class GKPlayerErrorEventArgs : EventArgs {
public GKPlayerErrorEventArgs (GKPlayer player, MonoTouch.Foundation.NSError error);

public MonoTouch.Foundation.NSError Error {
	get;
	set;
}
public GKPlayer Player {
	get;
	set;
}

}

public class GKPlayersEventArgs : EventArgs {
public GKPlayersEventArgs (GKPlayer[] players);

public GKPlayer[] Players {
	get;
	set;
}

}

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

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

}

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

public class GKStateEventArgs : EventArgs {
public GKStateEventArgs (GKPlayer player, GKPlayerConnectionState state);

public GKPlayer Player {
	get;
	set;
}
public GKPlayerConnectionState State {
	get;
	set;
}

}

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

}

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

Added:

 		set;

Removed:

 Could not find MonoTouch.MapKit.MKAnnotationViewDragState

Added:

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

Removed:

 Could not find MonoTouch.MapKit.MKAnnotationViewEventArgs

Added:

 public class MKAnnotationViewEventArgs : EventArgs {
public MKAnnotationViewEventArgs (MKAnnotationView view);

public MKAnnotationView View {
	get;
	set;
}

}

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

}

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

}

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;

}

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;

}

public struct MKMapSize {
public MKMapSize (double width, double height);

public double Width;
public double Height;

}

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;

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

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

}

Removed:

 Could not find MonoTouch.MapKit.MKMapViewOverlay

Added:

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

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

}

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

}

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

}

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

}

public class MKOverlayViewsEventArgs : EventArgs {
public MKOverlayViewsEventArgs (MKOverlayView overlayViews);

public MKOverlayView OverlayViews {
	get;
	set;
}

}

Added:

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

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

}

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

}

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

}

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

}

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

}

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

}

Removed:

 Could not find MonoTouch.MapKit.MKUserLocationEventArgs

Added:

 public class MKUserLocationEventArgs : EventArgs {
public MKUserLocationEventArgs (MKUserLocation userLocation);

public MKUserLocation UserLocation {
	get;
	set;
}

}

Added:

 		set;

Added:

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

Removed:

 Could not find MonoTouch.MediaPlayer.MPMediaItemEnumerator

Added:

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

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

Added:

 	public virtual MPTimedMetadata[] TimedMetadata {
 		get;
 	}

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

}

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

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

}

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

}

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

}

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;

}

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

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

public byte Major;
public byte Minor;

}

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

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;

}

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

}

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

}

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

}

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

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

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

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

Removed:

 Could not find MonoTouch.UIKit.UIApplicationState

Added:

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

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

Removed:

 	Redo

Added:

 	Redo,
 	PageCurl

Added:

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

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

Added:

 	Address,
 	CalendarEvent,

Removed:

 	public virtual UIUserInterfaceIdiom _UserInterfaceIdiom {
 		get;
 	}

Added:

 	public bool IsMultitaskingSupported {
 		get;
 	}

Removed:

 	MotionShake

Added:

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

Removed:

 	Motion

Added:

 	Motion,
 	RemoteControl

Added:

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

Added:

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

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

Added:

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

Removed:

 Could not find MonoTouch.UIKit.UIImagePickerControllerCameraCaptureMode

Added:

 [Serializable]
 public enum UIImagePickerControllerCameraCaptureMode {
 	Photo,
 	Video
 }

Removed:

 	Low

Added:

 	Low,
 	At640x480

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

}

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

}

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 {

Added:

 	public virtual void RemoteControlReceived (UIEvent theEvent);

Added:

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

Removed:

 	public UISegmentedControl (object [] args);

Added:

 	public UISegmentedControl (object [] args);

Removed:

 	Bar

Added:

 	Bar,
 	Bezeled

Removed:

 	public UITableViewCell (UITableViewCellStyle style, string reuseIdentifier);

Added:

 	public UITableViewCell (UITableViewCellStyle style, string reuseIdentifier);

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

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
 }

Added:

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

Added:

 	public virtual UIViewController RootViewController {
 		get;
 		set;
 	}

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

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<aderroreventargs> FailedToReceiveAd;

}

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

}

public class AdErrorEventArgs : EventArgs {
public AdErrorEventArgs (MonoTouch.Foundation.NSError error);

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

}

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

}