Namespace MonoTouch.Accounts

Class ACAccount

Selector: identifier
Property: string Identifier { get; }
Selector: accountType
Property: ACAccountType AccountType { get; set; }
Selector: accountDescription
Property: string AccountDescription { get; set; }
Selector: username
Property: string Username { get; set; }
Selector: credential
Property: ACAccountCredential Credential { get; set; }
Selector: initWithAccountType:
Method: IntPtr Constructor (ACAccountType type);
Selector: ACErrorDomain
Property: string ErrorDomain { get; }

Class ACAccountCredential

Selector: initWithOAuthToken:tokenSecret:
Method: IntPtr Constructor (string token, string secret);

Class ACAccountStore

Selector: accounts
Property: ACAccount [] Accounts { get; }
Selector: accountWithIdentifier:
Method: ACAccount FindAccount (string identifier);
Selector: accountTypeWithAccountTypeIdentifier:
Method: ACAccountType FindAccountType (string typeIdentifier);
Selector: accountsWithAccountType:
Method: ACAccount [] FindAccounts (ACAccountType accountType);
Selector: saveAccount:withCompletionHandler:
Method: void SaveAccount (ACAccount account, ACAccountStoreSaveCompletionHandler completionHandler);
Selector: requestAccessToAccountsWithType:withCompletionHandler:
Method: void RequestAccess (ACAccountType accountType, ACRequestCompletionHandler completionHandler);

Class ACAccountType

Selector: accountTypeDescription
Property: string Description { get; }
Selector: identifier
Property: string Identifier { get; }
Selector: accessGranted
Property: bool AccessGranted { get; }

Namespace MonoTouch.GLKit

Class GLKBaseEffect

Selector: colorMaterialEnabled
Property: bool ColorMaterialEnabled { get; set; }
Selector: useConstantColor
Property: bool UseConstantColor { get; set; }
Selector: transform
Property: GLKEffectPropertyTransform Transform { get; }
Selector: light0
Property: GLKEffectPropertyLight Light0 { get; }
Selector: light1
Property: GLKEffectPropertyLight Light1 { get; }
Selector: light2
Property: GLKEffectPropertyLight Light2 { get; }
Selector: lightingType
Property: GLKLightingType LightingType { get; set; }
Selector: lightModelAmbientColor
Property: Vector4 LightModelAmbientColor { get; set; }
Selector: material
Property: GLKEffectPropertyMaterial Material { get; }
Selector: texture2d0
Property: GLKEffectPropertyTexture Texture2d0 { get; }
Selector: texture2d1
Property: GLKEffectPropertyTexture Texture2d1 { get; }
Selector: textureOrder
Property: GLKEffectPropertyTexture [] TextureOrder { get; set; }
Selector: constantColor
Property: Vector4 ConstantColor { get; set; }
Selector: fog
Property: GLKEffectPropertyFog Fog { get; }
Selector: label
Property: string Label { get; set; }
Selector: prepareToDraw
Method: void PrepareToDraw ();
Selector: lightModelTwoSided
Property: bool LightModelTwoSided { get; set; }

Class GLKEffectProperty

Class GLKEffectPropertyFog

Selector: mode
Property: GLKFogMode Mode { get; set; }
Selector: color
Property: Vector4 Color { get; set; }
Selector: density
Property: float Density { get; set; }
Selector: start
Property: float Start { get; set; }
Selector: end
Property: float End { get; set; }
Selector: enabled
Property: bool Enabled { get; set; }

Class GLKEffectPropertyLight

Selector: position
Property: Vector4 Position { get; set; }
Selector: ambientColor
Property: Vector4 AmbientColor { get; set; }
Selector: diffuseColor
Property: Vector4 DiffuseColor { get; set; }
Selector: specularColor
Property: Vector4 SpecularColor { get; set; }
Selector: spotDirection
Property: Vector3 SpotDirection { get; set; }
Selector: spotExponent
Property: float SpotExponent { get; set; }
Selector: spotCutoff
Property: float SpotCutoff { get; set; }
Selector: constantAttenuation
Property: float ConstantAttenuation { get; set; }
Selector: linearAttenuation
Property: float LinearAttenuation { get; set; }
Selector: quadraticAttenuation
Property: float QuadraticAttenuation { get; set; }
Selector: transform
Property: GLKEffectPropertyTransform Transform { get; set; }
Selector: enabled
Property: bool Enabled { get; set; }

Class GLKEffectPropertyMaterial

Selector: diffuseColor
Property: Vector4 DiffuseColor { get; set; }
Selector: specularColor
Property: Vector4 SpecularColor { get; set; }
Selector: emissiveColor
Property: Vector4 EmissiveColor { get; set; }
Selector: shininess
Property: float Shininess { get; set; }
Selector: ambientColor
Property: Vector4 AmbientColor { get; set; }

Class GLKEffectPropertyTexture

Selector: target
Property: GLKTextureTarget Target { get; set; }
Selector: envMode
Property: GLKTextureEnvMode EnvMode { get; set; }
Selector: enabled
Property: bool Enabled { get; set; }
Selector: name
Property: uint GLName { get; set; }

Class GLKEffectPropertyTransform

Selector: normalMatrix
Property: Matrix3 NormalMatrix { get; }
Selector: modelviewMatrix
Property: Matrix4 ModelViewMatrix { get; set; }
Selector: projectionMatrix
Property: Matrix4 ProjectionMatrix { get; set; }
Selector: textureMatrix
Property: Matrix4 TextureMatrix { get; set; }

Class GLKNamedEffect

Selector: prepareToDraw
Method: void PrepareToDraw ();

Class GLKReflectionMapEffect

Selector: textureCubeMap
Property: GLKEffectPropertyTexture TextureCubeMap { get; }
Selector: matrix
Property: Matrix3 Matrix { get; set; }
Selector: prepareToDraw
Method: void PrepareToDraw ();

Class GLKSkyboxEffect

Selector: center
Property: Vector3 Center { get; set; }
Selector: xSize
Property: float XSize { get; set; }
Selector: ySize
Property: float YSize { get; set; }
Selector: xSize
Property: float ZSize { get; set; }
Selector: textureCubeMap
Property: GLKEffectPropertyTexture TextureCubeMap { get; }
Selector: transform
Property: GLKEffectPropertyTransform Transform { get; }
Selector: label
Property: string Label { get; set; }
Selector: prepareToDraw
Method: void PrepareToDraw ();
Selector: draw
Method: void Draw ();

Class GLKTextureInfo

Selector: width
Property: int Width { get; }
Selector: height
Property: int Height { get; }
Selector: alphaState
Property: GLKTextureInfoAlphaState AlphaState { get; }
Selector: textureOrigin
Property: GLKTextureInfoOrigin TextureOrigin { get; }
Selector: containsMipmaps
Property: bool ContainsMipmaps { get; }
Selector: GLuinttextureName
Property: uint TextureName { get; }
Selector: name
Property: uint Name { get; }
Selector: target
Property: GLKTextureTarget Target { get; }

Class GLKTextureLoader

Selector: textureWithContentsOfFile:options:error:
Method: GLKTextureInfo FromFile (string path, NSDictionary textureOperations, out NSError error);
Selector: textureWithContentsOfURL:options:error:
Method: GLKTextureInfo FromUrl (NSUrl url, NSDictionary textureOperations, out NSError error);
Selector: textureWithContentsOfData:options:error:
Method: GLKTextureInfo FromData (NSData data, NSDictionary textureOperations, out NSError error);
Selector: textureWithCGImage:options:error:
Method: GLKTextureInfo FromImage (CGImage cgImage, NSDictionary textureOperations, out NSError error);
Selector: cubeMapWithContentsOfFiles:options:error:
Method: GLKTextureInfo CubeMapFromFiles (NSArray paths, NSDictionary textureOperations, out NSError error);
Selector: cubeMapWithContentsOfFile:options:error:
Method: GLKTextureInfo CubeMapFromFile (string path, NSDictionary textureOperations, out NSError error);
Selector: cubeMapWithContentsOfURL:options:error:
Method: GLKTextureInfo CubeMapFromUrl (NSUrl url, NSDictionary textureOperations, out NSError error);
Selector: initWithSharegroup:
Method: IntPtr Constructors (EAGLSharegroup sharegroup);
Selector: textureWithContentsOfFile:options:queue:completionHandler:
Method: void BeginTextureLoad (string file, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: textureWithContentsOfURL:options:queue:completionHandler:
Method: void BeginTextureLoad (NSUrl filePath, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: textureWithContentsOfData:options:queue:completionHandler:
Method: void BeginTextureLoad (NSData data, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: textureWithCGImage:options:queue:completionHandler:
Method: void BeginTextureLoad (CGImage image, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: cubeMapWithContentsOfFiles:options:queue:completionHandler:
Method: void BeginLoadCubeMap (NSArray filePaths, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: cubeMapWithContentsOfFile:options:queue:completionHandler:
Method: void BeginLoadCubeMap (string fileName, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);
Selector: cubeMapWithContentsOfURL:options:queue:completionHandler:
Method: void BeginLoadCubeMap (NSUrl filePath, NSDictionary textureOperations, DispatchQueue queue, GLKTextureLoaderCallback onComplete);

Class GLKView

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: context
Property: EAGLContext Context { get; set; }
Selector: drawableWidth
Property: int DrawableWidth { get; }
Selector: drawableHeight
Property: int DrawableHeight { get; }
Selector: drawableColorFormat
Property: GLKViewDrawableColorFormat DrawableColorFormat { get; set; }
Selector: drawableDepthFormat
Property: GLKViewDrawableDepthFormat DrawableDepthFormat { get; set; }
Selector: drawableStencilFormat
Property: GLKViewDrawableStencilFormat DrawableStencilFormat { get; set; }
Selector: drawableMultisample
Property: GLKViewDrawableMultisample DrawableMultisample { get; set; }
Selector: enableSetNeedsDisplay
Property: bool EnableSetNeedsDisplay { get; set; }
Selector: initWithFrame:context:
Method: NSObject InitWithFramecontext (RectangleF frame, EAGLContext context);
Selector: bindDrawable
Method: void BindDrawable ();
Selector: snapshot
Method: UIImage Snapshot ();
Selector: display
Method: void Display ();
Selector: deleteDrawable
Method: void DeleteDrawable ();

Class GLKViewDelegate

Selector: glkView:drawInRect:
Method: void DrawInRect (GLKView view, RectangleF rect);

Class GLKViewController

Selector: preferredFramesPerSecond
Property: int PreferredFramesPerSecond { get; set; }
Selector: framesPerSecond
Property: int FramesPerSecond { get; }
Selector: paused
Property: bool Paused { [Bind ("isPaused")] get; set; }
Selector: framesDisplayed
Property: int FramesDisplayed { get; }
Selector: timeSinceFirstResume
Property: double TimeSinceFirstResume { get; }
Selector: timeSinceLastResume
Property: double TimeSinceLastResume { get; }
Selector: timeSinceLastUpdate
Property: double TimeSinceLastUpdate { get; }
Selector: timeSinceLastDraw
Property: double TimeSinceLastDraw { get; }
Selector: pauseOnWillResignActive
Property: bool PauseOnWillResignActive { get; set; }
Selector: resumeOnDidBecomeActive
Property: bool ResumeOnDidBecomeActive { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class GLKViewControllerDelegate

Selector: glkViewControllerUpdate:
Method: void Update (GLKViewController controller);
Selector: glkViewController:willPause:
Method: void WillPause (GLKViewController controller, bool pause);

Namespace MonoTouch.NewsstandKit

Class NKAssetDownload

Selector: issue
Property: NKIssue Issue { get; }
Selector: identifier
Property: string Identifier { get; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }
Selector: URLRequest
Property: NSUrlRequest UrlRequest { get; }
Selector: downloadWithDelegate:
Method: NSUrlConnection DownloadWithDelegate (NSUrlConnectionDownloadDelegate downloadDelegate);

Class NKIssue

Selector: downloadingAssets
Property: NKAssetDownload [] DownloadingAssets { get; }
Selector: contentURL
Property: NSUrl ContentUrl { get; }
Selector: status
Property: NKIssueContentStatus Status { get; }
Selector: name
Property: string Name { get; }
Selector: date
Property: NSDate Date { get; }
Selector: addAssetWithRequest:
Method: NKAssetDownload AddAsset (NSUrlRequest request);

Class NKLibrary

Selector: issues
Property: NKIssue [] Issues { get; }
Selector: downloadingAssets
Property: NKAssetDownload [] DownloadingAssets { get; }
Selector: currentlyReadingIssue
Property: NKIssue CurrentlyReadingIssue { get; set; }
Selector: sharedLibrary
Property: NKLibrary SharedLibrary { get; }
Selector: issueWithName:
Method: NKIssue GetIssue (string name);
Selector: addIssueWithName:date:
Method: NKIssue AddIssue (string name, NSDate date);
Selector: removeIssue:
Method: void RemoveIssue (NKIssue issue);

Namespace MonoTouch.Twitter

Class TWRequest

Selector: account
Property: ACAccount Account { get; set; }
Selector: requestMethod
Property: TWRequestMethod RequestMethod { get; }
Selector: URL
Property: NSUrl Url { get; }
Selector: parameters
Property: NSDictionary Parameters { get; }
Selector: initWithURL:parameters:requestMethod:
Method: IntPtr Constructor (NSUrl url, [NullAllowed] NSDictionary parameters, TWRequestMethod requestMethod);
Selector: addMultiPartData:withName:type:
Method: void AddMultiPartData (NSData data, string name, string type);
Selector: signedURLRequest
Property: NSUrlRequest SignedUrlRequest { get; }
Selector: performRequestWithHandler:
Method: void PerformRequest (TWRequestHandler handler);

Class TWTweetComposeViewController

Selector: setCompletionHandler:
Method: void SetCompletionHandler (TWTweetComposeHandler handler);
Selector: canSendTweet
Property: bool CanSendTweet { get; }
Selector: setInitialText:
Method: bool SetInitialText (string text);
Selector: addImage:
Method: bool AddImage (UIImage image);
Selector: removeAllImages
Method: bool RemoveAllImages ();
Selector: addURL:
Method: bool AddUrl (NSUrl url);
Selector: removeAllURLs
Method: bool RemoveAllUrls ();

Namespace MonoTouch.StoreKit

Class SKPayment

Selector: paymentWithProduct:
Method: SKPayment PaymentWithProduct (SKProduct product);
Selector: paymentWithProductIdentifier:
Method: SKPayment PaymentWithProduct (string identifier);
Selector: productIdentifier
Property: string ProductIdentifier { get; }
Selector: requestData
Property: NSData RequestData { get; }
Selector: quantity
Property: int Quantity { get; }

Class SKMutablePayment

Selector: productIdentifier
Property: string ProductIdentifier { get; set; }
Selector: quantity
Property: int Quantity { get; set; }
Selector: requestData
Property: NSData RequestData { get; set; }

Class SKPaymentQueue

Selector: defaultQueue
Property: SKPaymentQueue DefaultQueue { get; }
Selector: canMakePayments
Property: bool CanMakePayments { get; }
Selector: addPayment:
Method: void AddPayment (SKPayment payment);
Selector: restoreCompletedTransactions
Method: void RestoreCompletedTransactions ();
Selector: finishTransaction:
Method: void FinishTransaction (SKPaymentTransaction transaction);
Selector: addTransactionObserver:
Method: void AddTransactionObserver (SKPaymentTransactionObserver observer);
Selector: removeTransactionObserver:
Method: void RemoveTransactionObserver (SKPaymentTransactionObserver observer);
Selector: transactions
Property: SKPaymentTransaction [] Transactions { get; }

Class SKProduct

Selector: localizedDescription
Property: string LocalizedDescription { get; }
Selector: localizedTitle
Property: string LocalizedTitle { get; }
Selector: price
Property: NSDecimalNumber Price { get; }
Selector: priceLocale
Property: NSLocale PriceLocale { get; }
Selector: productIdentifier
Property: string ProductIdentifier { get; }

Class SKPaymentTransactionObserver

Selector: paymentQueue:updatedTransactions:
Method: void UpdatedTransactions (SKPaymentQueue queue, SKPaymentTransaction [] transactions);
Selector: paymentQueue:removedTransactions:
Method: void RemovedTransactions (SKPaymentQueue queue, SKPaymentTransaction [] transactions);
Selector: paymentQueue:restoreCompletedTransactionsFailedWithError:
Method: void RestoreCompletedTransactionsFailedWithError (SKPaymentQueue queue, NSError error);
Selector: paymentQueueRestoreCompletedTransactionsFinished:
Method: void PaymentQueueRestoreCompletedTransactionsFinished (SKPaymentQueue queue);

Class SKPaymentTransaction

Selector: error
Property: NSError Error { get; }
Selector: originalTransaction
Property: SKPaymentTransaction OriginalTransaction { get; }
Selector: payment
Property: SKPayment Payment { get; }
Selector: transactionDate
Property: NSDate TransactionDate { get; }
Selector: transactionIdentifier
Property: string TransactionIdentifier { get; }
Selector: transactionReceipt
Property: NSData TransactionReceipt { get; }
Selector: transactionState
Property: SKPaymentTransactionState TransactionState { get; }

Class SKRequest

Selector: delegate
Property: NSObject WeakDelegate { get; [NullAllowed] set; }
Selector: cancel
Method: void Cancel ();
Selector: start
Method: void Start ();

Class SKRequestDelegate

Selector: requestDidFinish:
Method: void RequestFinished (SKRequest request);
Selector: request:didFailWithError:"), EventArgs ("SKRequestError
Method: void RequestFailed (SKRequest request, NSError error);

Class SKProductsRequest

Selector: initWithProductIdentifiers:
Method: IntPtr Constructor (NSSet productIdentifiersStringSet);
Selector: delegate
Property: NSObject WeakDelegate { get; [NullAllowed] set; }

Class SKProductsResponse

Selector: products
Property: SKProduct [] Products { get; }
Selector: invalidProductIdentifiers
Property: string [] InvalidProducts { get; }

Class SKProductsRequestDelegate

Selector: productsRequest:didReceiveResponse:")][Abstract][EventArgs ("SKProductsRequestResponse
Method: void ReceivedResponse (SKProductsRequest request, SKProductsResponse response);

Namespace MonoTouch.MediaPlayer

Class MPMediaItem

Selector: canFilterByProperty:
Method: bool CanFilterByProperty (NSString property);
Selector: valueForProperty:
Method: NSObject ValueForProperty (NSString property);
Selector: enumerateValuesForProperties:usingBlock:
Method: void EnumerateValues (NSSet propertiesToEnumerate, MPMediaItemEnumerator enumerator);
Selector: persistentIDPropertyForGroupingType:
Method: string GetPersistentIDProperty (MPMediaGrouping groupingType);
Selector: titlePropertyForGroupingType:
Method: string GetTitleProperty (MPMediaGrouping groupingType);

Class MPMediaItemArtwork

Selector: initWithImage:
Method: IntPtr Constructor (UIImage image);
Selector: imageWithSize:
Method: UIImage ImageWithSize (SizeF size);
Selector: bounds
Property: RectangleF Bounds { get; }
Selector: imageCropRect
Property: RectangleF ImageCropRectangle { get; }

Class MPMediaItemCollection

Selector: collectionWithItems:
Method: MPMediaItemCollection FromItems (MPMediaItem [] items);
Selector: initWithItems:
Method: IntPtr Constructor (MPMediaItem [] items);
Selector: items
Property: MPMediaItem [] Items { get; }
Selector: representativeItem
Property: MPMediaItem RepresentativeItem { get; }
Selector: count
Property: int Count { get; }
Selector: mediaTypes
Property: MPMediaType MediaTypes { get; }

Class MPMediaLibrary

Selector: defaultMediaLibrary
Property: MPMediaLibrary DefaultMediaLibrary { get; }
Selector: lastModifiedDate
Property: NSDate LastModifiedDate { get; }
Selector: beginGeneratingLibraryChangeNotifications
Method: void BeginGeneratingLibraryChangeNotifications ();
Selector: endGeneratingLibraryChangeNotifications
Method: void EndGeneratingLibraryChangeNotifications ();

Class MPMediaPickerController

Selector: initWithMediaTypes:
Method: IntPtr Constructor (MPMediaType mediaTypes);
Selector: mediaTypes
Property: MPMediaType MediaTypes { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: allowsPickingMultipleItems
Property: bool AllowsPickingMultipleItems { get; set; }
Selector: prompt
Property: string Prompt { get; set; }

Class MPMediaPickerControllerDelegate

Selector: mediaPicker:didPickMediaItems:"), EventArgs ("ItemsPicked"), EventName ("ItemsPicked
Method: void MediaItemsPicked (MPMediaPickerController sender, MPMediaItemCollection mediaItemCollection);
Selector: mediaPickerDidCancel:"), EventArgs ("MPMediaPickerController"), EventName ("DidCancel
Method: void MediaPickerDidCancel (MPMediaPickerController sender);

Class MPMediaPlaylist

Selector: canFilterByProperty:
Method: bool CanFilterByProperty (string property);
Selector: valueForProperty:
Method: NSObject ValueForProperty (string property);

Class MPMediaQuery

Selector: initWithFilterPredicates:
Method: IntPtr Constructor (NSSet filterPredicates);
Selector: filterPredicates
Property: NSSet FilterPredicates { get; set; }
Selector: addFilterPredicate:
Method: void AddFilterPredicate (MPMediaPredicate predicate);
Selector: removeFilterPredicate:
Method: void RemoveFilterPredicate (MPMediaPredicate predicate);
Selector: items
Property: MPMediaItem [] Items { get; }
Selector: collections
Property: MPMediaItemCollection [] Collections { get; }
Selector: groupingType
Property: MPMediaGrouping GroupingType { get; set; }
Selector: albumsQuery
Property: MPMediaQuery albumsQuery { get; }
Selector: artistsQuery
Property: MPMediaQuery artistsQuery { get; }
Selector: songsQuery
Property: MPMediaQuery songsQuery { get; }
Selector: playlistsQuery
Property: MPMediaQuery playlistsQuery { get; }
Selector: podcastsQuery
Property: MPMediaQuery podcastsQuery { get; }
Selector: audiobooksQuery
Property: MPMediaQuery audiobooksQuery { get; }
Selector: compilationsQuery
Property: MPMediaQuery compilationsQuery { get; }
Selector: composersQuery
Property: MPMediaQuery composersQuery { get; }
Selector: genresQuery
Property: MPMediaQuery genresQuery { get; }
Selector: collectionSections
Property: MPMediaQuerySection [] CollectionSections { get; }
Selector: itemSections
Property: MPMediaQuerySection [] ItemSections { get; }

Class MPMediaPredicate

Class MPMediaPropertyPredicate

Selector: predicateWithValue:forProperty:
Method: MPMediaPropertyPredicate PredicateWithValue (NSObject value, string property);
Selector: predicateWithValue:forProperty:comparisonType:
Method: MPMediaPropertyPredicate PredicateWithValue (NSObject value, string property, MPMediaPredicateComparison comparisonType);
Selector: property
Property: string Property { get; }
Selector: value
Property: NSObject Value { get; }
Selector: comparisonType
Property: MPMediaPredicateComparison ComparisonType { get; }

Class MPMovieAccessLog

Selector: events
Property: MPMovieAccessLogEvent [] Events { get; }
Selector: extendedLogDataStringEncoding
Property: NSStringEncoding ExtendedLogDataStringEncoding { get; }
Selector: extendedLogData
Property: NSData ExtendedLogData { get; }

Class MPMovieErrorLog

Selector: events
Property: MPMovieErrorLogEvent [] Events { get; }
Selector: extendedLogDataStringEncoding
Property: NSStringEncoding ExtendedLogDataStringEncoding { get; }
Selector: extendedLogData
Property: NSData ExtendedLogData { get; }

Class MPMovieAccessLogEvent

Selector: numberOfSegmentsDownloaded
Property: int SegmentedDownloadedCount { get; }
Selector: playbackStartDate
Property: NSData PlaybackStartDate { get; }
Selector: URI
Property: string Uri { get; }
Selector: serverAddress
Property: string ServerAddress { get; }
Selector: numberOfServerAddressChanges
Property: int ServerAddressChangeCount { get; }
Selector: playbackSessionID
Property: string PlaybackSessionID { get; }
Selector: playbackStartOffset
Property: double PlaybackStartOffset { get; }
Selector: segmentsDownloadedDuration
Property: double SegmentsDownloadedDuration { get; }
Selector: durationWatched
Property: double DurationWatched { get; }
Selector: numberOfStalls
Property: int StallCount { get; }
Selector: numberOfBytesTransferred
Property: long BytesTransferred { get; }
Selector: observedBitrate
Property: double ObservedBitrate { get; }
Selector: indicatedBitrate
Property: double IndicatedBitrate { get; }
Selector: numberOfDroppedVideoFrames
Property: int DroppedVideoFrameCount { get; }

Class MPMovieErrorLogEvent

Selector: date
Property: NSDate Date { get; }
Selector: URI
Property: string Uri { get; }
Selector: serverAddress
Property: string ServerAddress { get; }
Selector: playbackSessionID
Property: string PlaybackSessionID { get; }
Selector: errorStatusCode
Property: int ErrorStatusCode { get; }
Selector: errorDomain
Property: string ErrorDomain { get; }
Selector: errorComment
Property: string ErrorComment { get; }

Class MPMoviePlayerController

Selector: initWithContentURL:
Method: IntPtr Constructor (NSUrl url);
Selector: play
Method: void Play ();
Selector: stop
Method: void Stop ();
Selector: backgroundColor
Method: // TODO: deprecate with iPad
Selector: scalingMode
Property: MPMovieScalingMode ScalingMode { get; set; }
Selector: movieControlMode
Method: // TODO: deprecate with iPad
Selector: initialPlaybackTime
Property: double InitialPlaybackTime { get; set; }
Selector: contentURL
Property: NSUrl ContentUrl { get; set; }
Selector: view
Property: UIView View { get; }
Selector: backgroundView
Property: UIView BackgroundView { get; }
Selector: playbackState
Property: MPMoviePlaybackState PlaybackState { get; }
Selector: loadState
Property: MPMovieLoadState LoadState { get; }
Selector: controlStyle
Property: MPMovieControlStyle ControlStyle { get; set; }
Selector: repeatMode
Property: MPMovieRepeatMode RepeatMode { get; set; }
Selector: shouldAutoplay
Property: bool ShouldAutoplay { get; set; }
Selector: useApplicationAudioSession
Property: bool UseApplicationAudioSession { get; set; }
Selector: fullscreen
Property: bool Fullscreen { [Bind ("isFullscreen")] get; set; }
Selector: setFullscreen:animated:
Method: void SetFullscreen (bool fullscreen, bool animated);
Selector: allowsAirPlay
Property: bool AllowsAirPlay { get; set; }
Selector: accessLog
Property: MPMovieAccessLog AccessLog { get; }
Selector: errorLog
Property: MPMovieErrorLog ErrorLog { get; }
Selector: pause
Method: void Pause ();
Selector: prepareToPlay
Method: void PrepareToPlay ();
Selector: isPreparedToPlay
Property: bool IsPreparedToPlay { get; }
Selector: currentPlaybackTime
Property: double CurrentPlaybackTime { get; set; }
Selector: currentPlaybackRate
Property: float CurrentPlaybackRate { get; set; }
Selector: beginSeekingForward
Method: void BeginSeekingForward ();
Selector: beginSeekingBackward
Method: void BeginSeekingBackward ();
Selector: endSeeking
Method: void EndSeeking ();
Selector: thumbnailImageAtTime:timeOption:
Method: UIImage ThumbnailImageAt (double time, MPMovieTimeOption timeOption);
Selector: requestThumbnailImagesAtTimes:timeOption:
Method: void RequestThumbnails (NSNumber [] doubleNumbers, MPMovieTimeOption timeOption);
Selector: cancelAllThumbnailImageRequests
Method: void CancelAllThumbnailImageRequests ();
Selector: movieMediaTypes
Property: MPMovieMediaType MovieMediaTypes { get; }
Selector: movieSourceType
Property: MPMovieSourceType SourceType { get; set; }
Selector: duration
Property: double Duration { get; }
Selector: playableDuration
Property: double PlayableDuration { get; }
Selector: naturalSize
Property: SizeF NaturalSize { get; }
Selector: endPlaybackTime
Property: double EndPlaybackTime { get; }
Selector: timedMetadata
Property: MPTimedMetadata [] TimedMetadata { get; }

Class MPTimedMetadata

Selector: key
Property: string Key { get; }
Selector: keyspace
Property: string Keyspace { get; }
Selector: value
Property: NSObject value { get; }
Selector: timestamp
Property: double Timestamp { get; }
Selector: allMetadata
Property: NSDictionary AllMetadata { get; }

Class MPMoviePlayerViewController

Selector: initWithContentURL:
Method: IntPtr Constructor (NSUrl url);
Selector: moviePlayer
Property: MPMoviePlayerController MoviePlayer { get; }
Selector: shouldAutorotateToInterfaceOrientation:
Method: bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation orientation);

Class MPMusicPlayerController

Selector: applicationMusicPlayer
Property: MPMusicPlayerController ApplicationMusicPlayer { get; }
Selector: iPodMusicPlayer
Property: MPMusicPlayerController iPodMusicPlayer { get; }
Selector: playbackState
Property: MPMusicPlaybackState PlaybackState { get; }
Selector: repeatMode
Property: MPMusicRepeatMode RepeatMode { get; set; }
Selector: shuffleMode
Property: MPMusicShuffleMode ShuffleMode { get; set; }
Selector: volume
Property: float Volume { get; set; }
Selector: nowPlayingItem
Property: MPMediaItem NowPlayingItem { get; set; }
Selector: setQueueWithQuery:
Method: void SetQueue (MPMediaQuery query);
Selector: setQueueWithItemCollection:
Method: void SetQueue (MPMediaItemCollection collection);
Selector: play
Method: void Play ();
Selector: pause
Method: void Pause ();
Selector: stop
Method: void Stop ();
Selector: currentPlaybackTime
Property: double CurrentPlaybackTime { get; set; }
Selector: beginSeekingForward
Method: void BeginSeekingForward ();
Selector: beginSeekingBackward
Method: void BeginSeekingBackward ();
Selector: endSeeking
Method: void EndSeeking ();
Selector: skipToNextItem
Method: void SkipToNextItem ();
Selector: skipToBeginning
Method: void SkipToBeginning ();
Selector: skipToPreviousItem
Method: void SkipToPreviousItem ();
Selector: beginGeneratingPlaybackNotifications
Method: void BeginGeneratingPlaybackNotifications ();
Selector: endGeneratingPlaybackNotifications
Method: void EndGeneratingPlaybackNotifications ();

Class MPVolumeView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: sizeThatFits:
Method: SizeF SizeThatFits (SizeF f);
Selector: showsRouteButton
Property: bool ShowsRouteButton { get; set; }
Selector: showsVolumeSlider
Property: bool ShowsVolumeSlider { get; set; }

Class MPMediaQuerySection

Selector: range
Property: NSRange Range { get; }
Selector: title
Property: string Title { get; }

Class MPNowPlayingInfoCenter

Selector: nowPlayingInfo
Property: NSDictionary _NowPlayingInfo { get; set; }
Selector: defaultCenter
Property: MPNowPlayingInfoCenter DefaultCenter { get; }

Namespace MonoTouch.GameKit

Class GKPeerPickerControllerDelegate

Selector: peerPickerController:didSelectConnectionType:
Method: void ConnectionTypeSelected (GKPeerPickerController picker, GKPeerPickerConnectionType type);
Selector: peerPickerController:sessionForConnectionType:
Method: GKSession GetSession (GKPeerPickerController picker, GKPeerPickerConnectionType forType);
Selector: peerPickerController:didConnectPeer:toSession:
Method: void PeerConnected (GKPeerPickerController picker, string peerId, GKSession toSession);
Selector: peerPickerControllerDidCancel:
Method: void ControllerCancelled (GKPeerPickerController picker);

Class GKPeerPickerController

Selector: connectionTypesMask
Property: GKPeerPickerConnectionType ConnectionTypesMask { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: show
Method: void Show ();
Selector: dismiss
Method: void Dismiss ();
Selector: visible
Property: bool Visible { [Bind ("isVisible")] get; set; }

Class GKVoiceChatClient

Selector: voiceChatService:sendData:toParticipantID:
Method: void SendData (GKVoiceChatService voiceChatService, NSData data, string toParticipant);
Selector: participantID
Method: string ParticipantID ();
Selector: voiceChatService:sendRealTimeData:toParticipantID:
Method: void SendRealTimeData (GKVoiceChatService voiceChatService, NSData data, string participantID);
Selector: voiceChatService:didStartWithParticipantID:
Method: void Started (GKVoiceChatService voiceChatService, string participantID);
Selector: voiceChatService:didNotStartWithParticipantID:error:
Method: void FailedToConnect (GKVoiceChatService voiceChatService, string participantID, NSError error);
Selector: voiceChatService:didStopWithParticipantID:error:
Method: void Stopped (GKVoiceChatService voiceChatService, string participantID, NSError error);
Selector: voiceChatService:didReceiveInvitationFromParticipantID:callID:
Method: void ReceivedInvitation (GKVoiceChatService voiceChatService, string participantID, int callID);

Class GKVoiceChatService

Selector: defaultVoiceChatService
Property: GKVoiceChatService Default { get; }
Selector: client
Property: GKVoiceChatClient Client { get; set; }
Selector: startVoiceChatWithParticipantID:error:
Method: bool StartVoiceChat (string participantID, IntPtr ns_error_out);
Selector: stopVoiceChatWithParticipantID:
Method: void StopVoiceChat (string participantID);
Selector: acceptCallID:error:
Method: bool AcceptCall (int callID, IntPtr ns_error_out);
Selector: denyCallID:
Method: void DenyCall (int callId);
Selector: receivedRealTimeData:fromParticipantID:
Method: void ReceivedRealTimeData (NSData audio, string participantID);
Selector: receivedData:fromParticipantID:
Method: void ReceivedData (NSData arbitraryData, string participantID);
Selector: microphoneMuted
Property: bool MicrophoneMuted { [Bind ("isMicrophoneMuted")] get; set; }
Selector: remoteParticipantVolume
Property: float RemoteParticipantVolume { get; set; }
Selector: outputMeteringEnabled
Property: bool OutputMeteringEnabled { [Bind ("isOutputMeteringEnabled")] get; set; }
Selector: inputMeteringEnabled
Property: bool InputMeteringEnabled { [Bind ("isInputMeteringEnabled")] get; set; }
Selector: outputMeterLevel
Property: float OutputMeterLevel { get; }
Selector: inputMeterLevel
Property: float InputMeterLevel { get; }
Selector: isVoIPAllowed
Property: bool IsVoIPAllowed { get; }

Class GKSessionDelegate

Selector: session:peer:didChangeState:
Method: void PeerChangedState (GKSession session, string peerID, GKPeerConnectionState state);
Selector: session:didReceiveConnectionRequestFromPeer:
Method: void PeerConnectionRequest (GKSession session, string peerID);
Selector: session:connectionWithPeerFailed:withError:
Method: void PeerConnectionFailed (GKSession session, string peerID, NSError error);
Selector: session:didFailWithError:
Method: void FailedWithError (GKSession session, NSError error);

Class GKSession

Selector: initWithSessionID:displayName:sessionMode:
Method: IntPtr Constructor (string sessionID, string displayName, GKSessionMode mode);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: sessionID
Property: string SessionID { get; }
Selector: displayName
Property: string DisplayName { get; }
Selector: sessionMode
Property: GKSessionMode SessionMode { get; }
Selector: peerID
Property: string PeerID { get; }
Selector: available
Property: bool Available { [Bind ("isAvailable")] get; set; }
Selector: disconnectTimeout
Property: double DisconnectTimeout { get; set; }
Selector: displayNameForPeer:
Method: string DisplayNameForPeer (string peerID);
Selector: sendData:toPeers:withDataMode:error:
Method: bool SendData (NSData data, string [] peers, GKSendDataMode mode, IntPtr ns_error_out);
Selector: sendDataToAllPeers:withDataMode:error:
Method: bool SendDataToAllPeers (NSData data, GKSendDataMode mode, IntPtr ns_error_out);
Selector: setDataReceiveHandler:withContext:
Method: void _SetDataReceiveHandler (NSObject obj, IntPtr context);
Selector: connectToPeer:withTimeout:
Method: void Connect (string peerID, double timeout);
Selector: cancelConnectToPeer:
Method: void CancelConnect (string peerID);
Selector: acceptConnectionFromPeer:error:
Method: bool AcceptConnection (string peerID, IntPtr error_out);
Selector: denyConnectionFromPeer:
Method: void DenyConnection (string peerID);
Selector: disconnectPeerFromAllPeers:
Method: void DisconnectPeerFromAllPeers (string peerID);
Selector: disconnectFromAllPeers
Method: void DisconnectFromAllPeers ();
Selector: peersWithConnectionState:
Method: string [] PeersWithConnectionState (GKPeerConnectionState state);

Class GKLeaderboard

Selector: timeScope
Property: GKLeaderboardTimeScope TimeScope { get; set; }
Selector: playerScope
Property: GKLeaderboardPlayerScope PlayerScope { get; set; }
Selector: maxRange
Property: int MaxRange { get; }
Selector: category
Property: string Category { get; set; }
Selector: title
Property: string Title { get; }
Selector: range
Property: NSRange Range { get; set; }
Selector: scores
Property: GKScore [] Scores { get; }
Selector: localPlayerScore
Property: GKScore LocalPlayerScore { get; }
Selector: initWithPlayerIDs:
Method: IntPtr Constructor (string [] players);
Selector: loadScoresWithCompletionHandler:
Method: void LoadScores (GKScoresLoadedHandler scoresLoadedHandler);
Selector: loadCategoriesWithCompletionHandler:
Method: void LoadCategories (GKCategoryHandler categoryHandler);
Selector: setDefaultLeaderboard:withCompletionHandler:
Method: void SetDefaultLeaderboard (string categoryID, GKNotificationHandler notificationHandler);

Class GKPlayer

Selector: playerID
Property: string PlayerID { get; }
Selector: alias
Property: string Alias { get; }
Selector: isFriend
Property: bool IsFriend { get; }
Selector: loadPlayersForIdentifiers:withCompletionHandler:
Method: void LoadPlayersForIdentifiers (string [] identifiers, GKPlayersHandler completionHandler);
Selector: loadPhotoForSize:withCompletionHandler:
Method: void LoadPhoto (GKPhotoSize size, GKPlayerPhotoLoaded onCompleted);

Class GKScore

Selector: initWithCategory:
Method: IntPtr Constructor (string category);
Selector: playerID
Property: string Player { get; }
Selector: rank
Property: int Rank { get; }
Selector: date
Property: NSDate Date { get; set; }
Selector: value
Property: long Value { get; set; }
Selector: formattedValue
Property: string FormattedValue { get; }
Selector: category
Property: string category { get; set; }
Selector: date
Property: NSDate date { get; }
Selector: reportScoreWithCompletionHandler:
Method: void ReportScore (GKNotificationHandler errorHandler);
Selector: context
Property: ulong Context { get; set; }
Selector: shouldSetDefaultLeaderboard
Property: bool ShouldSetDefaultLeaderboard { get; set; }

Class GKLeaderboardViewControllerDelegate

Selector: leaderboardViewControllerDidFinish:
Method: void DidFinish (GKLeaderboardViewController viewController);

Class GKLeaderboardViewController

Selector: initWithTimeScope:playerScope:
Method: IntPtr Constructor (GKLeaderboardTimeScope timeScope, GKLeaderboardPlayerScope playerScope);
Selector: leaderboardDelegate
Property: NSObject WeakDelegate { get; set; }
Selector: category
Property: string Category { get; set; }
Selector: timeScope
Property: GKLeaderboardTimeScope TimeScope { get; set; }

Class GKLocalPlayer

Selector: authenticated
Property: bool Authenticated { [Bind ("isAuthenticated")] get; }
Selector: friends
Property: string [] Friends { get; }
Selector: localPlayer
Property: GKLocalPlayer LocalPlayer { get; }
Selector: isUnderage
Property: bool IsUnderage { get; }
Selector: authenticateWithCompletionHandler:
Method: void Authenticate (GKNotificationHandler handler);
Selector: loadFriendsWithCompletionHandler:
Method: void LoadFriends (GKFriendsHandler handler);

Class GKMatch

Selector: players
Property: string [] PlayersIDs { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: expectedPlayerCount
Property: int ExpectedPlayerCount { get; }
Selector: sendData:toPlayers:withDataMode:error:
Method: bool SendData (NSData data, string [] players, GKMatchSendDataMode mode, NSError error);
Selector: sendDataToAllPlayers:withDataMode:error:
Method: bool SendDataToAllPlayers (NSData data, GKMatchSendDataMode mode, IntPtr ptrToNSErrorHandle);
Selector: disconnect
Method: void Disconnect ();
Selector: voiceChatWithName:
Method: GKVoiceChat VoiceChatWithName (string name);

Class GKMatchDelegate

Selector: match:didReceiveData:fromPlayer:"), EventArgs ("GKData
Method: void DataReceived (GKMatch match, NSData data, string playerId);
Selector: match:player:didChangeState:"), EventArgs ("GKState
Method: void StateChanged (GKMatch match, string playerId, GKPlayerConnectionState state);
Selector: match:connectionWithPlayerFailed:withError:"), EventArgs ("GKPlayerError
Method: void ConnectionFailed (GKMatch match, string playerId, NSError error);
Selector: match:didFailWithError:"), EventArgs ("GKError
Method: void Failed (GKMatch match, NSError error);
Selector: match:shouldReinvitePlayer:"), DelegateName ("GKMatchReinvitation
Method: bool ShouldReinvitePlayer (GKMatch match, string playerId);

Class GKVoiceChat

Selector: name
Property: string Name { get; }
Selector: active
Property: bool Active { [Bind ("isActive")] get; set; }
Selector: volume
Property: float Volume { get; set; }
Selector: start
Method: void Start ();
Selector: stop
Method: void Stop ();
Selector: setMute:forPlayer:
Method: void SetMute (bool isMuted, GKPlayer player);
Selector: isVoIPAllowed
Method: bool IsVoIPAllowed ();
Selector: playerStateUpdateHandler
Method: void SetPlayerStateUpdateHandler (GKPlayerStateUpdateHandler handler);
Selector: playerIDs
Property: string [] PlayerIDs {get; }

Class GKMatchRequest

Selector: minPlayers
Property: int MinPlayers { get; set; }
Selector: maxPlayers
Property: int MaxPlayers { get; set; }
Selector: playerGroup
Property: int PlayerGroup { get; set; }
Selector: playerAttributes
Property: uint PlayerAttributes { get; set; }
Selector: playersToInvite
Property: string [] PlayersToInvite { get; set; }

Class GKInvite

Selector: inviter
Property: string Inviter { get; }
Selector: hosted
Property: bool Hosted { [Bind ("isHosted")] get; }

Class GKMatchmaker

Selector: sharedMatchmaker
Property: GKMatchmaker SharedMatchmaker { get; }
Selector: setInviteHandler:
Method: void SetInviteHandler (GKInviteHandler handler);
Selector: findMatchForRequest:withCompletionHandler:
Method: void FindMatch (GKMatchRequest request, GKNotificationMatch matchHandler);
Selector: findPlayersForHostedMatchRequest:withCompletionHandler:
Method: void FindPlayers (GKMatchRequest request, GKFriendsHandler playerHandler);
Selector: addPlayersToMatch:matchRequest:completionHandler:
Method: void AddPlayers (GKMatch toMatch, GKMatchRequest matchRequest, GKNotificationHandler completionHandler);
Selector: cancel
Method: void Cancel ();
Selector: queryPlayerGroupActivity:withCompletionHandler:
Method: void QueryPlayerGroupActivity (uint playerGroup, GKQueryHandler completionHandler);
Selector: queryActivityWithCompletionHandler:
Method: void QueryActivity (GKQueryHandler completionHandler);

Class GKMatchmakerViewController

Selector: matchmakerDelegate
Property: NSObject WeakMatchmakerDelegate { get; set; }
Selector: matchRequest
Property: GKMatchRequest MatchRequest { get; }
Selector: hosted
Property: bool Hosted { [Bind ("isHosted")] get; set; }
Selector: initWithMatchRequest:
Method: IntPtr Constructor (GKMatchRequest request);
Selector: initWithInvite:
Method: IntPtr Constructor (GKInvite invite);
Selector: setHostedPlayerReady:
Method: void SetHostedPlayerReady (string playerID);
Selector: defaultInvitationMessage
Property: string DefaultInvitationMessage { get; set; }
Selector: addPlayersToMatch:
Method: void AddPlayersToMatch (GKMatch match);
Selector: setHostedPlayer:connected:
Method: void SetHostedPlayerConnected (string playerID, bool connected);

Class GKMatchmakerViewControllerDelegate

Selector: matchmakerViewControllerWasCancelled:
Method: void WasCancelled (GKMatchmakerViewController viewController);
Selector: matchmakerViewController:didFailWithError:"), EventArgs ("GKError
Method: void DidFailWithError (GKMatchmakerViewController viewController, NSError error);
Selector: matchmakerViewController:didFindMatch:"), EventArgs ("GKMatch
Method: void DidFindMatch (GKMatchmakerViewController viewController, GKMatch match);
Selector: matchmakerViewController:didFindPlayers:"), EventArgs ("GKPlayers
Method: void DidFindPlayers (GKMatchmakerViewController viewController, string [] playerIDs);
Selector: matchmakerViewController:didReceiveAcceptFromHostedPlayer:"), EventArgs ("GKPlayer
Method: void ReceivedAcceptFromHostedPlayer (GKMatchmakerViewController viewController, string playerID);

Class GKAchievement

Selector: hidden
Property: bool Hidden { get; }
Selector: identifier
Property: string Identifier { get; set; }
Selector: percentComplete
Property: double PercentComplete { get; set; }
Selector: completed
Property: bool Completed { [Bind ("isCompleted")] get; set; }
Selector: lastReportedDate
Property: NSDate LastReportedDate { get; set; }
Selector: loadAchievementsWithCompletionHandler:
Method: void LoadAchievements (GKCompletionHandler completionHandler);
Selector: resetAchievementsWithCompletionHandler:
Method: void ResetAchivements (GKNotificationHandler errorHandler);
Selector: initWithIdentifier:
Method: IntPtr Constructor (string identifier);
Selector: reportAchievementWithCompletionHandler:
Method: void ReportAchievement (GKNotificationHandler handler);
Selector: showsCompletionBanner
Property: bool ShowsCompletionBanner { get; set; }

Class GKAchievementDescription

Selector: identifier
Property: string Identifier { get; }
Selector: title
Property: string Title { get; }
Selector: achievedDescription
Property: string AchievedDescription { get; }
Selector: unachievedDescription
Property: string UnachievedDescription { get; }
Selector: maximumPoints
Property: int MaximumPoints { get; }
Selector: hidden
Property: bool Hidden { get; }
Selector: image
Property: UIImage Image { get; }
Selector: loadAchievementDescriptionsWithCompletionHandler:
Method: void LoadAchievementDescriptions (GKAchievementDescriptionHandler handler);
Selector: incompleteAchievementImage
Property: UIImage IncompleteAchievementImage { get; }
Selector: placeholderCompletedAchievementImage
Property: UIImage PlaceholderCompletedAchievementImage { get; }
Selector: loadImageWithCompletionHandler:
Method: void LoadImage (GKImageLoadedHandler imageLoadedHandler);

Class GKAchievementViewControllerDelegate

Selector: achievementViewControllerDidFinish:
Method: void DidFinish (GKAchievementViewController viewController);

Class GKAchievementViewController

Selector: achievementDelegate
Property: NSObject WeakDelegate { get; set; }

Class GKFriendRequestComposeViewController

Selector: composeViewDelegate
Property: NSObject WeakComposeViewDelegate { get; set; }
Selector: maxNumberOfRecipients
Property: int MaxNumberOfRecipients { get; }
Selector: addRecipientsWithAliases:
Method: void AddRecipientsFromAliases (string [] aliases);
Selector: addRecipientsWithEmailAddresses:
Method: void AddRecipientsFromEmails (string [] emailAddresses);
Selector: addRecipientsWithPlayerIDs:
Method: void AddRecipientsFromPlayerIDs (string [] emailAddresses);
Selector: message
Property: string Message { set; }

Class GKFriendRequestComposeViewControllerDelegate

Selector: friendRequestComposeViewControllerDidFinish:
Method: void DidFinish (GKFriendRequestComposeViewController viewController);

Class GKNotificationBanner

Selector: showBannerWithTitle:message:completionHandler:
Method: void Show (string title, string message, NSAction onCompleted);

Class GKTurnBasedParticipant

Selector: playerID
Property: string PlayerID { get; }
Selector: lastTurnDate
Property: NSDate LastTurnDate { get; }
Selector: status
Property: GKTurnBasedParticipantStatus Status { get; }
Selector: matchOutcome
Property: GKTurnBasedMatchOutcome MatchOutcome { get; set; }

Class GKTurnBasedEventHandlerDelegate

Selector: handleInviteFromGameCenter:
Method: void HandleInviteFromGameCenter (GKPlayer [] playersToInvite);
Selector: handleTurnEventForMatch:
Method: void HandleTurnEventForMatch (GKTurnBasedMatch match);
Selector: handleMatchEnded:
Method: void HandleMatchEnded (GKTurnBasedMatch match);

Class GKTurnBasedEventHandler

Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class GKTurnBasedMatch

Selector: matchID
Property: string MatchID { get; }
Selector: creationDate
Property: NSDate CreationDate { get; }
Selector: participants
Property: GKTurnBasedParticipant []Participants { get; }
Selector: status
Property: GKTurnBasedMatchStatus Status { get; }
Selector: currentParticipant
Property: GKTurnBasedParticipant CurrentParticipant { get; }
Selector: matchData
Property: NSData MatchData { get; }
Selector: message
Property: string Message { get; set; }
Selector: findMatchForRequest:withCompletionHandler:
Method: void FindMatch (GKMatchRequest request, GKTurnBasedMatchRequest onCompletion);
Selector: loadMatchesWithCompletionHandler:
Method: void LoadMatches (GKTurnBasedMatchesRequest onCompletion);
Selector: removeWithCompletionHandler:
Method: void Remove (GKNotificationHandler onCompletion);
Selector: loadMatchDataWithCompletionHandler:
Method: void LoadMatchData (GKTurnBasedMatchData onCompletion);
Selector: endTurnWithNextParticipant:matchData:completionHandler:
Method: void EndTurnWithNextParticipant (GKTurnBasedParticipant nextParticipatn, NSData matchData, GKNotificationHandler noCompletion);
Selector: participantQuitInTurnWithOutcome:nextParticipant:matchData:completionHandler:
Method: void ParticipantQuitInTurn (GKTurnBasedMatchOutcome matchOutcome, GKTurnBasedParticipant nextParticipant, NSData matchData, GKNotificationHandler onCompletion);
Selector: participantQuitOutOfTurnWithOutcome:withCompletionHandler:
Method: void ParticipantQuitOutOfTurn (GKTurnBasedMatchOutcome matchOutcome, GKNotificationHandler onCompletion);
Selector: endMatchInTurnWithMatchData:completionHandler:
Method: void EndMatchInTurn (NSData matchData, GKNotificationHandler onCompletion);

Class GKTurnBasedMatchmakerViewController

Selector: showExistingMatches
Property: bool ShowExistingMatches { get; set; }
Selector: initWithMatchRequest:
Method: IntPtr Constructor (GKMatchRequest request);
Selector: turnBasedMatchmakerDelegate
Property: NSObject WeakDelegate { get; set; }

Class GKTurnBasedMatchmakerViewControllerDelegate

Selector: turnBasedMatchmakerViewControllerWasCancelled:
Method: void WasCancelled (GKTurnBasedMatchmakerViewController viewController);
Selector: turnBasedMatchmakerViewController:didFailWithError:
Method: void FailedWithError (GKTurnBasedMatchmakerViewController viewController, NSError error);
Selector: turnBasedMatchmakerViewController:didFindMatch:
Method: void FoundMatch (GKTurnBasedMatchmakerViewController viewController, GKTurnBasedMatch match);
Selector: turnBasedMatchmakerViewController:playerQuitForMatch:
Method: void PlayerQuitForMatch (GKTurnBasedMatchmakerViewController viewController, GKTurnBasedMatch match);

Namespace MonoTouch.MessageUI

Class MFMailComposeViewController

Selector: canSendMail
Property: bool CanSendMail { get; }
Selector: mailComposeDelegate
Property: NSObject WeakMailComposeDelegate { get; set; }
Selector: setSubject:
Method: void SetSubject (string subject);
Selector: setToRecipients:
Method: void SetToRecipients (string [] recipients);
Selector: setCcRecipients:
Method: void SetCcRecipients (string [] ccRecipients);
Selector: setBccRecipients:
Method: void SetBccRecipients (string [] bccRecipients);
Selector: setMessageBody:isHTML:
Method: void SetMessageBody (string body, bool isHtml);
Selector: addAttachmentData:mimeType:fileName:
Method: void AddAttachmentData (NSData attachment, string mimeType, string fileName);

Class MFMailComposeViewControllerDelegate

Selector: mailComposeController:didFinishWithResult:error:
Method: void Finished (MFMailComposeViewController controller, MFMailComposeResult result, NSError error);

Class MFMessageComposeViewController

Selector: messageComposeDelegate
Property: NSObject WeakMessageComposeDelegate { get; set; }
Selector: recipients
Property: string [] Recipients { get; set; }
Selector: body
Property: string Body { get; set; }
Selector: canSendText
Property: bool CanSendText { get; }

Class MFMessageComposeViewControllerDelegate

Selector: messageComposeViewController:didFinishWithResult:
Method: void Finished (MFMessageComposeViewController controller, MessageComposeResult result);

Namespace MonoTouch.UIKit

Class UIAcceleration

Selector: timestamp
Property: double Time { get; }
Selector: x
Property: double X { get; }
Selector: y
Property: double Y { get; }
Selector: z
Property: double Z { get; }

Class UIAccelerometer

Selector: sharedAccelerometer
Property: UIAccelerometer SharedAccelerometer { get; }
Selector: updateInterval
Property: double UpdateInterval { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class UIAccelerometerDelegate

Selector: accelerometer:didAccelerate:"), EventArgs ("UIAccelerometer"), EventName ("Acceleration
Method: void DidAccelerate (UIAccelerometer accelerometer, UIAcceleration acceleration);

Class UIActionSheet

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: initWithTitle:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:")][Internal][PostGet ("WeakDelegate
Method: IntPtr Constructor (string title, [NullAllowed] UIActionSheetDelegate Delegate, [NullAllowed] string cancelTitle, [NullAllowed] string destroy, [NullAllowed] string other);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: title
Property: string Title { get; set; }
Selector: actionSheetStyle
Property: UIActionSheetStyle Style { get; set; }
Selector: addButtonWithTitle:
Method: int AddButton (string title);
Selector: buttonTitleAtIndex:
Method: string ButtonTitle (int index);
Selector: numberOfButtons
Property: int ButtonCount { get; }
Selector: cancelButtonIndex
Property: int CancelButtonIndex { get; set; }
Selector: destructiveButtonIndex
Property: int DestructiveButtonIndex { get; set; }
Selector: firstOtherButtonIndex
Property: int FirstOtherButtonIndex { get; }
Selector: visible
Property: bool Visible { [Bind ("isVisible")] get; set; }
Selector: showFromToolbar:
Method: void ShowFromToolbar (UIToolbar view);
Selector: showFromTabBar:
Method: void ShowFromTabBar (UITabBar view);
Selector: showInView:
Method: void ShowInView (UIView view);
Selector: dismissWithClickedButtonIndex:animated:
Method: void DismissWithClickedButtonIndex (int buttonIndex, bool animated);
Selector: showFromBarButtonItem:animated:
Method: void ShowFrom (UIBarButtonItem item, bool animated);
Selector: showFromRect:inView:animated:
Method: void ShowFrom (RectangleF rect, UIView inView, bool animated);

Class UIActionSheetDelegate

Selector: actionSheet:clickedButtonAtIndex:"), EventArgs ("UIButton
Method: void Clicked (UIActionSheet actionSheet, int buttonIndex);
Selector: actionSheetCancel:"), EventArgs ("UIActionSheet
Method: void Canceled (UIActionSheet actionSheet);
Selector: willPresentActionSheet:"), EventArgs ("UIActionSheet
Method: void WillPresent (UIActionSheet actionSheet);
Selector: didPresentActionSheet:"), EventArgs ("UIActionSheet
Method: void Presented (UIActionSheet actionSheet);
Selector: actionSheet:willDismissWithButtonIndex:"), EventArgs ("UIButton
Method: void WillDismiss (UIActionSheet actionSheet, int buttonIndex);
Selector: actionSheet:didDismissWithButtonIndex:"), EventArgs ("UIButton
Method: void Dismissed (UIActionSheet actionSheet, int buttonIndex);

Class UIAlertView

Selector: initWithTitle:message:delegate:cancelButtonTitle:otherButtonTitles:")][Internal][PostGet ("WeakDelegate
Method: IntPtr Constructor (string title, string message, [NullAllowed] UIAlertViewDelegate Del, [NullAllowed] string cancelButtonTitle, [NullAllowed] string otherButtonTitles);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: title
Property: string Title { get; set; }
Selector: message
Property: string Message { get; set; }
Selector: addButtonWithTitle:
Method: int AddButton (string title);
Selector: buttonTitleAtIndex:
Method: string ButtonTitle (int index);
Selector: numberOfButtons
Property: int ButtonCount { get; }
Selector: cancelButtonIndex
Property: int CancelButtonIndex { get; set; }
Selector: firstOtherButtonIndex
Property: int FirstOtherButtonIndex { get; }
Selector: visible
Property: bool Visible { [Bind ("isVisible")] get; set; }
Selector: show
Method: void Show ();
Selector: dismissWithClickedButtonIndex:animated:
Method: void DismissWithClickedButtonIndex (int index, bool animated);
Selector: alertViewStyle
Property: UIAlertViewStyle AlertViewStyle { get; set; }
Selector: textFieldAtIndex:
Method: UITextField GetTextField (int textFieldIndex);

Class UIAlertViewDelegate

Selector: alertView:clickedButtonAtIndex:"), EventArgs ("UIButton
Method: void Clicked (UIAlertView alertview, int buttonIndex);
Selector: alertViewCancel:"), EventArgs ("UIAlertView
Method: void Canceled (UIAlertView alertView);
Selector: willPresentAlertView:"), EventArgs ("UIAlertView
Method: void WillPresent (UIAlertView alertView);
Selector: didPresentAlertView:"), EventArgs ("UIAlertView
Method: void Presented (UIAlertView alertView);
Selector: alertView:willDismissWithButtonIndex:"), EventArgs ("UIButton
Method: void WillDismiss (UIAlertView alertView, int buttonIndex);
Selector: alertView:didDismissWithButtonIndex:"), EventArgs ("UIButton
Method: void Dismissed (UIAlertView alertView, int buttonIndex);
Selector: alertViewShouldEnableFirstOtherButton:"), DelegateName ("UIAlertViewPredicate
Method: bool ShouldEnableFirstOtherButton (UIAlertView alertView);

Class UIAppearance

Class UIApplication

Selector: sharedApplication
Property: UIApplication SharedApplication { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: beginIgnoringInteractionEvents
Method: void BeginIgnoringInteractionEvents ();
Selector: endIgnoringInteractionEvents
Method: void EndIgnoringInteractionEvents ();
Selector: isIgnoringInteractionEvents
Property: bool IsIgnoringInteractionEvents { get; }
Selector: idleTimerDisabled
Property: bool IdleTimerDisabled { [Bind ("isIdleTimerDisabled")] get; set; }
Selector: openURL:
Method: bool OpenUrl (NSUrl url);
Selector: canOpenURL:
Method: bool CanOpenUrl ([NullAllowed] NSUrl url);
Selector: sendEvent:
Method: void SendEvent (UIEvent uievent);
Selector: keyWindow
Property: UIWindow KeyWindow { get; }
Selector: windows
Property: UIWindow [] Windows { get; }
Selector: sendAction:to:from:forEvent:
Method: bool SendAction (Selector action, NSObject target, NSObject sender, UIEvent forEvent);
Selector: networkActivityIndicatorVisible
Property: bool NetworkActivityIndicatorVisible { [Bind ("isNetworkActivityIndicatorVisible")] get; set; }
Selector: statusBarStyle
Property: UIStatusBarStyle StatusBarStyle { get; set; }
Selector: setStatusBarStyle:animated:
Method: void SetStatusBarStyle (UIStatusBarStyle statusBarStyle, bool animated);
Selector: statusBarHidden
Property: bool StatusBarHidden { [Bind ("isStatusBarHidden")] get; set; }
Selector: setStatusBarHidden:withAnimation:
Method: void SetStatusBarHidden (bool state, UIStatusBarAnimation animation);
Selector: setStatusBarHidden:animated:
Method: void SetStatusBarHidden (bool hiddent, bool animated);
Selector: statusBarOrientation
Property: UIInterfaceOrientation StatusBarOrientation { get; set; }
Selector: setStatusBarOrientation:animated:
Method: void SetStatusBarOrientation (UIInterfaceOrientation orientation, bool animated);
Selector: statusBarOrientationAnimationDuration
Property: double StatusBarOrientationAnimationDuration { get; }
Selector: statusBarFrame
Property: RectangleF StatusBarFrame { get; }
Selector: applicationIconBadgeNumber
Property: int ApplicationIconBadgeNumber { get; set; }
Selector: applicationSupportsShakeToEdit
Property: bool ApplicationSupportsShakeToEdit { get; set; }
Selector: registerForRemoteNotificationTypes:
Method: void RegisterForRemoteNotificationTypes (UIRemoteNotificationType types);
Selector: unregisterForRemoteNotifications
Method: void UnregisterForRemoteNotifications ();
Selector: enabledRemoteNotificationTypes
Property: UIRemoteNotificationType EnabledRemoteNotificationTypes { get; }
Selector: applicationState
Property: UIApplicationState ApplicationState { get; }
Selector: backgroundTimeRemaining
Property: double BackgroundTimeRemaining { get; }
Selector: beginBackgroundTaskWithExpirationHandler:
Method: int BeginBackgroundTask (NSAction backgroundTimeExpired);
Selector: endBackgroundTask:
Method: void EndBackgroundTask (int taskId);
Selector: setKeepAliveTimeout:handler:
Method: bool SetKeepAliveTimeout (double timeout, NSAction handler);
Selector: clearKeepAliveTimeout
Method: void ClearKeepAliveTimeout ();
Selector: protectedDataAvailable
Property: bool ProtectedDataAvailable { [Bind ("isProtectedDataAvailable")] get; set; }
Selector: presentLocalNotificationNow:
Method: void PresentLocationNotificationNow (UILocalNotification notification);
Selector: scheduleLocalNotification:
Method: void ScheduleLocalNotification (UILocalNotification notification);
Selector: cancelLocalNotification:
Method: void CancelLocalNotification (UILocalNotification notification);
Selector: cancelAllLocalNotifications
Method: void CancelAllLocalNotifications ();
Selector: scheduledLocalNotifications
Property: UILocalNotification [] ScheduledLocalNotifications { get; }
Selector: beginReceivingRemoteControlEvents
Method: void BeginReceivingRemoteControlEvents ();
Selector: endReceivingRemoteControlEvents
Method: void EndReceivingRemoteControlEvents ();
Selector: userInterfaceLayoutDirection
Property: UIUserInterfaceLayoutDirection UserInterfaceLayoutDirection { get; }
Selector: setNewsstandIconImage:
Method: [NullAllowed]

Class UIApplicationDelegate

Selector: applicationDidFinishLaunching:
Method: void FinishedLaunching (UIApplication application);
Selector: application:didFinishLaunchingWithOptions:
Method: bool FinishedLaunching (UIApplication application, NSDictionary launcOptions);
Selector: applicationDidBecomeActive:
Method: void OnActivated (UIApplication application);
Selector: applicationWillResignActive:
Method: void OnResignActivation (UIApplication application);
Selector: application:handleOpenURL:
Method: void HandleOpenURL (UIApplication application, NSUrl url);
Selector: applicationDidReceiveMemoryWarning:
Method: void ReceiveMemoryWarning (UIApplication application);
Selector: applicationWillTerminate:
Method: void WillTerminate (UIApplication application);
Selector: applicationSignificantTimeChange:
Method: void ApplicationSignificantTimeChange (UIApplication application);
Selector: application:willChangeStatusBarOrientation:duration:
Method: void WillChangeStatusBarOrientation (UIApplication application, UIInterfaceOrientation newStatusBarOrientation, double duration);
Selector: application:didChangeStatusBarOrientation:
Method: void DidChangeStatusBarOrientation (UIApplication application, UIInterfaceOrientation oldStatusBarOrientation);
Selector: application:willChangeStatusBarFrame:
Method: void WillChangeStatusBarFrame (UIApplication application, RectangleF newStatusBarFrame);
Selector: application:didChangeStatusBarFrame:
Method: void ChangedStatusBarFrame (UIApplication application, RectangleF oldStatusBarFrame);
Selector: application:didRegisterForRemoteNotificationsWithDeviceToken:
Method: void RegisteredForRemoteNotifications (UIApplication application, NSData deviceToken);
Selector: application:didFailToRegisterForRemoteNotificationsWithError:
Method: void FailedToRegisterForRemoteNotifications (UIApplication application, NSError error);
Selector: application:didReceiveRemoteNotification:
Method: void ReceivedRemoteNotification (UIApplication application, NSDictionary userInfo);
Selector: application:didReceiveLocalNotification:
Method: void ReceivedLocalNotification (UIApplication application, UILocalNotification notification);
Selector: applicationDidEnterBackground:
Method: void DidEnterBackground (UIApplication application);
Selector: applicationWillEnterForeground:
Method: [Since (4,0)]
Selector: applicationProtectedDataWillBecomeUnavailable:
Method: [Since (4,0)]
Selector: applicationProtectedDataDidBecomeAvailable:
Method: [Since (4,0)]
Selector: application:openURL:sourceApplication:annotation:
Method: void OpenUrl (UIApplication application, NSUrl url, string sourceApplication, NSObject annotation);
Selector: window
Property: UIWindow Window { get; set; }

Class UIBarItem : UIAppearance

Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: title
Property: string Title { get;set; }
Selector: image
Property: UIImage Image { get; set; }
Selector: imageInsets
Property: UIEdgeInsets ImageInsets { get; set; }
Selector: tag
Property: int Tag { get; set; }
Selector: landscapeImagePhone
Property: UIImage LandscapeImagePhone { get; set; }
Selector: landscapeImagePhoneInsets
Property: UIEdgeInsets LandscapeImagePhoneInsets { get; set; }
Selector: setTitleTextAttributes:forState:
Method: [Appearance]
Selector: titleTextAttributesForState:
Method: [Appearance]

Class UIBarButtonItem

Selector: initWithImage:style:target:action:
Method: IntPtr Constructor (UIImage image, UIBarButtonItemStyle style, NSObject target, Selector action);
Selector: initWithTitle:style:target:action:
Method: IntPtr Constructor (string title, UIBarButtonItemStyle style, NSObject target, Selector action);
Selector: initWithBarButtonSystemItem:target:action:
Method: IntPtr Constructor (UIBarButtonSystemItem systemItem, [NullAllowed] NSObject target, [NullAllowed] Selector action);
Selector: initWithCustomView:
Method: //IntPtr Constructor (UIView customView);
Selector: style
Property: UIBarButtonItemStyle Style { get; set; }
Selector: width
Property: float Width { get; set; }
Selector: possibleTitles
Property: NSSet PossibleTitles { get; }
Selector: customView
Property: UIView CustomView { get; set; }
Selector: action
Property: Selector Action { get; set; }
Selector: target
Property: NSObject Target { get; set; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: title
Property: string Title { get;set; }
Selector: image
Property: UIImage Image { get; set; }
Selector: imageInsets
Property: UIEdgeInsets ImageInsets { get; set; }
Selector: tag
Property: int Tag { get; set; }
Selector: tintColor
Method: [Appearance]
Selector: initWithImage:landscapeImagePhone:style:target:action:
Method: IntPtr Constructor (UIImage image, UIImage landscapeImagePhone, UIBarButtonItemStyle style, NSObject target, Selector action);
Selector: setBackgroundImage:forState:barMetrics:
Method: [Appearance]
Selector: backgroundImageForState:barMetrics:
Method: [Appearance]
Selector: setBackgroundVerticalPositionAdjustment:forBarMetrics:
Method: [Appearance]
Selector: backgroundVerticalPositionAdjustmentForBarMetrics:
Method: [Appearance]
Selector: setTitlePositionAdjustment:forBarMetrics:
Method: [Appearance]
Selector: titlePositionAdjustmentForBarMetrics:
Method: [Appearance]
Selector: setBackButtonBackgroundImage:forState:barMetrics:
Method: [Appearance]
Selector: backButtonBackgroundImageForState:barMetrics:
Method: [Appearance]
Selector: setBackButtonTitlePositionAdjustment:forBarMetrics:
Method: [Appearance]
Selector: backButtonTitlePositionAdjustmentForBarMetrics:
Method: [Appearance]
Selector: setBackButtonBackgroundVerticalPositionAdjustment:forBarMetrics:
Method: [Appearance]
Selector: backButtonBackgroundVerticalPositionAdjustmentForBarMetrics:
Method: [Appearance]

Class UIColor

Selector: colorWithWhite:alpha:
Method: UIColor FromWhiteAlpha (float white, float alpha);
Selector: initWithRed:green:blue:alpha:
Method: IntPtr Constructor (float red, float green, float blue, float alpha);
Selector: colorWithHue:saturation:brightness:alpha:
Method: UIColor FromHSBA (float hue, float saturation, float brightness, float alpha);
Selector: colorWithRed:green:blue:alpha:
Method: UIColor FromRGBA (float red, float green, float blue, float alpha);
Selector: colorWithCGColor:
Method: UIColor FromCGColor (CGColor color);
Selector: colorWithPatternImage:
Method: UIColor FromPatternImage (UIImage image);
Selector: initWithCGColor:
Method: IntPtr Constructor (CGColor color);
Selector: clearColor
Property: UIColor Clear { get; }
Selector: blackColor
Property: UIColor Black { get; }
Selector: darkGrayColor
Property: UIColor DarkGray { get; }
Selector: lightGrayColor
Property: UIColor LightGray { get; }
Selector: whiteColor
Property: UIColor White { get; }
Selector: grayColor
Property: UIColor Gray { get; }
Selector: redColor
Property: UIColor Red { get; }
Selector: greenColor
Property: UIColor Green { get; }
Selector: blueColor
Property: UIColor Blue { get; }
Selector: cyanColor
Property: UIColor Cyan { get; }
Selector: yellowColor
Property: UIColor Yellow { get; }
Selector: magentaColor
Property: UIColor Magenta { get; }
Selector: orangeColor
Property: UIColor Orange { get; }
Selector: purpleColor
Property: UIColor Purple { get; }
Selector: brownColor
Property: UIColor Brown { get; }
Selector: set
Method: void SetColor ();
Selector: setFill
Method: void SetFill ();
Selector: setStroke
Method: void SetStroke ();
Selector: colorWithAlphaComponent:
Method: UIColor ColorWithAlpha (float alpha);
Selector: CGColor
Property: CGColor CGColor { get; }
Selector: lightTextColor
Method: [Static]
Selector: darkTextColor
Method: [Static]
Selector: groupTableViewBackgroundColor
Property: UIColor GroupTableViewBackgroundColor { get; }
Selector: viewFlipsideBackgroundColor
Property: UIColor ViewFlipsideBackgroundColor { get; }
Selector: scrollViewTexturedBackgroundColor
Property: UIColor ScrollViewTexturedBackgroundColor { get; }
Selector: underPageBackgroundColor
Property: UIColor UnderPageBackgroundColor { get; }
Selector: colorWithCIColor:
Method: UIColor FromCIColor (CIColor color);
Selector: initWithCIColor:
Method: IntPtr Constructor (CIColor ciColor);

Class UIDocument

Selector: localizedName
Property: string LocalizedName { get; }
Selector: fileType
Property: string FileType { get; }
Selector: fileModificationDate
Property: NSDate FileModificationDate { get; set; }
Selector: documentState
Property: UIDocumentState DocumentState { get; }
Selector: initWithFileURL:
Method: IntPtr Constructor (NSUrl url);
Selector: fileURL
Property: NSUrl FileUrl { get; }
Selector: openWithCompletionHandler:
Method: void Open (UIOperationHandler completionHandler);
Selector: closeWithCompletionHandler:
Method: void Close (UIOperationHandler completionHandler);
Selector: loadFromContents:ofType:error:
Method: bool LoadFromContents (NSObject contents, string typeName, out NSError outError);
Selector: contentsForType:error:
Method: NSObject ContentsForType (string typeName, out NSError outError);
Selector: disableEditing
Method: void DisableEditing ();
Selector: enableEditing
Method: void EnableEditing ();
Selector: undoManager
Property: NSUndoManager UndoManager { get; set; }
Selector: hasUnsavedChanges
Property: bool HasUnsavedChanges { get; }
Selector: updateChangeCount:
Method: void UpdateChangeCount (UIDocumentChangeKind change);
Selector: changeCountTokenForSaveOperation:
Method: NSObject ChangeCountTokenForSaveOperation (UIDocumentSaveOperation saveOperation);
Selector: updateChangeCountWithToken:forSaveOperation:
Method: void UpdateChangeCount (NSObject changeCountToken, UIDocumentSaveOperation saveOperation);
Selector: saveToURL:forSaveOperation:completionHandler:
Method: void Save (NSUrl url, UIDocumentSaveOperation saveOperation, UIOperationHandler completionHandler);
Selector: autosaveWithCompletionHandler:
Method: void AutoSave (UIOperationHandler completionHandler);
Selector: savingFileType
Property: string SavingFileType { get; }
Selector: fileNameExtensionForType:saveOperation:
Method: string GetFileNameExtension (string typeName, UIDocumentSaveOperation saveOperation);
Selector: writeContents:andAttributes:safelyToURL:forSaveOperation:error:
Method: bool WriteContents (NSObject contents, NSDictionary additionalFileAttributes, NSUrl url, UIDocumentSaveOperation saveOperation, out NSError outError);
Selector: writeContents:toURL:forSaveOperation:originalContentsURL:error:
Method: bool WriteContents (NSObject contents, NSUrl toUrl, UIDocumentSaveOperation saveOperation, NSUrl originalContentsURL, out NSError outError);
Selector: fileAttributesToWriteToURL:forSaveOperation:error:
Method: NSDictionary GetFileAttributesToWrite (NSUrl forUrl, UIDocumentSaveOperation saveOperation, out NSError outError);
Selector: readFromURL:error:
Method: bool Read (NSUrl fromUrl, out NSError outError);
Selector: performAsynchronousFileAccessUsingBlock:
Method: void PerformAsynchronousFileAccess (NSAction action);
Selector: handleError:userInteractionPermitted:
Method: void HandleError (NSError error, bool userInteractionPermitted);
Selector: finishedHandlingError:recovered:
Method: void FinishedHandlingError (NSError error, bool recovered);
Selector: userInteractionNoLongerPermittedForError:
Method: void UserInteractionNoLongerPermittedForError (NSError error);
Selector: revertToContentsOfURL:completionHandler:
Method: void RevertToContentsOfUrl (NSUrl url, UIOperationHandler completionHandler);

Class UIFont

Selector: systemFontOfSize:
Method: UIFont SystemFontOfSize (float size);
Selector: boldSystemFontOfSize:
Method: UIFont BoldSystemFontOfSize (float size);
Selector: italicSystemFontOfSize:
Method: UIFont ItalicSystemFontOfSize (float size);
Selector: fontWithName:size:
Method: UIFont FromName (string name, float size);
Selector: labelFontSize
Property: float LabelFontSize { get; }
Selector: buttonFontSize
Property: float ButtonFontSize { get; }
Selector: smallSystemFontSize
Property: float SmallSystemFontSize { get; }
Selector: systemFontSize
Property: float SystemFontSize { get; }
Selector: familyName
Property: string FamilyName { get; }
Selector: fontName
Property: string Name { get; }
Selector: pointSize
Property: float PointSize { get; }
Selector: ascender
Property: float Ascender { get; }
Selector: descender
Property: float Descender { get; }
Selector: leading
Property: float Leading { get; }
Selector: capHeight
Property: float CapHeight { get; }
Selector: xHeight
Property: float xHeight { get; }
Selector: lineHeight
Property: float LineHeight { get; }
Selector: familyNames
Property: string [] FamilyNames { get; }
Selector: fontNamesForFamilyName:
Method: string [] FontNamesForFamilyName (string familyName);

Class UIGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: state
Property: UIGestureRecognizerState State { get; set; }
Selector: view
Property: UIView View { get; }
Selector: addTarget:action:
Method: void AddTarget (NSObject target, Selector action);
Selector: removeTarget:action:
Method: void RemoveTarget (NSObject target, Selector action);
Selector: locationInView:
Method: PointF LocationInView (UIView view);
Selector: cancelsTouchesInView
Property: bool CancelsTouchesInView { get; set; }
Selector: delaysTouchesBegan
Property: bool DelaysTouchesBegan { get; set; }
Selector: delaysTouchesEnded
Property: bool DelaysTouchesEnded { get; set; }
Selector: locationOfTouch:inView:
Method: PointF LocationOfTouch (int touchIndex, UIView inView);
Selector: numberOfTouches
Property: int NumberOfTouches { get; }
Selector: requireGestureRecognizerToFail:
Method: void RequireGestureRecognizerToFail (UIGestureRecognizer otherGestureRecognizer);
Selector: ignoreTouch:forEvent:
Method: void IgnoreTouch (UITouch touch, UIEvent forEvent);
Selector: reset
Method: void Reset ();
Selector: canPreventGestureRecognizer:
Method: bool CanPreventGestureRecognizer (UIGestureRecognizer preventedGestureRecognizer);
Selector: canBePreventedByGestureRecognizer:
Method: bool CanBePreventedByGestureRecognizer (UIGestureRecognizer preventingGestureRecognizer);
Selector: touchesBegan:withEvent:
Method: void TouchesBegan (NSSet touches, UIEvent evt);
Selector: touchesMoved:withEvent:
Method: void TouchesMoved (NSSet touches, UIEvent evt);
Selector: touchesEnded:withEvent:
Method: void TouchesEnded (NSSet touches, UIEvent evt);
Selector: touchesCancelled:withEvent:
Method: void TouchesCancelled (NSSet touches, UIEvent evt);

Class UIGestureRecognizerDelegate

Selector: gestureRecognizer:shouldReceiveTouch:"), DefaultValue (true), DelegateName ("UITouchEventArgs
Method: bool ShouldReceiveTouch (UIGestureRecognizer recognizer, UITouch touch);
Selector: gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:"), DelegateName ("UIGesturesProbe
Method: bool ShouldRecognizeSimultaneously (UIGestureRecognizer gestureRecognizer, UIGestureRecognizer otherGestureRecognizer);
Selector: gestureRecognizerShouldBegin:"), DelegateName ("UIGestureProbe
Method: bool ShouldBegin (UIGestureRecognizer recognizer);

Class UITextInputTraits

Selector: autocapitalizationType
Property: UITextAutocapitalizationType AutocapitalizationType { get; set; }
Selector: autocorrectionType
Property: UITextAutocorrectionType AutocorrectionType { get; set; }
Selector: keyboardType
Property: UIKeyboardType KeyboardType { get; set; }
Selector: keyboardAppearance
Property: UIKeyboardAppearance KeyboardAppearance { get; set; }
Selector: returnKeyType
Property: UIReturnKeyType ReturnKeyType { get; set; }
Selector: enablesReturnKeyAutomatically
Property: bool EnablesReturnKeyAutomatically { get; set; }
Selector: secureTextEntry
Property: bool SecureTextEntry { [Bind ("isSecureTextEntry")] get; set; }
Selector: spellCheckingType
Property: UITextSpellCheckingType SpellCheckingType { get; }

Class UIKeyInput : UITextInputTraits

Selector: hasText
Property: bool HasText { get; }
Selector: insertText:
Method: void InsertText (string text);
Selector: deleteBackward
Method: void DeleteBackward ();

Class UITextPosition

Class UITextRange

Selector: isEmpty
Property: bool IsEmpty { get; }
Selector: start
Property: UITextPosition start { get; }
Selector: end
Property: UITextPosition end { get; }

Class UITextInput : UIKeyInput

Selector: selectedTextRange
Property: UITextRange SelectedTextRange { get; set; }
Selector: markedTextStyle
Property: NSDictionary MarkedTextStyle { get; set; }
Selector: beginningOfDocument
Property: UITextPosition BeginningOfDocument { get; }
Selector: endOfDocument
Property: UITextPosition EndOfDocument { get; }
Selector: inputDelegate
Property: NSObject WeakInputDelegate { get; set; }
Selector: tokenizer
Property: NSObject WeakTokenizer { get; }
Selector: textInputView
Property: UIView TextInputView { get; }
Selector: selectionAffinity
Property: UITextStorageDirection SelectionAffinity { get; set; }
Selector: textInRange:
Method: string TextInRange (UITextRange range);
Selector: replaceRange:withText:
Method: void ReplaceText (UITextRange range, string text);
Selector: markedTextRange
Property: UITextRange MarkedTextRange { get; }
Selector: setMarkedText:selectedRange:
Method: void SetMarkedText (string markedText, NSRange selectedRange);
Selector: unmarkText
Method: void UnmarkText ();
Selector: textRangeFromPosition:toPosition:
Method: UITextRange GetTextRange (UITextPosition fromPosition, UITextPosition toPosition);
Selector: positionFromPosition:offset:
Method: UITextPosition GetPosition (UITextPosition fromPosition, int offset);
Selector: positionFromPosition:inDirection:offset:
Method: UITextPosition GetPosition (UITextPosition fromPosition, UITextLayoutDirection inDirection, int offset);
Selector: comparePosition:toPosition:
Method: NSComparisonResult ComparePosition (UITextPosition first, UITextPosition second);
Selector: offsetFromPosition:toPosition:
Method: int GetOffsetFromPosition (UITextPosition fromPosition, UITextPosition toPosition);
Selector: positionWithinRange:farthestInDirection:
Method: UITextPosition GetPositionWithinRange (UITextRange range, UITextLayoutDirection direction);
Selector: characterRangeByExtendingPosition:inDirection:
Method: UITextRange GetCharacterRange (UITextPosition byExtendingPosition, UITextLayoutDirection direction);
Selector: baseWritingDirectionForPosition:inDirection:
Method: UITextWritingDirection GetBaseWritingDirection (UITextPosition forPosition, UITextStorageDirection direction);
Selector: setBaseWritingDirection:forRange:
Method: void SetBaseWritingDirectionforRange (UITextWritingDirection writingDirection, UITextRange range);
Selector: firstRectForRange:
Method: RectangleF GetFirstRectForRange (UITextRange range);
Selector: caretRectForPosition:
Method: RectangleF GetCaretRectForPosition (UITextPosition position);
Selector: closestPositionToPoint:
Method: UITextPosition GetClosestPositionToPoint (PointF point);
Selector: closestPositionToPoint:withinRange:
Method: UITextPosition GetClosestPositionToPoint (PointF point, UITextRange withinRange);
Selector: characterRangeAtPoint:
Method: UITextRange GetCharacterRangeAtPoint (PointF point);
Selector: textStylingAtPosition:inDirection:
Method: NSDictionary GetTextStyling (UITextPosition atPosition, UITextStorageDirection inDirection);
Selector: positionWithinRange:atCharacterOffset:
Method: UITextPosition GetPosition (UITextRange withinRange, int atCharacterOffset);
Selector: characterOffsetOfPosition:withinRange:
Method: int GetCharacterOffsetOfPosition (UITextPosition position, UITextRange range);

Class UITextInputTokenizer

Selector: rangeEnclosingPosition:withGranularity:inDirection:
Method: UITextRange GetRangeEnclosingPosition (UITextPosition position, UITextGranularity granularity, UITextDirection direction);
Selector: isPosition:atBoundary:inDirection:
Method: bool ProbeDirection (UITextPosition probePosition, UITextGranularity atBoundary, UITextDirection inDirection);
Selector: positionFromPosition:toBoundary:inDirection:
Method: UITextPosition GetPosition (UITextPosition fromPosition, UITextGranularity toBoundary, UITextDirection inDirection);
Selector: isPosition:withinTextUnit:inDirection:
Method: bool ProbeDirectionWithinTextUnit (UITextPosition probePosition, UITextGranularity withinTextUnit, UITextDirection inDirection);

Class UITextInputStringTokenizer

Selector: initWithTextInput:
Method: IntPtr Constructor (NSObject /* UITextInput */ textInput);

Class UITextInputDelegate

Selector: selectionWillChange:
Method: void SelectionWillChange (NSObject /* UITextInput */ uiTextInput);
Selector: selectionDidChange:
Method: void SelectionDidChange (NSObject /* UITextInput */ uiTextInput);
Selector: textWillChange:
Method: void TextWillChange (NSObject /* UITextInput */ textInput);
Selector: textDidChange:
Method: void TextDidChange (NSObject /* UITextInput */ textInput);

Class UILocalNotification

Selector: fireDate
Property: NSDate FireDate { get; set; }
Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: repeatInterval
Property: NSCalendarUnit RepeatInterval { get; set; }
Selector: repeatCalendar
Property: NSCalendar RepeatCalendar { get; set; }
Selector: alertBody
Property: string AlertBody { get; set; }
Selector: hasAction
Property: bool HasAction { get; set; }
Selector: alertAction
Property: string AlertAction { get; set; }
Selector: alertLaunchImage
Property: string AlertLaunchImage { get; set; }
Selector: soundName
Property: string SoundName { get; set; }
Selector: applicationIconBadgeNumber
Property: int ApplicationIconBadgeNumber { get; set; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }

Class UILongPressGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: numberOfTouchesRequired
Property: uint NumberOfTouchesRequired { get; set; }
Selector: minimumPressDuration
Property: double MinimumPressDuration { get; set; }
Selector: allowableMovement
Property: float AllowableMovement { get; set; }
Selector: numberOfTapsRequired
Property: int NumberOfTapsRequired { get; set; }

Class UITapGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: numberOfTapsRequired
Property: uint NumberOfTapsRequired { get; set; }
Selector: numberOfTouchesRequired
Property: uint NumberOfTouchesRequired { get; set; }

Class UIPanGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: minimumNumberOfTouches
Property: uint MinimumNumberOfTouches { get; set; }
Selector: maximumNumberOfTouches
Property: uint MaximumNumberOfTouches { get; set; }
Selector: setTranslation:inView:
Method: void SetTranslation (PointF translation, UIView view);
Selector: translationInView:
Method: PointF TranslationInView (UIView view);
Selector: velocityInView:
Method: PointF VelocityInView (UIView view);

Class UIRotationGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: rotation
Property: float Rotation { get; set; }
Selector: velocity
Property: float Velocity { get; set; }

Class UIPinchGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: scale
Property: float Scale { get; set; }
Selector: velocity
Property: float Velocity { get; set; }

Class UISwipeGestureRecognizer

Selector: initWithTarget:action:
Method: IntPtr Constructor (NSObject target, Selector action);
Selector: direction
Property: UISwipeGestureRecognizerDirection Direction { get; set; }
Selector: numberOfTouchesRequired
Property: uint NumberOfTouchesRequired { get; set; }

Class UIActivityIndicatorView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: initWithActivityIndicatorStyle:
Method: IntPtr Constructor (UIActivityIndicatorViewStyle style);
Selector: activityIndicatorViewStyle
Property: UIActivityIndicatorViewStyle ActivityIndicatorViewStyle { get; set; }
Selector: hidesWhenStopped
Property: bool HidesWhenStopped { get; set; }
Selector: startAnimating
Method: void StartAnimating ();
Selector: stopAnimating
Method: void StopAnimating ();
Selector: isAnimating
Property: bool IsAnimating { get; }
Selector: color
Method: [Appearance]

Class UIImage

Selector: initWithContentsOfFile:
Method: IntPtr Constructor (string filename);
Selector: initWithData:
Method: IntPtr Constructor (NSData data);
Selector: size
Property: SizeF Size { get; set; }
Selector: imageNamed:
Method: UIImage FromBundle (string name);
Selector: imageWithContentsOfFile:
Method: UIImage FromFile (string filename);
Selector: imageWithData:
Method: UIImage LoadFromData (NSData data);
Selector: imageWithCGImage:
Method: UIImage FromImage (CGImage image);
Selector: CGImage
Property: CGImage CGImage { get; }
Selector: imageOrientation
Property: UIImageOrientation Orientation { get; }
Selector: drawAtPoint:
Method: void Draw (PointF point);
Selector: drawAtPoint:blendMode:alpha:
Method: void Draw (PointF point, CGBlendMode blendMode, float alpha);
Selector: drawInRect:
Method: void Draw (RectangleF rect);
Selector: drawInRect:blendMode:alpha:
Method: void Draw (RectangleF rect, CGBlendMode blendMode, float alpha);
Selector: drawAsPatternInRect:
Method: void DrawAsPatternInRect (RectangleF rect);
Selector: stretchableImageWithLeftCapWidth:topCapHeight:
Method: UIImage StretchableImage (int leftCapWidth, int topCapHeight);
Selector: leftCapWidth
Property: int LeftCapWidth { get; }
Selector: topCapHeight
Property: int TopCapHeight { get; }
Selector: scale
Property: float CurrentScale { get; }
Selector: animatedImageNamed:duration:
Method: UIImage CreateAnimatedImage (string name, double duration);
Selector: animatedImageWithImages:duration:
Method: UIImage CreateAnimatedImage (UIImage [] images, double duration);
Selector: animatedResizableImageNamed:capInsets:duration:
Method: UIImage CreateAnimatedImage (UIImage [] images, UIEdgeInsets capInsets, double duration);
Selector: initWithCGImage:
Method: IntPtr Constructor (CGImage cgImage);
Selector: initWithCIImage
Method: IntPtr Constructor (CIImage ciImage);
Selector: initWithCGImage:scale:orientation:
Method: IntPtr Constructor (CGImage cgImage, float scale, UIImageOrientation orientation);
Selector: CIImage
Property: CIImage CIImage { get; }
Selector: images
Property: UIImage [] Images { get; }
Selector: duration
Property: double Duration { get; }
Selector: resizableImageWithCapInsets:
Method: UIImage CreateResizableImage (UIEdgeInsets capInsets);
Selector: capInsets
Property: UIEdgeInsets CapInsets { get; }
Selector: initWithImage:
Method: IntPtr Constructor (UIImage image);
Selector: initWithImage:options:
Method: IntPtr Constructor (UIImage image, NSDictionary options);

Class UIEvent

Selector: type
Property: UIEventType Type { get; }
Selector: subtype
Property: UIEventSubtype Subtype { get; }
Selector: timestamp
Property: double Timestamp { get; }
Selector: allTouches
Property: NSSet AllTouches { get; }
Selector: touchesForView:
Method: NSSet TouchesForView (UIView view);
Selector: touchesForWindow:
Method: NSSet TouchesForWindow (UIWindow window);
Selector: touchesForGestureRecognizer:
Method: NSSet TouchesForGestureRecognizer (UIGestureRecognizer window);

Class UIWindow

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: makeKeyAndVisible
Method: void MakeKeyAndVisible ();
Selector: makeKeyWindow
Method: void MakeKeyWindow ();
Selector: becomeKeyWindow
Method: void BecomeKeyWindow ();
Selector: resignKeyWindow
Method: void ResignKeyWindow ();
Selector: keyWindow
Property: bool IsKeyWindow { get; }
Selector: windowLevel
Property: float WindowLevel { get; set; }
Selector: convertPoint:fromWindow:
Method: PointF ConvertPointFromWindow (PointF point, [NullAllowed] UIWindow window);
Selector: convertPoint:toWindow:
Method: PointF ConvertPointToWindow (PointF point, [NullAllowed] UIWindow window);
Selector: convertRect:fromWindow:
Method: RectangleF ConvertRectFromWindow (RectangleF rect, UIWindow window);
Selector: convertRect:toWindow:
Method: RectangleF ConvertRectToWindow (RectangleF rect, UIWindow window);
Selector: sendEvent:
Method: void SendEvent (UIEvent evt);
Selector: rootViewController
Property: UIViewController RootViewController { get; set; }
Selector: screen
Property: UIScreen Screen { get; set; }

Class UIControl

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: selected
Property: bool Selected { [Bind("isSelected")] get; set; }
Selector: highlighted
Property: bool Highlighted { [Bind ("isHighlighted")] get; set; }
Selector: contentVerticalAlignment
Property: UIControlContentVerticalAlignment VerticalAlignment { get; set; }
Selector: contentHorizontalAlignment
Property: UIControlContentHorizontalAlignment HorizontalAlignment { get; set; }
Selector: state
Property: UIControlState State { get; }
Selector: isTracking
Property: bool Tracking { get; }
Selector: isTouchInside
Property: bool TouchInside { get; }
Selector: beginTrackingWithTouch:withEvent:
Method: bool BeginTracking (UITouch uitouch, UIEvent uievent);
Selector: continueTrackingWithTouch:withEvent:
Method: bool ContinueTracking (UITouch uitouch, UIEvent uievent);
Selector: endTrackingWithTouch:withEvent:
Method: void EndTracking (UITouch uitouch, UIEvent uievent);
Selector: cancelTrackingWithEvent:
Method: void CancelTracking (UIEvent uievent);
Selector: addTarget:action:forControlEvents:
Method: void AddTarget ([NullAllowed] NSObject target, Selector sel, UIControlEvent events);
Selector: removeTarget:action:forControlEvents:
Method: void RemoveTarget ([NullAllowed] NSObject target, [NullAllowed] Selector sel, UIControlEvent events);
Selector: allTargets
Property: NSSet AllTargets { get; }
Selector: allControlEvents
Property: UIControlEvent AllControlEvents { get; }
Selector: actionsForTarget:forControlEvent:
Method: string [] GetActions (NSObject target, UIControlEvent events);
Selector: sendAction:to:forEvent:
Method: void SendAction (Selector action, NSObject target, UIEvent uievent);
Selector: sendActionsForControlEvents:
Method: void SendActionForControlEvents (UIControlEvent events);

Class UIBezierPath

Selector: bezierPath
Method: UIBezierPath Create ();
Selector: bezierPathWithArcCenter:radius:startAngle:endAngle:clockwise:
Method: UIBezierPath FromArc (PointF center, float radius, float startAngle, float endAngle, bool clockwise);
Selector: bezierPathWithCGPath:
Method: UIBezierPath FromPath (CGPath path);
Selector: bezierPathWithOvalInRect:
Method: UIBezierPath FromOval (RectangleF inRect);
Selector: bezierPathWithRect:
Method: UIBezierPath FromRect (RectangleF rect);
Selector: bezierPathWithRoundedRect:byRoundingCorners:cornerRadii:
Method: UIBezierPath FromRoundedRect (RectangleF rect, UIRectCorner corners, SizeF radii);
Selector: bezierPathWithRoundedRect:cornerRadius:
Method: UIBezierPath FromRoundedRect (RectangleF rect, float cornerRadius);
Selector: CGPath
Property: CGPath CGPath { get; }
Selector: moveToPoint:
Method: void MoveTo (PointF point);
Selector: addLineToPoint:
Method: void AddLineTo (PointF point);
Selector: addCurveToPoint:controlPoint1:controlPoint2:
Method: void AddCurveToPoint (PointF endPoint, PointF controlPoint1, PointF controlPoint2);
Selector: addQuadCurveToPoint:controlPoint:
Method: void AddQuadCurveToPoint (PointF endPoint, PointF controlPoint);
Selector: closePath
Method: void ClosePath ();
Selector: removeAllPoints
Method: void RemoveAllPoints ();
Selector: appendPath:
Method: void AppendPath (UIBezierPath path);
Selector: applyTransform:
Method: void ApplyTransform (CGAffineTransform transform);
Selector: empty
Property: bool Empty { [Bind ("isEmpty")] get; set; }
Selector: bounds
Property: RectangleF Bounds { get; }
Selector: currentPoint
Property: PointF CurrentPoint { get; }
Selector: containsPoint:
Method: bool ContainsPoint (PointF point);
Selector: lineWidth
Property: float LineWidth { get; set; }
Selector: lineCapStyle
Property: CGLineCap LineCapStyle { get; set; }
Selector: lineJoinStyle
Property: CGLineJoin LineJoinStyle { get; set; }
Selector: miterLimit
Property: float MiterLimit { get; set; }
Selector: flatness
Property: float Flatness { get; set; }
Selector: usesEvenOddFillRule
Property: bool UsesEvenOddFillRule { get; set; }
Selector: fill
Method: void Fill ();
Selector: stroke
Method: void Stroke ();
Selector: fillWithBlendMode:alpha:
Method: void Fill (CGBlendMode blendMode, float alpha);
Selector: strokeWithBlendMode:alpha:
Method: void Stroke (CGBlendMode blendMode, float alpha);
Selector: addClip
Method: void AddClip ();
Selector: addArcWithCenter:radius:startAngle:endAngle:clockwise:
Method: void AddArc (PointF center, float radius, float startAngle, float endAngle, bool clockWise);

Class UIButton

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: buttonWithType:
Method: UIButton FromType (UIButtonType type);
Selector: contentEdgeInsets
Property: UIEdgeInsets ContentEdgeInsets {get;set;}
Selector: titleEdgeInsets
Property: UIEdgeInsets TitleEdgeInsets { get; set; }
Selector: reversesTitleShadowWhenHighlighted
Property: bool ReverseTitleShadowWhenHighlighted { get; set; }
Selector: imageEdgeInsets
Property: UIEdgeInsets ImageEdgeInsets { get; set; }
Selector: adjustsImageWhenHighlighted
Property: bool AdjustsImageWhenHighlighted { get; set; }
Selector: adjustsImageWhenDisabled
Property: bool AdjustsImageWhenDisabled { get; set; }
Selector: showsTouchWhenHighlighted
Property: bool ShowsTouchWhenHighlighted { get; set; }
Selector: buttonType
Property: UIButtonType ButtonType { get; }
Selector: setTitle:forState:
Method: void SetTitle (string title, UIControlState forState);
Selector: setTitleColor:forState:
Method: [Appearance]
Selector: setTitleShadowColor:forState:
Method: [Appearance]
Selector: setImage:forState:
Method: [Appearance]
Selector: setBackgroundImage:forState:
Method: [Appearance]
Selector: titleForState:
Method: string Title (UIControlState state);
Selector: titleColorForState:
Method: [Appearance]
Selector: titleShadowColorForState:
Method: [Appearance]
Selector: imageForState:
Method: [Appearance]
Selector: backgroundImageForState:
Method: UIImage BackgroundImageForState (UIControlState state);
Selector: currentTitle
Property: string CurrentTitle { get; }
Selector: currentTitleColor
Method: [Appearance]
Selector: currentTitleShadowColor
Method: [Appearance]
Selector: currentImage
Method: [Appearance]
Selector: currentBackgroundImage
Method: [Appearance]
Selector: titleLabel
Property: UILabel TitleLabel { get; }
Selector: imageView
Property: UIImageView ImageView { get; }
Selector: backgroundRectForBounds:
Method: RectangleF BackgroundRectForBounds (RectangleF rect);
Selector: contentRectForBounds:
Method: RectangleF ContentRectForBounds (RectangleF rect);
Selector: titleRectForContentRect:
Method: RectangleF TitleRectForContentRect (RectangleF rect);
Selector: imageRectForContentRect:
Method: RectangleF ImageRectForContentRect (RectangleF rect);
Selector: font
Property: UIFont Font { get; set; }
Selector: lineBreakMode
Property: UILineBreakMode LineBreakMode { get; set; }
Selector: titleShadowOffset
Property: SizeF TitleShadowOffset { get; set; }
Selector: tintColor
Method: [Appearance]

Class UILabel

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: text
Property: string Text { get; set; }
Selector: font
Property: UIFont Font { get; set; }
Selector: textColor
Property: UIColor TextColor { get; set; }
Selector: shadowColor
Property: UIColor ShadowColor { get; set;}
Selector: shadowOffset
Property: SizeF ShadowOffset { get; set; }
Selector: textAlignment
Property: UITextAlignment TextAlignment { get; set; }
Selector: lineBreakMode
Property: UILineBreakMode LineBreakMode { get; set; }
Selector: highlightedTextColor
Property: UIColor HighlightedTextColor { get; set; }
Selector: highlighted
Property: bool Highlighted { [Bind ("isHighlighted")] get; set; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: numberOfLines
Property: int Lines { get; set; }
Selector: adjustsFontSizeToFitWidth
Property: bool AdjustsFontSizeToFitWidth { get; set; }
Selector: minimumFontSize
Property: float MinimumFontSize { get; set; }
Selector: baselineAdjustment
Property: UIBaselineAdjustment BaselineAdjustment { get; set; }
Selector: textRectForBounds:limitedToNumberOfLines:
Method: RectangleF TextRectForBounds (RectangleF bounds, int numberOfLines);
Selector: drawTextInRect:
Method: void DrawText (RectangleF rect);

Class UIImageView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: initWithImage:
Method: IntPtr Constructor (UIImage image);
Selector: initWithImage:highlightedImage:
Method: IntPtr Constructor (UIImage image, UIImage highlightedImage);
Selector: image
Property: UIImage Image { get; set; }
Selector: highlightedImage
Property: UIImage HighlightedImage { get; set; }
Selector: highlighted
Property: bool Highlighted { [Bind ("isHighlighted")] get; set; }
Selector: animationImages
Property: UIImage [] AnimationImages { get; set; }
Selector: highlightedAnimationImages
Property: UIImage [] HighlightedAnimationImages { get; set; }
Selector: animationDuration
Property: double AnimationDuration { get; set; }
Selector: animationRepeatCount
Property: int AnimationRepeatCount { get; set; }
Selector: startAnimating
Method: void StartAnimating ();
Selector: stopAnimating
Method: void StopAnimating ();
Selector: isAnimating
Property: bool IsAnimating { get; }

Class UIDatePicker

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: datePickerMode
Property: UIDatePickerMode Mode { get; set; }
Selector: locale
Property: NSLocale Locale { get; set; }
Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: calendar
Property: NSCalendar Calendar { get; set; }
Selector: date
Property: NSDate Date { get; set; }
Selector: minimumDate
Property: NSDate MinimumDate { get; set; }
Selector: maximumDate
Property: NSDate MaximumDate { get; set; }
Selector: countDownDuration
Property: double CountDownDuration { get; set; }
Selector: minuteInterval
Property: int MinuteInterval { get; set; }
Selector: setDate:animated:
Method: void SetDate (NSDate date, bool animated);

Class UIDevice

Selector: currentDevice
Property: UIDevice CurrentDevice { get; }
Selector: name
Property: string Name { get; }
Selector: model
Property: string Model { get; }
Selector: localizedModel
Property: string LocalizedModel { get; }
Selector: systemName
Property: string SystemName { get; }
Selector: systemVersion
Property: string SystemVersion { get; }
Selector: orientation
Property: UIDeviceOrientation Orientation { get; }
Selector: uniqueIdentifier
Property: string UniqueIdentifier { get; }
Selector: generatesDeviceOrientationNotifications
Property: bool GeneratesDeviceOrientationNotifications { [Bind ("isGeneratingDeviceOrientationNotifications")] get; }
Selector: beginGeneratingDeviceOrientationNotifications
Method: void BeginGeneratingDeviceOrientationNotifications ();
Selector: endGeneratingDeviceOrientationNotifications
Method: void EndGeneratingDeviceOrientationNotifications ();
Selector: batteryMonitoringEnabled
Property: bool BatteryMonitoringEnabled { [Bind ("isBatteryMonitoringEnabled")] get; set; }
Selector: batteryState
Property: UIDeviceBatteryState BatteryState { get; }
Selector: batteryLevel
Property: float BatteryLevel { get; }
Selector: proximityMonitoringEnabled
Property: bool ProximityMonitoringEnabled { [Bind ("isProximityMonitoringEnabled")] get; set; }
Selector: proximityState
Property: bool ProximityState { get; }
Selector: userInterfaceIdiom
Property: UIUserInterfaceIdiom _UserInterfaceIdiom { get; }
Selector: isMultitaskingSupported
Property: bool _IsMultitaskingSupported { get; }
Selector: playInputClick
Method: void PlayInputClick ();

Class UIDocumentInteractionController

Selector: interactionControllerWithURL:
Method: UIDocumentInteractionController FromUrl (NSUrl url);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: URL
Property: NSUrl Url { get; set; }
Selector: UTI
Property: string Uti { get; set; }
Selector: annotation
Property: NSObject Annotation { get; set; }
Selector: name
Property: string Name { get; set; }
Selector: icons
Property: UIImage[] Icons { get; }
Selector: dismissMenuAnimated:
Method: void DismissMenu (bool animated);
Selector: dismissPreviewAnimated:
Method: void DimissPreview (bool animated);
Selector: presentOpenInMenuFromBarButtonItem:animated:
Method: bool PresentOpenInMenu (UIBarButtonItem item, bool animated);
Selector: presentOpenInMenuFromRect:inView:animated:
Method: bool PresentOpenInMenu (RectangleF rect, UIView inView, bool animated);
Selector: presentOptionsMenuFromBarButtonItem:animated:
Method: bool PresentOptionsMenu (UIBarButtonItem item, bool animated);
Selector: presentOptionsMenuFromRect:inView:animated:
Method: bool PresentOptionsMenu (RectangleF rect, UIView inView, bool animated);
Selector: presentPreviewAnimated:
Method: bool PresentPreview (bool animated);
Selector: gestureRecognizers
Property: UIGestureRecognizer [] GestureRecognizers { get; set; }

Class UIDocumentInteractionControllerDelegate

Selector: documentInteractionController:canPerformAction:"), DelegateName ("UIDocumentInteractionProbe
Method: bool CanPerformAction (UIDocumentInteractionController controller, Selector action);
Selector: documentInteractionController:performAction:"), DelegateName ("UIDocumentInteractionProbe
Method: bool PerformAction (UIDocumentInteractionController controller, Selector action);
Selector: documentInteractionController:didEndSendingToApplication:
Method: void DidEndSendingToApplication (UIDocumentInteractionController controller);
Selector: documentInteractionController:willBeginSendingToApplication:
Method: void WillBeginSendingToApplication (UIDocumentInteractionController controller);
Selector: documentInteractionControllerDidDismissOpenInMenu:
Method: void DidDismissOpenInMenu (UIDocumentInteractionController controller);
Selector: documentInteractionControllerDidDismissOptionsMenu:
Method: void DidDismissOptionsMenu (UIDocumentInteractionController controller);
Selector: documentInteractionControllerDidEndPreview:
Method: void DidEndPreview (UIDocumentInteractionController controller);
Selector: documentInteractionControllerRectForPreview:"), DelegateName ("UIDocumentInteractionRectangle
Method: RectangleF RectangleForPreview (UIDocumentInteractionController controller);
Selector: documentInteractionControllerViewControllerForPreview:"), DelegateName ("UIDocumentViewController
Method: UIViewController ViewControllerForPreview (UIDocumentInteractionController controller);
Selector: documentInteractionControllerViewForPreview:"), DelegateName ("UIDocumentViewForPreview
Method: UIView ViewForPreview (UIDocumentInteractionController controller);
Selector: documentInteractionControllerWillBeginPreview:
Method: void WillBeginPreview (UIDocumentInteractionController controller);
Selector: documentInteractionControllerWillPresentOpenInMenu:
Method: void WillPresentOpenInMenu (UIDocumentInteractionController controller);
Selector: documentInteractionControllerWillPresentOptionsMenu:
Method: void WillPresentOptionsMenu (UIDocumentInteractionController controller);

Class UIImagePickerController

Selector: isSourceTypeAvailable:
Method: bool IsSourceTypeAvailable (UIImagePickerControllerSourceType sourceType);
Selector: availableMediaTypesForSourceType:
Method: string [] AvailableMediaTypes (UIImagePickerControllerSourceType sourceType);
Selector: delegate
Property: NSObject Delegate { get; set; }
Selector: sourceType
Property: UIImagePickerControllerSourceType SourceType { get; set; }
Selector: mediaTypes
Property: string [] MediaTypes { get; set; }
Selector: allowsImageEditing
Property: bool AllowsImageEditing { get; set; }
Selector: allowsEditing
Property: bool AllowsEditing { get; set; }
Selector: videoMaximumDuration
Property: double VideoMaximumDuration { get; set; }
Selector: videoQuality
Property: UIImagePickerControllerQualityType VideoQuality { get; set; }
Selector: showsCameraControls
Property: bool ShowsCameraControls { get; set; }
Selector: cameraOverlayView
Property: UIView CameraOverlayView { get; set; }
Selector: cameraViewTransform
Property: CGAffineTransform CameraViewTransform { get; set; }
Selector: takePicture
Method: void TakePicture ();
Selector: startVideoCapture
Method: bool StartVideoCapture ();
Selector: stopVideoCapture
Method: bool StopVideoCapture ();
Selector: cameraCaptureMode
Property: UIImagePickerControllerCameraCaptureMode CameraCaptureMode { get; set; }
Selector: availableCaptureModesForCameraDevice:
Method: NSNumber [] AvailableCaptureModesForCameraDevice (UIImagePickerControllerCameraDevice cameraDevice);
Selector: cameraDevice
Property: UIImagePickerControllerCameraDevice CameraDevice { get; set; }
Selector: cameraFlashMode
Property: UIImagePickerControllerCameraFlashMode CameraFlashMode { get; set; }
Selector: isCameraDeviceAvailable:
Method: bool IsCameraDeviceAvailable (UIImagePickerControllerCameraDevice cameraDevice);
Selector: isFlashAvailableForCameraDevice:
Method: bool IsFlashAvailableForCameraDevice (UIImagePickerControllerCameraDevice cameraDevice);

Class UIImagePickerControllerDelegate

Selector: imagePickerController:didFinishPickingImage:editingInfo:"), EventArgs ("UIImagePickerImagePicked
Method: void FinishedPickingImage (UIImagePickerController picker, UIImage image, NSDictionary editingInfo);
Selector: imagePickerController:didFinishPickingMediaWithInfo:"), EventArgs ("UIImagePickerMediaPicked
Method: void FinishedPickingMedia (UIImagePickerController picker, NSDictionary info);
Selector: imagePickerControllerDidCancel:"), EventArgs ("UIImagePickerController
Method: void Canceled (UIImagePickerController picker);

Class UIManagedDocument

Selector: managedObjectContext
Property: NSManagedObjectContext ManagedObjectContext { get; }
Selector: managedObjectModel
Property: NSManagedObjectModel ManagedObjectModel { get; }
Selector: persistentStoreOptions
Property: NSDictionary PersistentStoreOptions { get; set; }
Selector: modelConfiguration
Property: string ModelConfiguration { get; set; }
Selector: persistentStoreName
Property: string PersistentStoreName { get; }
Selector: configurePersistentStoreCoordinatorForURL:ofType:modelConfiguration:storeOptions:error:
Method: bool ConfigurePersistentStoreCoordinator (NSUrl storeURL, string fileType, string configuration, NSDictionary storeOptions, NSError error);
Selector: persistentStoreTypeForFileType:
Method: string GetPersistentStoreType (string fileType);
Selector: readAdditionalContentFromURL:error:
Method: bool ReadAdditionalContent (NSUrl absoluteURL, out NSError error);
Selector: additionalContentForURL:error:
Method: NSObject AdditionalContent (NSUrl absoluteURL, out NSError error);
Selector: writeAdditionalContent:toURL:originalContentsURL:error:
Method: bool WriteAdditionalContent (NSObject content, NSUrl absoluteURL, NSUrl absoluteOriginalContentsURL, out NSError error);

Class UIMenuController

Selector: sharedMenuController
Property: UIMenuController SharedMenuController { get; }
Selector: menuVisible
Property: bool MenuVisible { [Bind ("isMenuVisible")] get; set; }
Selector: setMenuVisible:animated:
Method: void SetMenuVisible (bool visible, bool animated);
Selector: setTargetRect:inView:
Method: void SetTargetRect (RectangleF rect, UIView inView);
Selector: update
Method: void Update ();
Selector: menuFrame
Property: RectangleF MenuFrame { get; }
Selector: arrowDirection
Property: UIMenuControllerArrowDirection ArrowDirection { get; set; }
Selector: menuItems
Property: UIMenuItem [] MenuItems { get; set; }

Class UIMenuItem

Selector: initWithTitle:action:
Method: IntPtr Constructor (string title, Selector action);
Selector: title
Property: string Title { get; set; }
Selector: action
Property: Selector Action { get; set; }

Class UINavigationBar

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: barStyle
Property: UIBarStyle BarStyle { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: tintColor
Method: [Appearance]
Selector: translucent
Property: bool Translucent { [Bind ("isTranslucent")] get; set; }
Selector: pushNavigationItem:animated:")][PostGet ("Items
Method: void PushNavigationItem (UINavigationItem item, bool animated);
Selector: popNavigationItemAnimated:")][PostGet ("Items
Method: UINavigationItem PopNavigationItemAnimated (bool animated);
Selector: topItem
Property: UINavigationItem TopItem { get; }
Selector: backItem
Property: UINavigationItem BackItem { get; }
Selector: items
Property: UINavigationItem [] Items { get; }
Selector: setItems:animated:")][PostGet ("Items
Method: void SetItems (UINavigationItem [] items, bool animated);
Selector: titleTextAttributes
Method: [Appearance]
Selector: setBackgroundImage:forBarMetrics:
Method: [Appearance]
Selector: backgroundImageForBarMetrics:
Method: [Appearance]
Selector: setTitleVerticalPositionAdjustment:forBarMetrics:
Method: [Appearance]
Selector: titleVerticalPositionAdjustmentForBarMetrics:
Method: [Appearance]

Class UINavigationBarDelegate

Selector: navigationBar:didPopItem:
Method: void DidPopItem (UINavigationBar navigationBar, UINavigationItem item);
Selector: navigationBar:shouldPopItem:
Method: bool ShouldPopItem (UINavigationBar navigationBar, UINavigationItem item);
Selector: navigationBar:didPushItem:
Method: void DidPushItem (UINavigationBar navigationBar, UINavigationItem item);
Selector: navigationBar:shouldPushItem:
Method: bool ShouldPushItem (UINavigationBar navigationBar, UINavigationItem item);

Class UINavigationItem

Selector: initWithTitle:
Method: IntPtr Constructor (string title);
Selector: title
Property: string Title { get; set; }
Selector: backBarButtonItem
Property: UIBarButtonItem BackBarButtonItem { get; set; }
Selector: titleView
Property: UIView TitleView { get; [NullAllowed] set; }
Selector: prompt
Property: string Prompt { get; set; }
Selector: hidesBackButton
Property: bool HidesBackButton { get; set; }
Selector: setHidesBackButton:animated:
Method: void SetHidesBackButton (bool hides, bool animated);
Selector: leftBarButtonItem
Property: UIBarButtonItem LeftBarButtonItem { get; set; }
Selector: rightBarButtonItem
Property: UIBarButtonItem RightBarButtonItem { get; set; }
Selector: setLeftBarButtonItem:animated:")][PostGet ("LeftBarButtonItem
Method: void SetLeftBarButtonItem ([NullAllowed] UIBarButtonItem item, bool animated);
Selector: setRightBarButtonItem:animated:")][PostGet ("RightBarButtonItem
Method: void SetRightBarButtonItem ([NullAllowed] UIBarButtonItem item, bool animated);
Selector: leftBarButtonItems
Property: UIBarButtonItem [] LeftBarButtonItems { get; set; }
Selector: rightBarButtonItems
Property: UIBarButtonItem [] RightBarButtonItems { get; set; }
Selector: leftItemsSupplementBackButton
Property: bool LeftItemsSupplementBackButton { get; set; }
Selector: setLeftBarButtonItems:animated:
Method: void SetLeftBarButtonItems (UIBarButtonItem [] items, bool animated);
Selector: setRightBarButtonItems:animated:
Method: void SetRightBarButtonItems (UIBarButtonItem [] items, bool animated);

Class UINavigationController

Selector: initWithNibName:bundle:
Method: IntPtr Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
Selector: initWithRootViewController:
Method: IntPtr Constructor (UIViewController rootViewController);
Selector: pushViewController:animated:")][PostGet ("ViewControllers
Method: void PushViewController (UIViewController viewController, bool animated);
Selector: popViewControllerAnimated:")][PostGet ("ViewControllers
Method: UIViewController PopViewControllerAnimated (bool animated);
Selector: popToViewController:animated:")][PostGet ("ViewControllers
Method: UIViewController [] PopToViewController (UIViewController viewController, bool animated);
Selector: popToRootViewControllerAnimated:")][PostGet ("ViewControllers
Method: UIViewController [] PopToRootViewController (bool animated);
Selector: topViewController", ArgumentSemantic.Retain)][PostGet ("ViewControllers
Property: UIViewController TopViewController { get; set; }
Selector: visibleViewController", ArgumentSemantic.Retain)][PostGet ("ViewControllers
Property: UIViewController VisibleViewController { get; set; }
Selector: viewControllers
Property: UIViewController [] ViewControllers { get; set; }
Selector: setViewControllers:animated:")][PostGet ("ViewControllers
Method: void SetViewControllers (UIViewController [] controllers, bool animated);
Selector: navigationBarHidden
Property: bool NavigationBarHidden { [Bind ("isNavigationBarHidden")] get ; set; }
Selector: setNavigationBarHidden:animated:
Method: void SetNavigationBarHidden (bool hidden, bool animated);
Selector: navigationBar
Property: UINavigationBar NavigationBar { get; }
Selector: toolbarHidden
Property: bool ToolbarHidden { [Bind ("isToolbarHidden")] get; set; }
Selector: setToolbarHidden:animated:
Method: void SetToolbarHidden (bool hidden, bool animated);
Selector: toolbar
Property: UIToolbar Toolbar { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class UINavigationControllerDelegate

Selector: navigationController:willShowViewController:animated:"), EventArgs ("UINavigationController
Method: void WillShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);
Selector: navigationController:didShowViewController:animated:"), EventArgs ("UINavigationController
Method: void DidShowViewController (UINavigationController navigationController, UIViewController viewController, bool animated);

Class UINib

Selector: nibWithNibName:bundle:
Method: UINib FromName (string name, NSBundle bundleOrNil);
Selector: nibWithData:bundle:
Method: UINib FromData (NSData data, NSBundle bundleOrNil);
Selector: instantiateWithOwner:options:
Method: NSObject [] InstantiateWithOwneroptions (NSObject ownerOrNil, NSDictionary optionsOrNil);

Class UIPageControl

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: numberOfPages
Property: int Pages { get; set; }
Selector: currentPage
Property: int CurrentPage { get; set; }
Selector: hidesForSinglePage
Property: bool HidesForSinglePage { get; set; }
Selector: defersCurrentPageDisplay
Property: bool DefersCurrentPageDisplay { get; set; }
Selector: updateCurrentPageDisplay
Method: void UpdateCurrentPageDisplay ();
Selector: sizeForNumberOfPages:
Method: SizeF SizeForNumberOfPages (int pageCount);

Class UIPageViewController

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: dataSource
Property: NSObject WeakDataSource { get; set; }
Selector: transitionStyle
Property: UIPageViewControllerTransitionStyle TransitionStyle { get; }
Selector: navigationOrientation
Property: UIPageViewControllerNavigationOrientation NavigationOrientation { get; }
Selector: spineLocation
Property: UIPageViewControllerSpineLocation SpineLocation { get; }
Selector: doubleSided
Property: bool DoubleSided { [Bind ("isDoubleSided")] get; set; }
Selector: gestureRecognizers
Property: UIGestureRecognizer [] GestureRecognizers { get; }
Selector: viewControllers
Property: UIViewController [] ViewControllers { get; }
Selector: initWithTransitionStyle:navigationOrientation:options:
Method: IntPtr Constructor (UIPageViewControllerTransitionStyle style, UIPageViewControllerNavigationOrientation navigationOrientation, NSDictionary options);
Selector: setViewControllers:direction:animated:completion:
Method: void SetViewControllers (UIViewController [] viewControllers, UIPageViewControllerNavigationDirection direction, bool animated, UICompletionHandler completionHandler);

Class UIPageViewControllerDelegate

Selector: pageViewController:didFinishAnimating:previousViewControllers:transitionCompleted:"), EventArgs ("UIPageViewFinishedAnimation
Method: void DidFinishAnimating (UIPageViewController pageViewController, bool finished, UIViewController [] previousViewControllers, bool completed);
Selector: pageViewController:spineLocationForInterfaceOrientation:"), DelegateName ("UIPageViewSpineLocationCallback
Method: [DefaultValue(UIPageViewControllerSpineLocation.Mid)]

Class UIPageViewControllerDataSource

Selector: pageViewController:viewControllerBeforeViewController:"), DelegateName ("UIPageViewGetViewController
Method: UIViewController GetPreviousViewController (UIPageViewController pageViewController, UIViewController referenceViewController);
Selector: pageViewController:viewControllerAfterViewController:"), DelegateName ("UIPageViewGetViewController
Method: UIViewController GetNextViewController (UIPageViewController pageViewController, UIViewController referenceViewController);

Class UIPasteboard

Selector: generalPasteboard
Property: UIPasteboard General { get; }
Selector: pasteboardWithName:create:
Method: UIPasteboard FromName (string name, bool create);
Selector: pasteboardWithUniqueName
Method: UIPasteboard GetUnique ();
Selector: name
Property: string Name { get; set; }
Selector: removePasteboardWithName:
Method: void Remove (string name);
Selector: persistent
Property: bool Persistent { [Bind ("isPersistent")] get; set; }
Selector: changeCount
Property: int ChangeCount { get; }
Selector: pasteboardTypes
Property: string [] Types { get; }
Selector: containsPasteboardTypes:
Method: bool Contains (string [] pasteboardTypes);
Selector: dataForPasteboardType:
Method: NSData DataForPasteboardType (string pasteboardType);
Selector: valueForPasteboardType:
Method: NSObject GetValue (string pasteboardType);
Selector: setValue:forPasteboardType:
Method: void SetValue (NSObject value, string pasteboardType);
Selector: setData:forPasteboardType:
Method: void SetData (NSData data, string forPasteboardType);
Selector: numberOfItems
Property: int Count { get; }
Selector: pasteboardTypesForItemSet:
Method: NSArray [] PasteBoardTypesForSet (NSIndexSet itemSet);
Selector: containsPasteboardTypes:inItemSet:
Method: bool Contains (string [] pasteboadTypes, NSIndexSet itemSet);
Selector: itemSetWithPasteboardTypes:
Method: NSIndexSet ItemSetWithPasteboardTypes (string [] pasteboardTypes);
Selector: valuesForPasteboardType:inItemSet:
Method: NSData [] GetValuesForPasteboardType (string pasteboardType, NSIndexSet itemSet);
Selector: dataForPasteboardType:inItemSet:
Method: NSData [] GetDataForPasteboardType (string pasteboardType, NSIndexSet itemSet);
Selector: items
Property: NSDictionary [] Items { get; set; }
Selector: addItems:
Method: void AddItems (NSDictionary [] items);
Selector: string
Property: string String { get; set; }
Selector: strings
Property: string [] Strings { get; set; }
Selector: URL
Property: NSUrl Url { get; set; }
Selector: URLs
Property: NSUrl [] Urls { get; set; }
Selector: image
Property: UIImage Image { get; set; }
Selector: images
Property: UIImage [] Images { get; set; }
Selector: color
Property: UIColor Color { get; set; }
Selector: colors
Property: UIColor [] Colors { get; set; }

Class UIPickerView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: dataSource
Property: NSObject DataSource { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: showsSelectionIndicator
Property: bool ShowSelectionIndicator { get; set; }
Selector: numberOfComponents
Property: int NumberOfComponents { get; }
Selector: numberOfRowsInComponent:
Method: int RowsInComponent (int component);
Selector: rowSizeForComponent:
Method: SizeF RowSizeForComponent (int component);
Selector: viewForRow:forComponent:
Method: UIView ViewFor (int row, int component);
Selector: reloadAllComponents
Method: void ReloadAllComponents ();
Selector: reloadComponent:
Method: void ReloadComponent (int component);
Selector: selectRow:inComponent:animated:
Method: void Select (int row, int component, bool animated);
Selector: selectedRowInComponent:
Method: int SelectedRowInComponent (int component);

Class UIPickerViewDelegate

Selector: pickerView:rowHeightForComponent:
Method: float GetRowHeight (UIPickerView pickerView, int component);
Selector: pickerView:widthForComponent:
Method: float GetComponentWidth (UIPickerView pickerView, int component);
Selector: pickerView:titleForRow:forComponent:
Method: string GetTitle (UIPickerView pickerView, int row, int component);
Selector: pickerView:viewForRow:forComponent:reusingView:
Method: UIView GetView (UIPickerView pickerView, int row, int component, UIView view);
Selector: pickerView:didSelectRow:inComponent:
Method: void Selected (UIPickerView pickerView, int row, int component);

Class UIPickerViewDataSource

Selector: numberOfComponentsInPickerView:
Method: [Abstract]
Selector: pickerView:numberOfRowsInComponent:
Method: [Abstract]

Class UIProgressView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: initWithProgressViewStyle:
Method: IntPtr Constructor (UIProgressViewStyle style);
Selector: progressViewStyle
Property: UIProgressViewStyle Style { get; set; }
Selector: progress
Property: float Progress { get; set; }
Selector: progressTintColor
Method: [Appearance]
Selector: trackTintColor
Method: [Appearance]
Selector: progressImage
Method: [Appearance]
Selector: trackImage
Method: [Appearance]
Selector: setProgress:animated:
Method: void SetProgress (float progress, bool animated);

Class UIReferenceLibraryViewController

Selector: dictionaryHasDefinitionForTerm
Method: bool DictionaryHasDefinitionForTerm (string term);
Selector: initWithTerm
Method: IntPtr Constructor (string term);

Class UIResponder

Selector: nextResponder
Property: UIResponder NextResponder { get; }
Selector: canBecomeFirstResponder
Property: bool CanBecomeFirstResponder { get; }
Selector: becomeFirstResponder
Method: bool BecomeFirstResponder ();
Selector: canResignFirstResponder
Property: bool CanResignFirstResponder { get; }
Selector: resignFirstResponder
Method: bool ResignFirstResponder ();
Selector: isFirstResponder
Property: bool IsFirstResponder { get; }
Selector: touchesBegan:withEvent:
Method: void TouchesBegan (NSSet touches, UIEvent evt);
Selector: touchesMoved:withEvent:
Method: void TouchesMoved (NSSet touches, UIEvent evt);
Selector: touchesEnded:withEvent:
Method: void TouchesEnded (NSSet touches, UIEvent evt);
Selector: touchesCancelled:withEvent:
Method: void TouchesCancelled (NSSet touches, UIEvent evt);
Selector: motionBegan:withEvent:
Method: void MotionBegan (UIEventSubtype motion, UIEvent evt);
Selector: motionEnded:withEvent:
Method: void MotionEnded (UIEventSubtype motion, UIEvent evt);
Selector: motionCancelled:withEvent:
Method: void MotionCancelled (UIEventSubtype motion, UIEvent evt);
Selector: canPerformAction:withSender:
Method: bool CanPerform (Selector action, [NullAllowed] NSObject withSender);
Selector: undoManager
Property: NSUndoManager UndoManager { get; }
Selector: inputAccessoryView
Property: UIView InputAccessoryView { get; }
Selector: inputView
Property: UIView InputView { get; }
Selector: reloadInputViews
Method: void ReloadInputViews ();
Selector: remoteControlReceivedWithEvent:
Method: void RemoteControlReceived (UIEvent theEvent);
Selector: cut:
Method: void Cut (NSObject sender);
Selector: copy:
Method: void Copy (NSObject sender);
Selector: paste:
Method: void Paste (NSObject sender);
Selector: select:
Method: void Select (NSObject sender);
Selector: selectAll:
Method: void SelectAll (NSObject sender);
Selector: delete:
Method: void Delete (NSObject sender);
Selector: makeTextWritingDirectionLeftToRight:
Method: void MakeTextWritingDirectionLeftToRight ();
Selector: makeTextWritingDirectionRightToLeft:
Method: void MakeTextWritingDirectionRightToLeft ();

Class UIScreen

Selector: bounds
Property: RectangleF Bounds { get; }
Selector: applicationFrame
Property: RectangleF ApplicationFrame { get; }
Selector: mainScreen
Property: UIScreen MainScreen { get; }
Selector: availableModes
Property: UIScreenMode [] AvailableModes { get; }
Selector: currentMode
Property: UIScreenMode CurrentMode { get; set; }
Selector: preferredMode
Property: UIScreenMode PreferredMode { get; }
Selector: mirroredScreen
Property: UIScreen MirroredScreen { get; }
Selector: screens
Property: UIScreen [] Screens { get; }
Selector: scale
Property: float Scale { get; }
Selector: displayLinkWithTarget:selector:
Method: MonoTouch.CoreAnimation.CADisplayLink CreateDisplayLink (NSObject target, Selector sel);
Selector: brightness
Property: float Brightness { get; set; }
Selector: wantsSoftwareDimming
Property: bool WantsSoftwareDimming { get; set; }
Selector: overscanCompensation
Property: UIScreenOverscanCompensation OverscanCompensation { get; set; }

Class UIScrollView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: contentOffset
Property: PointF ContentOffset { get; set; }
Selector: contentSize
Property: SizeF ContentSize { get; set; }
Selector: contentInset
Property: UIEdgeInsets ContentInset { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: bounces
Property: bool Bounces { get; set; }
Selector: alwaysBounceVertical
Property: bool AlwaysBounceVertical { get; set; }
Selector: alwaysBounceHorizontal
Property: bool AlwaysBounceHorizontal { get; set; }
Selector: showsHorizontalScrollIndicator
Property: bool ShowsHorizontalScrollIndicator { get; set; }
Selector: showsVerticalScrollIndicator
Property: bool ShowsVerticalScrollIndicator { get; set; }
Selector: scrollIndicatorInsets
Property: UIEdgeInsets ScrollIndicatorInsets { get; set; }
Selector: indicatorStyle
Property: UIScrollViewIndicatorStyle IndicatorStyle { get; set; }
Selector: decelerationRate
Property: float DecelerationRate { get; set; }
Selector: pagingEnabled
Property: bool PagingEnabled { [Bind ("isPagingEnabled")] get; set; }
Selector: directionalLockEnabled
Property: bool DirectionalLockEnabled { [Bind ("isDirectionalLockEnabled")] get; set; }
Selector: scrollEnabled
Property: bool ScrollEnabled { [Bind ("isScrollEnabled")] get; set; }
Selector: tracking
Property: bool Tracking { [Bind("isTracking")] get; set; }
Selector: dragging
Property: bool Dragging { [Bind ("isDragging")] get; set; }
Selector: decelerating
Property: bool Decelerating { [Bind ("isDecelerating")] get; set; }
Selector: setContentOffset:animated:
Method: void SetContentOffset (PointF contentOffset, bool animated);
Selector: scrollRectToVisible:animated:
Method: void ScrollRectToVisible (RectangleF rect, bool animated);
Selector: flashScrollIndicators
Method: void FlashScrollIndicators ();
Selector: delaysContentTouches
Property: bool DelaysContentTouches { get; set; }
Selector: canCancelContentTouches
Property: bool CanCancelContentTouches { get; set; }
Selector: touchesShouldBegin:withEvent:inContentView:
Method: bool TouchesShouldBegin (NSSet touches, UIEvent withEvent, UIView inContentView);
Selector: touchesShouldCancelInContentView:
Method: bool TouchesShouldCancelInContentView (UIView view);
Selector: minimumZoomScale
Property: float MinimumZoomScale { get; set; }
Selector: maximumZoomScale
Property: float MaximumZoomScale { get; set; }
Selector: zoomScale
Property: float ZoomScale { get; set; }
Selector: setZoomScale:animated:
Method: void SetZoomScale (float scale, bool animated);
Selector: zoomToRect:animated:
Method: void ZoomToRect (RectangleF rect, bool animated);
Selector: bouncesZoom
Property: bool BouncesZoom { get; set; }
Selector: zooming
Property: bool Zooming { [Bind ("isZooming")] get; set; }
Selector: zoomBouncing
Property: bool ZoomBouncing { [Bind ("isZoomBouncing")] get; set; }
Selector: scrollsToTop
Property: bool ScrollsToTop { get; set; }
Selector: panGestureRecognizer
Property: UIPanGestureRecognizer PanGestureRecognizer { get; }
Selector: pinchGestureRecognizer
Property: UIPinchGestureRecognizer PinchGestureRecognizer { get; }

Class UIScrollViewDelegate

Selector: scrollViewDidScroll:"), EventArgs ("UIScrollView
Method: void Scrolled (UIScrollView scrollView);
Selector: scrollViewWillBeginDragging:"), EventArgs ("UIScrollView
Method: void DraggingStarted (UIScrollView scrollView);
Selector: scrollViewDidEndDragging:willDecelerate:"), EventArgs ("Dragging
Method: void DraggingEnded (UIScrollView scrollView, [EventName ("decelerate")] bool willDecelerate);
Selector: scrollViewWillBeginDecelerating:"), EventArgs ("UIScrollView
Method: void DecelerationStarted (UIScrollView scrollView);
Selector: scrollViewDidEndDecelerating:"), EventArgs ("UIScrollView
Method: void DecelerationEnded (UIScrollView scrollView);
Selector: scrollViewDidEndScrollingAnimation:"), EventArgs ("UIScrollView
Method: void ScrollAnimationEnded (UIScrollView scrollView);
Selector: viewForZoomingInScrollView:"), DelegateName ("UIScrollViewGetZoomView"), DefaultValue ("null
Method: UIView ViewForZoomingInScrollView (UIScrollView scrollView);
Selector: scrollViewShouldScrollToTop:"), DelegateName ("UIScrollViewCondition"), DefaultValue ("true
Method: bool ShouldScrollToTop (UIScrollView scrollView);
Selector: scrollViewDidScrollToTop:"), EventArgs ("UIScrollView
Method: void ScrolledToTop (UIScrollView scrollView);
Selector: scrollViewDidEndZooming:withView:atScale:"), EventArgs ("ZoomingEnded
Method: void ZoomingEnded (UIScrollView scrollView, UIView withView, float atScale);
Selector: scrollViewDidZoom:"), EventArgs ("UIScrollView
Method: void DidZoom (UIScrollView scrollView);
Selector: scrollViewWillBeginZooming:withView:"), EventArgs ("UIScrollViewZooming
Method: void ZoomingStarted (UIScrollView scrollView, UIView view);
Selector: scrollViewWillEndDragging:withVelocity:targetContentOffset:"), EventArgs ("WillEndDragging
Method: void WillEndDragging (UIScrollView scrollView, PointF velocity, ref PointF targetContentOffset);

Class UISearchBar

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: barStyle
Property: UIBarStyle BarStyle { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: text
Property: string Text { get; set; }
Selector: prompt
Property: string Prompt { get; set; }
Selector: placeholder
Property: string Placeholder { get; set; }
Selector: showsBookmarkButton
Property: bool ShowsBookmarkButton { get; set; }
Selector: showsCancelButton
Property: bool ShowsCancelButton { get; set; }
Selector: tintColor
Property: UIColor TintColor { get; [NullAllowed] set; }
Selector: selectedScopeButtonIndex
Property: int SelectedScopeButtonIndex { get; set; }
Selector: showsScopeBar
Property: bool ShowsScopeBar { get; set; }
Selector: autocapitalizationType
Property: UITextAutocapitalizationType AutocapitalizationType { get; set; }
Selector: autocorrectionType
Property: UITextAutocorrectionType AutocorrectionType { get; set; }
Selector: keyboardType
Property: UIKeyboardType KeyboardType { get; set; }
Selector: scopeButtonTitles
Property: string [] ScopeButtonTitles { get; set; }
Selector: translucent
Property: bool Translucent { [Bind ("isTranslucent")] get; set; }
Selector: setShowsCancelButton:animated:
Method: void SetShowsCancelButton (bool showsCancelButton, bool animated);
Selector: searchResultsButtonSelected
Property: bool SearchResultsButtonSelected { [Bind ("isSearchResultsButtonSelected")] get; set; }
Selector: showsSearchResultsButton
Property: bool ShowsSearchResultsButton { get; set; }
Selector: backgroundImage
Method: [Appearance]
Selector: scopeBarBackgroundImage
Method: [Appearance]
Selector: searchFieldBackgroundPositionAdjustment
Property: UIOffset SearchFieldBackgroundPositionAdjustment { get; set; }
Selector: searchTextPositionAdjustment
Property: UIOffset SearchTextPositionAdjustment { get; set; }
Selector: setSearchFieldBackgroundImage:forState:
Method: [Appearance]
Selector: searchFieldBackgroundImageForState:
Method: [Appearance]
Selector: setImage:forSearchBarIcon:state:
Method: [Appearance]
Selector: imageForSearchBarIcon:state:
Method: [Appearance]
Selector: setScopeBarButtonBackgroundImage:forState:
Method: [Appearance]
Selector: scopeBarButtonBackgroundImageForState:
Method: [Appearance]
Selector: setScopeBarButtonDividerImage:forLeftSegmentState:rightSegmentState:
Method: [Appearance]
Selector: scopeBarButtonDividerImageForLeftSegmentState:rightSegmentState:
Method: [Appearance]
Selector: setScopeBarButtonTitleTextAttributes:forState:
Method: [Appearance]
Selector: scopeBarButtonTitleTextAttributesForState:
Method: [Appearance]
Selector: setPositionAdjustment:forSearchBarIcon:
Method: void SetPositionAdjustmentforSearchBarIcon (UIOffset adjustment, UISearchBarIcon icon);
Selector: positionAdjustmentForSearchBarIcon:
Method: UIOffset GetPositionAdjustmentForSearchBarIcon (UISearchBarIcon icon);

Class UISearchBarDelegate

Selector: searchBarShouldBeginEditing:"), DefaultValue (true), DelegateName ("UISearchBarPredicate
Method: bool ShouldBeginEditing (UISearchBar searchBar);
Selector: searchBarTextDidBeginEditing:"), EventArgs ("UISearchBar
Method: void OnEditingStarted (UISearchBar searchBar);
Selector: searchBarShouldEndEditing:"), DelegateName ("UISearchBarPredicate
Method: bool ShouldEndEditing (UISearchBar searchBar);
Selector: searchBarTextDidEndEditing:"), EventArgs ("UISearchBar
Method: void OnEditingStopped (UISearchBar searchBar);
Selector: searchBar:textDidChange:"), EventArgs ("UISearchBarTextChanged
Method: void TextChanged (UISearchBar searchBar, string searchText);
Selector: searchBar:shouldChangeTextInRange:replacementText:"), DefaultValue (true), DelegateName ("UISearchBarRangeEventArgs
Method: bool ShouldChangeTextInRange (UISearchBar searchBar, NSRange range, string text);
Selector: searchBarSearchButtonClicked:"), EventArgs ("UISearchBar
Method: void SearchButtonClicked (UISearchBar searchBar);
Selector: searchBarBookmarkButtonClicked:"), EventArgs ("UISearchBar
Method: void BookmarkButtonClicked (UISearchBar searchBar);
Selector: searchBarCancelButtonClicked:"), EventArgs ("UISearchBar
Method: void CancelButtonClicked (UISearchBar searchBar);
Selector: searchBar:selectedScopeButtonIndexDidChange:"), EventArgs ("UISearchBarButtonIndex
Method: void SelectedScopeButtonIndexChanged (UISearchBar searchBar, int selectedScope);
Selector: searchBarResultsListButtonClicked:"), EventArgs ("UISearchBar
Method: void ListButtonClicked (UISearchBar searchBar);

Class UISearchDisplayController

Selector: initWithSearchBar:contentsController:
Method: IntPtr Constructor (UISearchBar searchBar, UIViewController viewController);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: active
Property: bool Active { [Bind ("isActive")] get; set; }
Selector: setActive:animated:
Method: void SetActive (bool visible, bool animated);
Selector: searchBar
Property: UISearchBar SearchBar { get; }
Selector: searchContentsController
Property: UIViewController SearchContentsController { get; }
Selector: searchResultsTableView
Property: UITableView SearchResultsTableView { get; }
Selector: searchResultsDataSource
Property: NSObject SearchResultsWeakDataSource { get; set; }
Selector: searchResultsDelegate
Property: NSObject SearchResultsWeakDelegate { get; set; }
Selector: searchResultsTitle
Property: string SearchResultsTitle { get; set; }

Class UISearchDisplayDelegate

Selector: searchDisplayControllerWillBeginSearch:
Method: void WillBeginSearch (UISearchDisplayController controller);
Selector: searchDisplayControllerDidBeginSearch:
Method: void DidBeginSearch (UISearchDisplayController controller);
Selector: searchDisplayControllerWillEndSearch:
Method: void WillEndSearch (UISearchDisplayController controller);
Selector: searchDisplayControllerDidEndSearch:
Method: void DidEndSearch (UISearchDisplayController controller);
Selector: searchDisplayController:didLoadSearchResultsTableView:
Method: void DidLoadSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:willUnloadSearchResultsTableView:
Method: void WillUnloadSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:willShowSearchResultsTableView:
Method: void WillShowSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:didShowSearchResultsTableView:
Method: void DidShowSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:willHideSearchResultsTableView:
Method: void WillHideSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:didHideSearchResultsTableView:
Method: void DidHideSearchResults (UISearchDisplayController controller, UITableView tableView);
Selector: searchDisplayController:shouldReloadTableForSearchString:
Method: bool ShouldReloadForSearchString (UISearchDisplayController controller, string forSearchString);
Selector: searchDisplayController:shouldReloadTableForSearchScope:
Method: bool ShouldReloadForSearchScope (UISearchDisplayController controller, int forSearchOption);

Class UISegmentedControl

Selector: initWithItems:
Method: IntPtr InitWithItems (IntPtr v);
Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: segmentedControlStyle
Property: UISegmentedControlStyle ControlStyle { get; set; }
Selector: momentary
Property: bool Momentary { [Bind ("isMomentary")] get; set; }
Selector: tintColor
Method: [Appearance]
Selector: numberOfSegments
Property: int NumberOfSegments { get; }
Selector: insertSegmentWithTitle:atIndex:animated:
Method: void InsertSegment (string title, int pos, bool animated);
Selector: insertSegmentWithImage:atIndex:animated:
Method: void InsertSegment (UIImage image, int pos, bool animated);
Selector: removeSegmentAtIndex:animated:
Method: void RemoveSegmentAtIndex (int segment, bool animated);
Selector: removeAllSegments
Method: void RemoveAllSegments ();
Selector: setTitle:forSegmentAtIndex:
Method: void SetTitle (string title, int segment);
Selector: titleForSegmentAtIndex:
Method: string TitleAt (int segment);
Selector: setImage:forSegmentAtIndex:
Method: void SetImage (UIImage image, int segment);
Selector: imageForSegmentAtIndex:
Method: UIImage ImageAt (int segment);
Selector: setWidth:forSegmentAtIndex:
Method: void SetWidth (float width, int segment);
Selector: widthForSegmentAtIndex:
Method: float SegmentWidth (int segment);
Selector: setContentOffset:forSegmentAtIndex:
Method: void SetContentOffset (SizeF offset, int segment);
Selector: contentOffsetForSegmentAtIndex:
Method: SizeF GetContentOffset (int segment);
Selector: setEnabled:forSegmentAtIndex:
Method: void SetEnabled (bool enabled, int segment);
Selector: isEnabledForSegmentAtIndex:
Method: bool IsEnabled (int segment);
Selector: selectedSegmentIndex
Property: int SelectedSegment { get; set; }
Selector: apportionsSegmentWidthsByContent
Property: bool ApportionsSegmentWidthsByContent { get; set; }
Selector: setBackgroundImage:forState:barMetrics:
Method: [Appearance]
Selector: backgroundImageForState:barMetrics:
Method: [Appearance]
Selector: setDividerImage:forLeftSegmentState:rightSegmentState:barMetrics:
Method: [Appearance]
Selector: dividerImageForLeftSegmentState:rightSegmentState:barMetrics:
Method: [Appearance]
Selector: setTitleTextAttributes:forState:
Method: [Appearance]
Selector: titleTextAttributesForState:
Method: [Appearance]
Selector: setContentPositionAdjustment:forSegmentType:barMetrics:
Method: [Appearance]
Selector: contentPositionAdjustmentForSegmentType:barMetrics:
Method: [Appearance]

Class UISlider

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: value
Property: float Value { get; set; }
Selector: minimumValue
Property: float MinValue { get; set; }
Selector: maximumValue
Property: float MaxValue { get; set; }
Selector: minimumValueImage
Property: UIImage MinValueImage { get; set; }
Selector: maximumValueImage
Property: UIImage MaxValueImage { get; set; }
Selector: continuous
Property: bool Continuous { [Bind ("isContinuous")] get; set; }
Selector: currentThumbImage
Property: UIImage CurrentThumbImage { get; set; }
Selector: currentMinimumTrackImage
Property: UIImage CurrentMinTrackImage { get; set; }
Selector: currentMaximumTrackImage
Property: UIImage CurrentMaxTrackImage { get; set; }
Selector: setValue:animated:
Method: void SetValue (float value, bool animated);
Selector: setThumbImage:forState:
Method: void SetThumbImage (UIImage image, UIControlState forState);
Selector: setMinimumTrackImage:forState:
Method: void SetMinTrackImage (UIImage image, UIControlState forState);
Selector: setMaximumTrackImage:forState:
Method: void SetMaxTrackImage (UIImage image, UIControlState forState);
Selector: thumbImageForState:
Method: UIImage ThumbImage (UIControlState forState);
Selector: minimumTrackImageForState:
Method: UIImage MinTrackImage (UIControlState forState);
Selector: maximumTrackImageForState:
Method: UIImage MaxTrackImage (UIControlState forState);
Selector: minimumValueImageRectForBounds:
Method: RectangleF MinValueImageRectForBounds (RectangleF forBounds);
Selector: maximumValueImageRectForBounds:
Method: RectangleF MaxValueImageRectForBounds (RectangleF forBounds);
Selector: trackRectForBounds:
Method: RectangleF TrackRectForBounds (RectangleF forBounds);
Selector: thumbRectForBounds:trackRect:value:
Method: RectangleF ThumbRectForBounds (RectangleF bounds, RectangleF trackRect, float value);
Selector: minimumTrackTintColor
Method: [Appearance]
Selector: maximumTrackTintColor
Method: [Appearance]
Selector: thumbTintColor
Method: [Appearance]

Class UISwitch

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: on
Property: bool On { [Bind ("isOn")] get; set; }
Selector: setOn:animated:
Method: void SetState (bool newState, bool animated);
Selector: onTintColor
Method: [Appearance]

Class UITabBar

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: items
Property: UITabBarItem [] Items { get; set; }
Selector: selectedItem
Property: UITabBarItem SelectedItem { get; set; }
Selector: setItems:animated:
Method: void SetItems (UITabBarItem [] items, bool animated);
Selector: beginCustomizingItems:
Method: void BeginCustomizingItems (UITabBarItem [] items);
Selector: endCustomizingAnimated:
Method: bool EndCustomizingAnimated (bool animated);
Selector: isCustomizing
Property: bool IsCustomizing { get; }
Selector: tintColor
Method: [Appearance]
Selector: selectedImageTintColor
Method: [Appearance]
Selector: backgroundImage
Method: [Appearance]
Selector: selectionIndicatorImage
Method: [Appearance]

Class UITabBarController

Selector: initWithNibName:bundle:
Method: IntPtr Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
Selector: viewControllers
Property: UIViewController [] ViewControllers { get; set; }
Selector: setViewControllers:animated:
Method: void SetViewControllers (UIViewController [] viewControllers, bool animated);
Selector: selectedViewController
Property: UIViewController SelectedViewController { get; set; }
Selector: selectedIndex
Property: int SelectedIndex { get; set; }
Selector: moreNavigationController
Property: UINavigationController MoreNavigationController { get; set; }
Selector: customizableViewControllers
Property: UIViewController [] CustomizableViewControllers { get; [NullAllowed] set; }
Selector: tabBar
Property: UITabBar TabBar { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class UITabBarDelegate

Selector: tabBar:didSelectItem:"), EventArgs ("UITabBarItem
Method: void ItemSelected (UITabBar tabbar, UITabBarItem item);
Selector: tabBar:willBeginCustomizingItems:"), EventArgs ("UITabBarItems
Method: void WillBeginCustomizingItems (UITabBar tabbar, UITabBarItem [] items);
Selector: tabBar:didBeginCustomizingItems:"), EventArgs ("UITabBarItems
Method: void DidBeginCustomizingItems (UITabBar tabbar, UITabBarItem [] items);
Selector: tabBar:willEndCustomizingItems:changed:"), EventArgs ("UITabBarFinalItems
Method: void WillEndCustomizingItems (UITabBar tabbar, UITabBarItem [] items, bool changed);
Selector: tabBar:didEndCustomizingItems:changed:"), EventArgs ("UITabBarFinalItems
Method: void DidEndCustomizingItems (UITabBar tabbar, UITabBarItem [] items, bool changed);

Class UITabBarControllerDelegate

Selector: tabBarController:shouldSelectViewController:"), DefaultValue (true), DelegateName ("UITabBarSelection
Method: bool ShouldSelectViewController (UITabBarController tabBarController, UIViewController viewController);
Selector: tabBarController:didSelectViewController:"), EventArgs ("UITabBarSelection
Method: void ViewControllerSelected (UITabBarController tabBarController, UIViewController viewController);
Selector: tabBarController:willBeginCustomizingViewControllers:"), EventArgs ("UITabBarCustomize
Method: void OnCustomizingViewControllers (UITabBarController tabBarController, UIViewController [] viewControllers);
Selector: tabBarController:willEndCustomizingViewControllers:changed:"), EventArgs ("UITabBarCustomizeChange
Method: void OnEndCustomizingViewControllers (UITabBarController tabBarController, UIViewController [] viewControllers, bool changed);
Selector: tabBarController:didEndCustomizingViewControllers:changed:"), EventArgs ("UITabBarCustomizeChange
Method: void FinishedCustomizingViewControllers (UITabBarController tabBarController, UIViewController [] viewControllers, bool changed);

Class UITabBarItem

Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: title
Property: string Title { get;set; }
Selector: image
Property: UIImage Image { get; set; }
Selector: imageInsets
Property: UIEdgeInsets ImageInsets { get; set; }
Selector: tag
Property: int Tag { get; set; }
Selector: initWithTitle:image:tag:
Method: IntPtr Constructor (string title, [NullAllowed] UIImage image, int tag);
Selector: initWithTabBarSystemItem:tag:
Method: IntPtr Constructor (UITabBarSystemItem systemItem, int tag);
Selector: badgeValue
Property: string BadgeValue { get; set; }
Selector: setFinishedSelectedImage:withFinishedUnselectedImage:
Method: void SetFinishedImages (UIImage selectedImage, UIImage unselectedImage);
Selector: finishedSelectedImage
Property: UIImage FinishedSelectedImage { get; }
Selector: finishedUnselectedImage
Property: UIImage FinishedUnselectedImage { get; }
Selector: titlePositionAdjustment
Method: [Appearance]

Class UITableView

Selector: initWithFrame:style:
Method: IntPtr Constructor (RectangleF frame, UITableViewStyle style);
Selector: style
Property: UITableViewStyle Style { get; }
Selector: dataSource
Property: NSObject WeakDataSource { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: rowHeight
Property: float RowHeight { get; set; }
Selector: sectionHeaderHeight
Property: float SectionHeaderHeight { get; set; }
Selector: sectionFooterHeight
Property: float SectionFooterHeight { get; set; }
Selector: reloadData
Method: void ReloadData ();
Selector: reloadSectionIndexTitles
Method: void ReloadSectionIndexTitles ();
Selector: numberOfSections
Method: int NumberOfSections ();
Selector: numberOfRowsInSection:
Method: int NumberOfRowsInSection (int section);
Selector: rectForSection:
Method: RectangleF RectForSection (int section);
Selector: rectForHeaderInSection:
Method: RectangleF RectForHeaderInSection (int section);
Selector: rectForFooterInSection:
Method: RectangleF RectForFooterInSection (int section);
Selector: rectForRowAtIndexPath:
Method: RectangleF RectForRowAtIndexPath (NSIndexPath indexPath);
Selector: indexPathForRowAtPoint:
Method: NSIndexPath IndexPathForRowAtPoint (PointF point);
Selector: indexPathForCell:
Method: NSIndexPath IndexPathForCell (UITableViewCell cell);
Selector: indexPathsForRowsInRect:
Method: IntPtr _IndexPathsForRowsInRect (RectangleF rect);
Selector: cellForRowAtIndexPath:
Method: UITableViewCell CellAt (NSIndexPath ns);
Selector: visibleCells
Property: UITableViewCell [] VisibleCells { get; }
Selector: indexPathsForVisibleRows
Property: NSIndexPath [] IndexPathsForVisibleRows { get; }
Selector: scrollToRowAtIndexPath:atScrollPosition:animated:
Method: void ScrollToRow (NSIndexPath indexPath, UITableViewScrollPosition atScrollPosition, bool animated);
Selector: scrollToNearestSelectedRowAtScrollPosition:animated:
Method: void ScrollToNearestSelected (UITableViewScrollPosition atScrollPosition, bool animated);
Selector: beginUpdates
Method: void BeginUpdates ();
Selector: endUpdates
Method: void EndUpdates ();
Selector: insertSections:withRowAnimation:
Method: void InsertSections (NSIndexSet sections, UITableViewRowAnimation withRowAnimation);
Selector: deleteSections:withRowAnimation:
Method: void DeleteSections (NSIndexSet sections, UITableViewRowAnimation withRowAnimation);
Selector: reloadSections:withRowAnimation:
Method: void ReloadSections (NSIndexSet sections, UITableViewRowAnimation withRowAnimation);
Selector: insertRowsAtIndexPaths:withRowAnimation:
Method: void InsertRows (NSIndexPath [] atIndexPaths, UITableViewRowAnimation withRowAnimation);
Selector: deleteRowsAtIndexPaths:withRowAnimation:
Method: void DeleteRows (NSIndexPath [] atIndexPaths, UITableViewRowAnimation withRowAnimation);
Selector: reloadRowsAtIndexPaths:withRowAnimation:
Method: void ReloadRows (NSIndexPath [] atIndexPaths, UITableViewRowAnimation withRowAnimation);
Selector: editing
Property: bool Editing { [Bind ("isEditing")] get; set; }
Selector: setEditing:animated:
Method: void SetEditing (bool editing, bool animated);
Selector: allowsSelection
Property: bool AllowsSelection { get; set; }
Selector: allowsSelectionDuringEditing
Property: bool AllowsSelectionDuringEditing { get; set; }
Selector: indexPathForSelectedRow
Property: NSIndexPath IndexPathForSelectedRow { get; }
Selector: selectRowAtIndexPath:animated:scrollPosition:
Method: void SelectRow (NSIndexPath indexPath, bool animated, UITableViewScrollPosition scrollPosition);
Selector: deselectRowAtIndexPath:animated:
Method: void DeselectRow ([NullAllowed] NSIndexPath indexPath, bool animated);
Selector: sectionIndexMinimumDisplayRowCount
Property: int SectionIndexMinimumDisplayRowCount { get; set; }
Selector: separatorStyle
Property: UITableViewCellSeparatorStyle SeparatorStyle { get; set; }
Selector: separatorColor
Property: UIColor SeparatorColor { get; set; }
Selector: tableHeaderView
Property: UIView TableHeaderView { get; set; }
Selector: tableFooterView
Property: UIView TableFooterView { get; set; }
Selector: dequeueReusableCellWithIdentifier:
Method: UITableViewCell DequeueReusableCell (string identifier);
Selector: dequeueReusableCellWithIdentifier:
Method: UITableViewCell DequeueReusableCell (NSString identifier);
Selector: backgroundView
Property: UIView BackgroundView { get; set; }
Selector: allowsMultipleSelection
Property: bool AllowsMultipleSelection { get; set; }
Selector: allowsMultipleSelectionDuringEditing
Property: bool AllowsMultipleSelectionDuringEditing { get; set; }
Selector: moveSection:toSection:
Method: void MoveSection (int fromSection, int toSection);
Selector: moveRowAtIndexPath:toIndexPath:
Method: void MoveRow (NSIndexPath fromIndexPath, NSIndexPath toIndexPath);
Selector: indexPathsForSelectedRows
Property: NSIndexPath [] IndexPathsForSelectedRows { get; }
Selector: registerNib:forCellReuseIdentifier:
Method: void RegisterNibforCellReuse (UINib nib, string reuseIdentifier);

Class UITableViewSource

Selector: tableView:numberOfRowsInSection:
Method: [Abstract]
Selector: tableView:cellForRowAtIndexPath:
Method: [Abstract]
Selector: numberOfSectionsInTableView:
Method: int NumberOfSections (UITableView tableView);
Selector: tableView:titleForHeaderInSection:
Method: string TitleForHeader (UITableView tableView, int section);
Selector: tableView:titleForFooterInSection:
Method: string TitleForFooter (UITableView tableView, int section);
Selector: tableView:canEditRowAtIndexPath:
Method: bool CanEditRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:canMoveRowAtIndexPath:
Method: bool CanMoveRow (UITableView tableView, NSIndexPath indexPath);
Selector: sectionIndexTitlesForTableView:
Method: string [] SectionIndexTitles (UITableView tableView);
Selector: tableView:sectionForSectionIndexTitle:atIndex:
Method: int SectionFor (UITableView tableView, string title, int atIndex);
Selector: tableView:commitEditingStyle:forRowAtIndexPath:
Method: void CommitEditingStyle (UITableView tableView, UITableViewCellEditingStyle editingStyle, NSIndexPath indexPath);
Selector: tableView:moveRowAtIndexPath:toIndexPath:
Method: void MoveRow (UITableView tableView, NSIndexPath sourceIndexPath, NSIndexPath destinationIndexPath);
Selector: tableView:willDisplayCell:forRowAtIndexPath:
Method: void WillDisplay (UITableView tableView, UITableViewCell cell, NSIndexPath indexPath);
Selector: tableView:heightForRowAtIndexPath:
Method: float GetHeightForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:heightForHeaderInSection:
Method: float GetHeightForHeader (UITableView tableView, int section);
Selector: tableView:heightForFooterInSection:
Method: float GetHeightForFooter (UITableView tableView, int section);
Selector: tableView:viewForHeaderInSection:
Method: UIView GetViewForHeader (UITableView tableView, int section);
Selector: tableView:viewForFooterInSection:
Method: UIView GetViewForFooter (UITableView tableView, int section);
Selector: tableView:accessoryTypeForRowWithIndexPath:
Method: UITableViewCellAccessory AccessoryForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:accessoryButtonTappedForRowWithIndexPath:
Method: void AccessoryButtonTapped (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willSelectRowAtIndexPath:
Method: NSIndexPath WillSelectRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willDeselectRowAtIndexPath:
Method: void WillDeselectRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didSelectRowAtIndexPath:
Method: void RowSelected (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didDeselectRowAtIndexPath:
Method: void RowDeselected (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:editingStyleForRowAtIndexPath:
Method: UITableViewCellEditingStyle EditingStyleForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:titleForDeleteConfirmationButtonForRowAtIndexPath:
Method: string TitleForDeleteConfirmation (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:shouldIndentWhileEditingRowAtIndexPath:
Method: bool ShouldIndentWhileEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willBeginEditingRowAtIndexPath:
Method: void WillBeginEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didEndEditingRowAtIndexPath:
Method: void DidEndEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:targetIndexPathForMoveFromRowAtIndexPath:toProposedIndexPath:
Method: NSIndexPath CustomizeMoveTarget (UITableView tableView, NSIndexPath sourceIndexPath, NSIndexPath proposedIndexPath);
Selector: tableView:indentationLevelForRowAtIndexPath:
Method: int IndentationLevel (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:shouldShowMenuForRowAtIndexPath:
Method: bool ShouldShowMenu (UITableView tableView, NSIndexPath rowAtindexPath);
Selector: tableView:canPerformAction:forRowAtIndexPath:withSender:
Method: bool CanPerformAction (UITableView tableView, Selector action, NSIndexPath indexPath, NSObject sender);
Selector: tableView:performAction:forRowAtIndexPath:withSender:
Method: void PerformAction (UITableView tableView, Selector action, NSIndexPath indexPath, NSObject sender);

Class UITableViewCell

Selector: initWithStyle:reuseIdentifier:
Method: IntPtr Constructor (UITableViewCellStyle style, [NullAllowed] NSString reuseIdentifier);
Selector: imageView
Property: UIImageView ImageView { get; }
Selector: textLabel
Property: UILabel TextLabel { get; }
Selector: detailTextLabel
Property: UILabel DetailTextLabel { get; }
Selector: contentView
Property: UIView ContentView { get; }
Selector: backgroundView
Property: UIView BackgroundView { get; set; }
Selector: selectedBackgroundView
Property: UIView SelectedBackgroundView { get; set; }
Selector: reuseIdentifier
Property: string ReuseIdentifier { get; }
Selector: prepareForReuse
Method: void PrepareForReuse ();
Selector: selectionStyle
Property: UITableViewCellSelectionStyle SelectionStyle { get; set; }
Selector: selected
Property: bool Selected { [Bind ("isSelected")] get; set; }
Selector: highlighted
Property: bool Highlighted { [Bind ("isHighlighted")] get; set; }
Selector: setSelected:animated:
Method: void SetSelected (bool selected, bool animated);
Selector: setHighlighted:animated:
Method: void SetHighlighted (bool highlighted, bool animated);
Selector: editingStyle
Property: UITableViewCellEditingStyle EditingStyle { get; }
Selector: showsReorderControl
Property: bool ShowsReorderControl { get; set; }
Selector: shouldIndentWhileEditing
Property: bool ShouldIndentWhileEditing { get; set; }
Selector: accessoryType
Property: UITableViewCellAccessory Accessory { get; set; }
Selector: accessoryView
Property: UIView AccessoryView { get; [NullAllowed] set; }
Selector: editingAccessoryType
Property: UITableViewCellAccessory EditingAccessory { get; set; }
Selector: editingAccessoryView
Property: UIView EditingAccessoryView { get; set; }
Selector: indentationLevel
Property: int IndentationLevel { get; set; }
Selector: indentationWidth
Property: float IndentationWidth { get; set; }
Selector: editing
Property: bool Editing { [Bind ("isEditing")] get; set; }
Selector: setEditing:animated:
Method: void SetEditing (bool editing, bool animated);
Selector: showingDeleteConfirmation
Property: bool ShowingDeleteConfirmation { get; set; }
Selector: willTransitionToState:
Method: void WillTransitionToState (UITableViewCellState mask);
Selector: didTransitionToState:
Method: void DidTransitionToState (UITableViewCellState mask);
Selector: multipleSelectionBackgroundView
Property: UIView MultipleSelectionBackgroundView { get; set; }

Class UITableViewController

Selector: initWithNibName:bundle:
Method: IntPtr Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
Selector: initWithStyle:
Method: IntPtr Constructor (UITableViewStyle withStyle);
Selector: tableView
Property: UITableView TableView { get; set; }
Selector: clearsSelectionOnViewWillAppear
Property: bool ClearsSelectionOnViewWillAppear { get; set; }

Class UITableViewDataSource

Selector: tableView:numberOfRowsInSection:
Method: [Abstract]
Selector: tableView:cellForRowAtIndexPath:
Method: [Abstract]
Selector: numberOfSectionsInTableView:
Method: int NumberOfSections (UITableView tableView);
Selector: tableView:titleForHeaderInSection:
Method: string TitleForHeader (UITableView tableView, int section);
Selector: tableView:titleForFooterInSection:
Method: string TitleForFooter (UITableView tableView, int section);
Selector: tableView:canEditRowAtIndexPath:
Method: bool CanEditRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:canMoveRowAtIndexPath:
Method: bool CanMoveRow (UITableView tableView, NSIndexPath indexPath);
Selector: sectionIndexTitlesForTableView:
Method: string [] SectionIndexTitles (UITableView tableView);
Selector: tableView:sectionForSectionIndexTitle:atIndex:
Method: int SectionFor (UITableView tableView, string title, int atIndex);
Selector: tableView:commitEditingStyle:forRowAtIndexPath:
Method: void CommitEditingStyle (UITableView tableView, UITableViewCellEditingStyle editingStyle, NSIndexPath indexPath);
Selector: tableView:moveRowAtIndexPath:toIndexPath:
Method: void MoveRow (UITableView tableView, NSIndexPath sourceIndexPath, NSIndexPath destinationIndexPath);

Class UITableViewDelegate

Selector: tableView:willDisplayCell:forRowAtIndexPath:
Method: void WillDisplay (UITableView tableView, UITableViewCell cell, NSIndexPath indexPath);
Selector: tableView:heightForRowAtIndexPath:
Method: float GetHeightForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:heightForHeaderInSection:
Method: float GetHeightForHeader (UITableView tableView, int section);
Selector: tableView:heightForFooterInSection:
Method: float GetHeightForFooter (UITableView tableView, int section);
Selector: tableView:viewForHeaderInSection:
Method: UIView GetViewForHeader (UITableView tableView, int section);
Selector: tableView:viewForFooterInSection:
Method: UIView GetViewForFooter (UITableView tableView, int section);
Selector: tableView:accessoryTypeForRowWithIndexPath:
Method: UITableViewCellAccessory AccessoryForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:accessoryButtonTappedForRowWithIndexPath:
Method: void AccessoryButtonTapped (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willSelectRowAtIndexPath:
Method: NSIndexPath WillSelectRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willDeselectRowAtIndexPath:
Method: void WillDeselectRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didSelectRowAtIndexPath:
Method: void RowSelected (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didDeselectRowAtIndexPath:
Method: void RowDeselected (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:editingStyleForRowAtIndexPath:
Method: UITableViewCellEditingStyle EditingStyleForRow (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:titleForDeleteConfirmationButtonForRowAtIndexPath:
Method: string TitleForDeleteConfirmation (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:shouldIndentWhileEditingRowAtIndexPath:
Method: bool ShouldIndentWhileEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:willBeginEditingRowAtIndexPath:
Method: void WillBeginEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:didEndEditingRowAtIndexPath:
Method: void DidEndEditing (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:targetIndexPathForMoveFromRowAtIndexPath:toProposedIndexPath:
Method: NSIndexPath CustomizeMoveTarget (UITableView tableView, NSIndexPath sourceIndexPath, NSIndexPath proposedIndexPath);
Selector: tableView:indentationLevelForRowAtIndexPath:
Method: int IndentationLevel (UITableView tableView, NSIndexPath indexPath);
Selector: tableView:shouldShowMenuForRowAtIndexPath:
Method: bool ShouldShowMenu (UITableView tableView, NSIndexPath rowAtindexPath);
Selector: tableView:canPerformAction:forRowAtIndexPath:withSender:
Method: bool CanPerformAction (UITableView tableView, Selector action, NSIndexPath indexPath, NSObject sender);
Selector: tableView:performAction:forRowAtIndexPath:withSender:
Method: void PerformAction (UITableView tableView, Selector action, NSIndexPath indexPath, NSObject sender);

Class UITextField : UITextInput

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: text
Property: string Text { get; [NullAllowed] set; }
Selector: textColor
Property: UIColor TextColor { get; [NullAllowed] set; }
Selector: font
Property: UIFont Font { get; [NullAllowed] set; }
Selector: textAlignment
Property: UITextAlignment TextAlignment { get; set; }
Selector: borderStyle
Property: UITextBorderStyle BorderStyle { get; set; }
Selector: placeholder
Property: string Placeholder { get; [NullAllowed] set; }
Selector: clearsOnBeginEditing
Property: bool ClearsOnBeginEditing { get; set; }
Selector: adjustsFontSizeToFitWidth
Property: bool AdjustsFontSizeToFitWidth { get; set; }
Selector: minimumFontSize
Property: float MinimumFontSize { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; [NullAllowed] set; }
Selector: background
Property: UIImage Background { get; [NullAllowed] set; }
Selector: disabledBackground
Property: UIImage DisabledBackground { get; [NullAllowed] set; }
Selector: isEditing
Property: bool IsEditing { get; }
Selector: clearButtonMode
Property: UITextFieldViewMode ClearButtonMode { get; set; }
Selector: leftView
Property: UIView LeftView { get; set; }
Selector: rightView
Property: UIView RightView { get; set; }
Selector: leftViewMode
Property: UITextFieldViewMode LeftViewMode { get; set; }
Selector: rightViewMode
Property: UITextFieldViewMode RightViewMode { get; set; }
Selector: borderRectForBounds:
Method: RectangleF BorderRect (RectangleF forBounds);
Selector: textRectForBounds:
Method: RectangleF TextRect (RectangleF forBounds);
Selector: placeholderRectForBounds:
Method: RectangleF PlaceholderRect (RectangleF forBounds);
Selector: editingRectForBounds:
Method: RectangleF EditingRect (RectangleF forBounds);
Selector: clearButtonRectForBounds:
Method: RectangleF ClearButtonRect (RectangleF forBounds);
Selector: leftViewRectForBounds:
Method: RectangleF LeftViewRect (RectangleF forBounds);
Selector: rightViewRectForBounds:
Method: RectangleF RightViewRect (RectangleF forBounds);
Selector: drawTextInRect:
Method: void DrawText (RectangleF rect);
Selector: drawPlaceholderInRect:
Method: void DrawPlaceholder (RectangleF rect);
Selector: inputAccessoryView
Property: UIView InputAccessoryView { get; set; }
Selector: inputView
Property: UIView InputView { get; set; }

Class UITextFieldDelegate

Selector: textFieldShouldBeginEditing:"), DelegateName ("UITextFieldCondition
Method: bool ShouldBeginEditing (UITextField textField);
Selector: textFieldDidBeginEditing:"), EventArgs ("UITextField"), EventName ("Started
Method: void EditingStarted (UITextField textField);
Selector: textFieldShouldEndEditing:"), DelegateName ("UITextFieldCondition
Method: bool ShouldEndEditing (UITextField textField);
Selector: textFieldDidEndEditing:"), EventArgs ("UITextField"), EventName ("Ended
Method: void EditingEnded (UITextField textField);
Selector: textFieldShouldClear:"), DelegateName ("UITextFieldCondition"), DefaultValue ("true
Method: bool ShouldClear (UITextField textField);
Selector: textFieldShouldReturn:"), DelegateName ("UITextFieldCondition"), DefaultValue ("true
Method: bool ShouldReturn (UITextField textField);
Selector: textField:shouldChangeCharactersInRange:replacementString:"), DelegateName ("UITextFieldChange"), DefaultValue ("true
Method: bool ShouldChangeCharacters (UITextField textField, NSRange range, string replacementString);

Class UITextView : UITextInput

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: text
Property: string Text { get; set; }
Selector: font
Property: UIFont Font { get; set; }
Selector: textColor
Property: UIColor TextColor { get; set; }
Selector: editable
Property: bool Editable { get; set; }
Selector: textAlignment
Property: UITextAlignment TextAlignment { get; set; }
Selector: selectedRange
Property: NSRange SelectedRange { get; set; }
Selector: scrollRangeToVisible:
Method: void ScrollRangeToVisible (NSRange range);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: dataDetectorTypes
Property: UIDataDetectorType DataDetectorTypes { get; set; }
Selector: inputAccessoryView
Property: UIView InputAccessoryView { get; set; }
Selector: inputView
Property: UIView InputView { get; set; }

Class UITextViewDelegate

Selector: textViewShouldBeginEditing:"), DelegateName ("UITextViewCondition"), DefaultValue ("true
Method: bool ShouldBeginEditing (UITextView textView);
Selector: textViewShouldEndEditing:"), DelegateName ("UITextViewCondition"), DefaultValue ("true
Method: bool ShouldEndEditing (UITextView textView);
Selector: textViewDidBeginEditing:"), EventArgs ("UITextView"), EventName ("Started
Method: void EditingStarted (UITextView textView);
Selector: textViewDidEndEditing:"), EventArgs ("UITextView"), EventName ("Ended
Method: void EditingEnded (UITextView textView);
Selector: textView:shouldChangeTextInRange:replacementText:"), DelegateName ("UITextViewChange"), DefaultValue ("true
Method: bool ShouldChangeText (UITextView textView, NSRange range, string text);
Selector: textViewDidChange:"), EventArgs ("UITextView
Method: void Changed (UITextView textView);
Selector: textViewDidChangeSelection:"), EventArgs ("UITextView
Method: void SelectionChanged (UITextView textView);

Class UIToolbar

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: barStyle
Property: UIBarStyle BarStyle { get; set; }
Selector: items
Property: UIBarButtonItem [] Items { get; set; }
Selector: tintColor
Property: UIColor TintColor { get; [NullAllowed] set; }
Selector: translucent
Property: bool Translucent { [Bind ("isTranslucent")] get; set; }
Selector: setItems:animated:")][PostGet ("Items
Method: //void SetItems (UIBarButtonItem [] items, bool animated);
Selector: setBackgroundImage:forToolbarPosition:barMetrics:
Method: [Appearance]
Selector: backgroundImageForToolbarPosition:barMetrics:
Method: [Appearance]

Class UITouch

Selector: locationInView:
Method: PointF LocationInView (UIView view);
Selector: previousLocationInView:
Method: PointF PreviousLocationInView (UIView view);
Selector: view
Property: UIView View { get; }
Selector: window
Property: UIWindow Window { get; }
Selector: tapCount
Property: int TapCount { get; }
Selector: timestamp
Property: double Timestamp { get; }
Selector: phase
Property: UITouchPhase Phase { get; }
Selector: gestureRecognizers
Property: UIGestureRecognizer[] GestureRecognizers { get; }

Class UIVideoEditorController

Selector: canEditVideoAtPath:
Method: bool CanEditVideoAtPath (string path);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: videoPath
Property: string VideoPath { get; set; }
Selector: videoMaximumDuration
Property: double VideoMaximumDuration { get; set; }
Selector: videoQuality
Property: UIImagePickerControllerQualityType VideoQuality { get; set; }

Class UIVideoEditorControllerDelegate

Selector: videoEditorController:didSaveEditedVideoToPath:"), EventArgs ("UIPath"), EventName ("Saved
Method: void VideoSaved (UIVideoEditorController editor, [EventName ("path")] string editedVideoPath);
Selector: videoEditorController:didFailWithError:"), EventArgs ("NSError
Method: void Failed (UIVideoEditorController editor, NSError error);
Selector: videoEditorControllerDidCancel:
Method: void UserCancelled (UIVideoEditorController editor);

Class UIView : UIAppearance

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: addSubview:")][PostGet ("Subviews
Method: void AddSubview (UIView view);
Selector: drawRect:
Method: void Draw (RectangleF rect);
Selector: backgroundColor
Method: [Appearance]
Selector: bounds
Property: RectangleF Bounds { get; set; }
Selector: userInteractionEnabled
Property: bool UserInteractionEnabled { [Bind ("isUserInteractionEnabled")]get; set; }
Selector: tag
Property: int Tag { get;set; }
Selector: layer
Property: MonoTouch.CoreAnimation.CALayer Layer { get; }
Selector: frame
Property: RectangleF Frame { get; set; }
Selector: center
Property: PointF Center { get; set; }
Selector: transform
Property: CGAffineTransform Transform { get; set; }
Selector: multipleTouchEnabled
Property: bool MultipleTouchEnabled { [Bind ("isMultipleTouchEnabled")] get; set; }
Selector: exclusiveTouch
Property: bool ExclusiveTouch { [Bind ("isExclusiveTouch")] get; set; }
Selector: hitTest:withEvent:
Method: UIView HitTest (PointF point, UIEvent uievent);
Selector: pointInside:withEvent:
Method: bool PointInside (PointF point, UIEvent uievent);
Selector: convertPoint:toView:
Method: PointF ConvertPointToView (PointF point, [NullAllowed] UIView toView);
Selector: convertPoint:fromView:
Method: PointF ConvertPointFromView (PointF point, [NullAllowed] UIView fromView);
Selector: convertRect:toView:
Method: RectangleF ConvertRectToView (RectangleF rect, UIView toView);
Selector: convertRect:fromView:
Method: RectangleF ConvertRectFromView (RectangleF rect, UIView fromView);
Selector: autoresizesSubviews
Property: bool AutosizesSubviews { get; set; }
Selector: autoresizingMask
Property: UIViewAutoresizing AutoresizingMask { get; set; }
Selector: sizeThatFits:
Method: SizeF SizeThatFits (SizeF size);
Selector: sizeToFit
Method: void SizeToFit ();
Selector: superview
Property: UIView Superview { get; }
Selector: subviews
Property: UIView [] Subviews { get; }
Selector: window
Property: UIWindow Window { get; }
Selector: removeFromSuperview
Method: [PreSnippet ("var mySuper = Superview;")]
Selector: insertSubview:atIndex:")][PostGet ("Subviews
Method: void InsertSubview (UIView view, int atIndex);
Selector: exchangeSubviewAtIndex:withSubviewAtIndex:
Method: void ExchangeSubview (int atIndex, int withSubviewAtIndex);
Selector: insertSubview:belowSubview:")][PostGet ("Subviews
Method: void InsertSubviewBelow (UIView view, UIView siblingSubview);
Selector: insertSubview:aboveSubview:")][PostGet ("Subviews
Method: void InsertSubviewAbove (UIView view, UIView siblingSubview);
Selector: bringSubviewToFront:
Method: void BringSubviewToFront (UIView view);
Selector: sendSubviewToBack:
Method: void SendSubviewToBack (UIView view);
Selector: didAddSubview:
Method: void SubviewAdded (UIView uiview);
Selector: willRemoveSubview:
Method: void WillRemoveSubview (UIView uiview);
Selector: willMoveToSuperview:
Method: void WillMoveToSuperview ([NullAllowed] UIView newsuper);
Selector: didMoveToSuperview
Method: void MovedToSuperview ();
Selector: willMoveToWindow:
Method: void WillMoveToWindow ([NullAllowed] UIWindow window);
Selector: didMoveToWindow
Method: void MovedToWindow ();
Selector: isDescendantOfView:
Method: bool IsDescendantOfView (UIView view);
Selector: viewWithTag:
Method: UIView ViewWithTag (int tag);
Selector: setNeedsLayout
Method: void SetNeedsLayout ();
Selector: layoutIfNeeded
Method: void LayoutIfNeeded ();
Selector: layoutSubviews
Method: void LayoutSubviews ();
Selector: setNeedsDisplay
Method: void SetNeedsDisplay ();
Selector: setNeedsDisplayInRect:
Method: void SetNeedsDisplayInRect (RectangleF rect);
Selector: clipsToBounds
Property: bool ClipsToBounds { get; set; }
Selector: alpha
Property: float Alpha { get; set; }
Selector: opaque
Property: bool Opaque { [Bind ("isOpaque")] get; set; }
Selector: clearsContextBeforeDrawing
Property: bool ClearsContextBeforeDrawing { get; set; }
Selector: hidden
Property: bool Hidden { [Bind ("isHidden")] get; set; }
Selector: contentMode
Property: UIViewContentMode ContentMode { get; set; }
Selector: contentStretch
Property: RectangleF ContentStretch { get; set; }
Selector: beginAnimations:context:
Method: void BeginAnimations ([NullAllowed] string s, IntPtr context);
Selector: commitAnimations
Method: void CommitAnimations ();
Selector: setAnimationDelegate:
Method: void SetAnimationDelegate (NSObject del);
Selector: setAnimationWillStartSelector:
Method: void SetAnimationWillStartSelector (Selector sel);
Selector: setAnimationDidStopSelector:
Method: void SetAnimationDidStopSelector (Selector sel);
Selector: setAnimationDuration:
Method: void SetAnimationDuration (double duration);
Selector: setAnimationDelay:
Method: void SetAnimationDelay (double delay);
Selector: setAnimationStartDate:
Method: void SetAnimationStartDate (NSDate startDate);
Selector: setAnimationCurve:
Method: void SetAnimationCurve (UIViewAnimationCurve curve);
Selector: setAnimationRepeatCount:
Method: void SetAnimationRepeatCount (float repeatCount);
Selector: setAnimationRepeatAutoreverses:
Method: void SetAnimationRepeatAutoreverses (bool repeatAutoreverses);
Selector: setAnimationBeginsFromCurrentState:
Method: void SetAnimationBeginsFromCurrentState (bool fromCurrentState);
Selector: setAnimationTransition:forView:cache:
Method: void SetAnimationTransition (UIViewAnimationTransition transition, UIView forView, bool cache);
Selector: areAnimationsEnabled
Property: bool AnimationsEnabled { [Bind ("areAnimationsEnabled")] get; [Bind ("setAnimationsEnabled:")] set; }
Selector: addGestureRecognizer:"), PostGet ("GestureRecognizers
Method: void AddGestureRecognizer (UIGestureRecognizer gestureRecognizer);
Selector: removeGestureRecognizer:"), PostGet ("GestureRecognizers
Method: void RemoveGestureRecognizer (UIGestureRecognizer gestureRecognizer);
Selector: gestureRecognizers
Property: UIGestureRecognizer[] GestureRecognizers { get; }
Selector: animateWithDuration:animations:
Method: void Animate (double duration, [NullAllowed] NSAction animation);
Selector: animateWithDuration:animations:completion:
Method: void Animate (double duration, [NullAllowed] NSAction animation, [NullAllowed] NSAction completion);
Selector: animateWithDuration:delay:options:animations:completion:
Method: void Animate (double duration, double delay, UIViewAnimationOptions options, [NullAllowed] NSAction animation, [NullAllowed] NSAction completion);
Selector: transitionFromView:toView:duration:options:completion:
Method: void Transition (UIView fromView, UIView toView, double duration, UIViewAnimationOptions options, [NullAllowed] NSAction completion);
Selector: transitionWithView:duration:options:animations:completion:
Method: void Transition (UIView withView, double duration, UIViewAnimationOptions options, [NullAllowed] NSAction animation, [NullAllowed] NSAction completion);
Selector: contentScaleFactor
Property: float ContentScaleFactor { get; set; }
Selector: viewPrintFormatter
Property: UIViewPrintFormatter ViewPrintFormatter { get; }
Selector: drawRect:forViewPrintFormatter:
Method: void DrawRect (RectangleF area, UIViewPrintFormatter formatter);
Selector: enableInputClicksWhenVisible
Property: bool EnableInputClicksWhenVisible { get; }

Class UIViewController

Selector: initWithNibName:bundle:
Method: IntPtr Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
Selector: view
Property: UIView View { get; set; }
Selector: loadView
Method: void LoadView ();
Selector: viewDidLoad
Method: void ViewDidLoad ();
Selector: viewDidUnload
Method: void ViewDidUnload ();
Selector: isViewLoaded
Property: bool IsViewLoaded { get; }
Selector: nibName
Property: string NibName { get; }
Selector: nibBundle
Property: NSBundle NibBundle { get; }
Selector: viewWillAppear:
Method: void ViewWillAppear (bool animated);
Selector: viewDidAppear:
Method: void ViewDidAppear (bool animated);
Selector: viewWillDisappear:
Method: void ViewWillDisappear (bool animated);
Selector: viewDidDisappear:
Method: void ViewDidDisappear (bool animated);
Selector: title
Property: string Title { get; set; }
Selector: didReceiveMemoryWarning
Method: void DidReceiveMemoryWarning ();
Selector: presentModalViewController:animated:")][PostGet ("ModalViewController
Method: void PresentModalViewController (UIViewController modalViewController, bool animated);
Selector: dismissModalViewControllerAnimated:")][PostGet ("ModalViewController
Method: void DismissModalViewControllerAnimated (bool animated);
Selector: modalViewController
Property: UIViewController ModalViewController { get; }
Selector: modalTransitionStyle
Property: UIModalTransitionStyle ModalTransitionStyle { get; set; }
Selector: wantsFullScreenLayout
Property: bool WantsFullScreenLayout { get; set; }
Selector: parentViewController
Property: UIViewController ParentViewController { get; }
Selector: tabBarItem
Property: UITabBarItem TabBarItem { get; set; }
Selector: shouldAutorotateToInterfaceOrientation:
Method: bool ShouldAutorotateToInterfaceOrientation (UIInterfaceOrientation toInterfaceOrientation);
Selector: rotatingHeaderView
Property: UIView RotatingHeaderView { get; }
Selector: rotatingFooterView
Property: UIView RotatingFooterView { get; }
Selector: interfaceOrientation
Property: UIInterfaceOrientation InterfaceOrientation { get; }
Selector: willRotateToInterfaceOrientation:duration:
Method: void WillRotate (UIInterfaceOrientation toInterfaceOrientation, double duration);
Selector: didRotateFromInterfaceOrientation:
Method: void DidRotate (UIInterfaceOrientation fromInterfaceOrientation);
Selector: willAnimateRotationToInterfaceOrientation:duration:
Method: void WillAnimateRotation (UIInterfaceOrientation toInterfaceOrientation, double duration);
Selector: willAnimateFirstHalfOfRotationToInterfaceOrientation:duration:
Method: void WillAnimateFirstHalfOfRotation (UIInterfaceOrientation toInterfaceOrientation, double duration);
Selector: didAnimateFirstHalfOfRotationToInterfaceOrientation:
Method: void DidAnimateFirstHalfOfRotation (UIInterfaceOrientation toInterfaceOrientation);
Selector: willAnimateSecondHalfOfRotationFromInterfaceOrientation:duration:
Method: void WillAnimateSecondHalfOfRotation (UIInterfaceOrientation fromInterfaceOrientation, double duration);
Selector: editing
Property: bool Editing { [Bind ("isEditing")] get; set; }
Selector: setEditing:animated:
Method: void SetEditing (bool editing, bool animated);
Selector: editButtonItem
Property: UIBarButtonItem EditButtonItem { get; }
Selector: searchDisplayController
Property: UISearchDisplayController SearchDisplayController { get; }
Selector: navigationItem
Property: UINavigationItem NavigationItem {get; }
Selector: hidesBottomBarWhenPushed
Property: bool HidesBottomBarWhenPushed { get; set; }
Selector: splitViewController
Property: UISplitViewController SplitViewController { get; }
Selector: tabBarController
Property: UITabBarController TabBarController { get; }
Selector: navigationController
Property: UINavigationController NavigationController { get; }
Selector: toolbarItems
Property: UIBarButtonItem [] ToolbarItems { get; set; }
Selector: setToolbarItems:animated:")][PostGet ("ToolbarItems
Method: void SetToolbarItems (UIBarButtonItem [] items, bool animated);
Selector: modalPresentationStyle
Property: UIModalPresentationStyle ModalPresentationStyle { get; set; }
Selector: presentMoviePlayerViewControllerAnimated:
Method: void PresentMoviePlayerViewController (MPMoviePlayerViewController moviePlayerViewController);
Selector: dismissMoviePlayerViewControllerAnimated
Method: void DismissMoviePlayerViewController ();
Selector: contentSizeForViewInPopover
Property: SizeF ContentSizeForViewInPopover { get; set; }
Selector: modalInPopover
Property: bool ModalInPopover { [Bind ("isModalInPopover")] get; set; }
Selector: disablesAutomaticKeyboardDismissal
Property: bool DisablesAutomaticKeyboardDismissal { get; set; }
Selector: storyboard
Property: UIStoryboard Storyboard { get; }
Selector: presentedViewController
Property: UIViewController PresentedViewController { get; }
Selector: presentingViewController
Property: UIViewController PresentingViewController { get; }
Selector: definesPresentationContext
Property: bool DefinesPresentationContext { get; set; }
Selector: providesPresentationContextTransitionStyle
Property: bool ProvidesPresentationContextTransitionStyle { get; set; }
Selector: viewWillUnload
Method: void ViewWillUnload ();
Selector: performSegueWithIdentifier:sender:
Method: void PerformSegue (string identifier, NSObject sender);
Selector: prepareForSegue:sender:
Method: void PrepareForSegue (UIStoryboardSegue segue, NSObject sender);
Selector: viewWillLayoutSubviews
Method: void ViewWillLayoutSubviews ();
Selector: viewDidLayoutSubviews
Method: void ViewDidLayoutSubviews ();
Selector: isBeingPresented
Property: bool IsBeingPresented { get; }
Selector: isBeingDismissed
Property: bool IsBeingDismissed { get; }
Selector: isMovingToParentViewController
Property: bool IsMovingToParentViewController { get; }
Selector: isMovingFromParentViewController
Property: bool IsMovingFromParentViewController { get; }
Selector: presentViewController:animated:completion:")][PostGet ("PresentedViewController
Method: void PresentViewController (UIViewController viewControllerToPresent, bool animated, NSAction completionHandler);
Selector: dismissViewControllerAnimated:completion:")][PostGet ("PresentedViewController
Method: void DismissViewController (bool animated, NSAction completionHandler);
Selector: attemptRotationToDeviceOrientation
Method: void AttemptRotationToDeviceOrientation ();
Selector: automaticallyForwardAppearanceAndRotationMethodsToChildViewControllers
Property: /*PROTECTED*/ bool AutomaticallyForwardAppearanceAndRotationMethodsToChildViewControllers { get; }
Selector: childViewControllers
Property: /*PROTECTED, MUSTCALLBASE*/ UIViewController [] ChildViewControllers { get; }
Selector: addChildViewController:
Method: /*PROTECTED, MUSTCALLBASE*/ void AddChildViewController (UIViewController childController);
Selector: removeFromParentViewController
Method: /*PROTECTED, MUSTCALLBASE*/ void RemoveFromParentViewController ();
Selector: transitionFromViewController:toViewController:duration:options:animations:completion:
Method: /*PROTECTED, MUSTCALLBASE*/ void Transition (UIViewController fromViewController, UIViewController toViewController, double duration, UIViewAnimationOptions options, NSAction animations, UICompletionHandler completionHandler);
Selector: willMoveToParentViewController:
Method: void WillMoveToParentViewController ([NullAllowed] UIViewController parent);
Selector: didMoveToParentViewController:
Method: void DidMoveToParentViewController ([NullAllowed] UIViewController parent);

Class UIWebView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: loadRequest:
Method: void LoadRequest (NSUrlRequest r);
Selector: loadHTMLString:baseURL:
Method: void LoadHtmlString (string s, [NullAllowed] NSUrl baseUrl);
Selector: loadData:MIMEType:textEncodingName:baseURL:
Method: void LoadData (NSData data, string mimeType, string textEncodingName, NSUrl baseUrl);
Selector: request
Property: NSUrlRequest Request { get; }
Selector: reload
Method: void Reload ();
Selector: stopLoading
Method: void StopLoading ();
Selector: goBack
Method: void GoBack ();
Selector: goForward
Method: void GoForward ();
Selector: canGoBack
Property: bool CanGoBack { get; }
Selector: canGoForward
Property: bool CanGoForward { get; }
Selector: isLoading
Property: bool IsLoading { get; }
Selector: stringByEvaluatingJavaScriptFromString:
Method: string EvaluateJavascript (string script);
Selector: scalesPageToFit
Property: bool ScalesPageToFit { get; set; }
Selector: dataDetectorTypes
Property: UIDataDetectorType DataDetectorTypes { get; set; }
Selector: allowsInlineMediaPlayback
Property: bool AllowsInlineMediaPlayback { get; set; }
Selector: mediaPlaybackRequiresUserAction
Property: bool MediaPlaybackRequiresUserAction { get; set; }
Selector: scrollView
Property: UIScrollView ScrollView { get; }
Selector: mediaPlaybackAllowsAirPlay
Property: bool MediaPlaybackAllowsAirPlay { get; set; }

Class UIWebViewDelegate

Selector: webView:shouldStartLoadWithRequest:navigationType:"), DelegateName ("UIWebLoaderControl"), DefaultValue ("true
Method: bool ShouldStartLoad (UIWebView webView, NSUrlRequest request, UIWebViewNavigationType navigationType);
Selector: webViewDidStartLoad:"), EventArgs ("UIWebView
Method: void LoadStarted (UIWebView webView);
Selector: webViewDidFinishLoad:"), EventArgs ("UIWebView"), EventName ("LoadFinished
Method: void LoadingFinished (UIWebView webView);
Selector: webView:didFailLoadWithError:"), EventArgs ("UIWebErrorArgs", false, true), EventName ("LoadError
Method: void LoadFailed (UIWebView webView, NSError error);

Class UITextChecker

Selector: rangeOfMisspelledWordInString:range:startingAt:wrap:language:
Method: NSRange RangeOfMisspelledWordInString (string stringToCheck, NSRange range, int startingOffset, bool wrapFlag, string language);
Selector: guessesForWordRange:inString:language:
Method: string [] GuessesForWordRange (NSRange range, string str, string language);
Selector: completionsForPartialWordRange:inString:language:
Method: string [] CompletionsForPartialWordRange (NSRange range, string str, string language);
Selector: ignoreWord:
Method: void IgnoreWord (string wordToIgnore);
Selector: ignoredWords
Property: string [] IgnoredWords { get; set; }
Selector: learnWord:
Method: void LearnWord (string word);
Selector: unlearnWord:
Method: void UnlearnWord (string word);
Selector: hasLearnedWord:
Method: bool HasLearnedWord (string word);
Selector: availableLanguages
Property: string AvailableLangauges { get; }

Class UISplitViewController

Selector: initWithNibName:bundle:
Method: IntPtr Constructor ([NullAllowed] string nibName, [NullAllowed] NSBundle bundle);
Selector: viewControllers
Property: UIViewController [] ViewControllers { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: splitViewController:shouldHideViewController:inOrientation:"), DelegateName ("UISplitViewControllerHidePredicate
Method: bool ShouldHideViewController (UISplitViewController svc, UIViewController viewController, UIInterfaceOrientation inOrientation);

Class UISplitViewControllerDelegate

Selector: splitViewController:popoverController:willPresentViewController:"), EventArgs ("UISplitViewPresent
Method: void WillPresentViewController (UISplitViewController svc, UIPopoverController pc, UIViewController aViewController);
Selector: splitViewController:willHideViewController:withBarButtonItem:forPopoverController:"), EventArgs ("UISplitViewHide
Method: void WillHideViewController (UISplitViewController svc, UIViewController aViewController, UIBarButtonItem barButtonItem, UIPopoverController pc);
Selector: splitViewController:willShowViewController:invalidatingBarButtonItem:"), EventArgs ("UISplitViewShow
Method: void WillShowViewController (UISplitViewController svc, UIViewController aViewController, UIBarButtonItem button);

Class UIStepper

Selector: continuous
Property: bool Continuous { [Bind ("isContinuous")] get; set; }
Selector: autorepeat
Property: bool AutoRepeat { get; set; }
Selector: wraps
Property: bool Wraps { get; set; }
Selector: value
Property: double Value { get; set; }
Selector: minimumValue
Property: double MinimumValue { get; set; }
Selector: maximumValue
Property: double MaximumValue { get; set; }
Selector: stepValue
Property: double StepValue { get; set; }

Class UIStoryboard

Selector: storyboardWithName:bundle:
Method: UIStoryboard FromName (string name, [NullAllowed] NSBundle storyboardBundleOrNil);
Selector: instantiateInitialViewController
Method: NSObject InstantiateInitialViewController ();
Selector: instantiateViewControllerWithIdentifier:
Method: NSObject InstantiateViewController (string identifier);

Class UIStoryboardPopoverSegue

Selector: popoverController
Property: UIPopoverController PopoverController { get; }

Class UIStoryboardSegue

Selector: initWithIdentifier:source:destination:
Method: IntPtr Constructor (string identifier, UIViewController source, UIViewController destination);
Selector: identifier
Property: string Identifier { get; }
Selector: sourceViewController
Property: UIViewController SourceViewController { get; }
Selector: destinationViewController
Property: UIViewController DestinationViewController { get; }
Selector: perform
Method: void Perform ();

Class UIPopoverBackgroundView

Selector: initWithFrame:
Method: IntPtr Constructor (RectangleF frame);
Selector: arrowOffset
Property: float ArrowOffset { get; set; }
Selector: arrowDirection
Property: UIPopoverArrowDirection ArrowDirection { get; set; }
Selector: ...
Method: // static method
Selector: arrowHeight
Method: float GetArrowHeight ();
Selector: arrowBase
Method: float GetArrowBase ();
Selector: contentViewInsets
Method: UIEdgeInsets GetContentViewInsets ();

Class UIPopoverController

Selector: initWithContentViewController:
Method: IntPtr Constructor (UIViewController viewController);
Selector: contentViewController
Property: UIViewController ContentViewController { get; set; }
Selector: popoverContentSize
Property: SizeF PopoverContentSize { get; set; }
Selector: setPopoverContentSize:animated:
Method: void SetPopoverContentSize (SizeF size, bool animated);
Selector: passthroughViews
Property: UIView [] PassthroughViews { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: popoverVisible
Property: bool PopoverVisible { [Bind ("isPopoverVisible")] get; }
Selector: popoverArrowDirection
Property: UIPopoverArrowDirection PopoverArrowDirection { get; }
Selector: presentPopoverFromRect:inView:permittedArrowDirections:animated:
Method: void PresentFromRect (RectangleF rect, UIView view, UIPopoverArrowDirection arrowDirections, bool animated);
Selector: presentPopoverFromBarButtonItem:permittedArrowDirections:animated:
Method: void PresentFromBarButtonItem (UIBarButtonItem item, UIPopoverArrowDirection arrowDirections, bool animated);
Selector: dismissPopoverAnimated:
Method: void Dismiss (bool animated);

Class UIPopoverControllerDelegate

Selector: popoverControllerDidDismissPopover:"), EventArgs ("UIPopoverController
Method: void DidDismiss (UIPopoverController popoverController);
Selector: popoverControllerShouldDismissPopover:"), DelegateName ("UIPopoverControllerCondition"), DefaultValue ("true
Method: bool ShouldDismiss (UIPopoverController popoverController);

Class UIScreenMode

Selector: pixelAspectRatio
Property: float PixelAspectRatio { get; }
Selector: size
Property: SizeF Size { get; }

Class UITextInputMode

Selector: currentInputMode
Property: UITextInputMode CurrentInputMode { get; }
Selector: primaryLanguage
Property: string PrimaryLanguage { get; }
Selector: activeInputModes
Property: UITextInputMode [] ActiveInputModes { get; }

Class UIPrintPaper

Selector: bestPaperForPageSize:withPapersFromArray
Method: UIPrintPaper ForPageSize (SizeF pageSize, UIPrintPaper [] paperList);
Selector: paperSize
Property: SizeF PaperSize { get; }
Selector: printableRect
Property: RectangleF PrintableRect { get; }

Class UIPrintPageRenderer

Selector: footerHeight
Property: float FooterHeight { get; set; }
Selector: headerHeight
Property: float HeaderHeight { get; set; }
Selector: paperRect
Property: RectangleF PaperRect { get; }
Selector: printableRect
Property: RectangleF PrintableRect { get; }
Selector: printFormatters
Property: UIPrintFormatter [] PrintFormatters { get; set; }
Selector: addPrintFormatter:startingAtPageAtIndex:
Method: void AddPrintFormatter (UIPrintFormatter formatter, int pageIndex);
Selector: drawContentForPageAtIndex:inRect:
Method: void DrawContentForPage (int index, RectangleF contentRect);
Selector: drawFooterForPageAtIndex:inRect:
Method: void DrawFooterForPage (int index, RectangleF footerRect);
Selector: drawHeaderForPageAtIndex:inRect:
Method: void DrawHeaderForPage (int index, RectangleF headerRect);
Selector: drawPageAtIndex:inRect:
Method: void DrawPage (int index, RectangleF pageRect);
Selector: drawPrintFormatter:forPageAtIndex:
Method: void DrawPrintFormatterForPage (UIPrintFormatter printFormatter, int index);
Selector: numberOfPages
Property: int NumberOfPages { get; }
Selector: prepareForDrawingPages:
Method: void PrepareForDrawingPages (NSRange range);
Selector: printFormattersForPageAtIndex:
Method: UIPrintFormatter [] PrintFormattersForPage (int index);

Class UIPrintInteractionControllerDelegate

Selector: printInteractionControllerParentViewController:"), DefaultValue (null), DelegateName ("UIPrintInteraction
Method: UIViewController GetViewController (UIPrintInteractionController printInteractionController);
Selector: printInteractionController:choosePaper:"), DefaultValue (null), DelegateName ("UIPrintInteractionPaperList
Method: UIPrintPaper ChoosePaper (UIPrintInteractionController printInteractionController, UIPrintPaper [] paperList);
Selector: printInteractionControllerWillPresentPrinterOptions:"), EventArgs ("UIPrintInteraction
Method: void WillPresentPrinterOptions (UIPrintInteractionController printInteractionController);
Selector: printInteractionControllerDidPresentPrinterOptions:"), EventArgs ("UIPrintInteraction
Method: void DidPresentPrinterOptions (UIPrintInteractionController printInteractionController);
Selector: printInteractionControllerWillDismissPrinterOptions:"), EventArgs ("UIPrintInteraction
Method: void WillDismissPrinterOptions (UIPrintInteractionController printInteractionController);
Selector: printInteractionControllerDidDismissPrinterOptions:"), EventArgs ("UIPrintInteraction
Method: void DidDismissPrinterOptions (UIPrintInteractionController printInteractionController);
Selector: printInteractionControllerWillStartJob:"), EventArgs ("UIPrintInteraction
Method: void WillStartJob (UIPrintInteractionController printInteractionController);
Selector: printInteractionControllerDidFinishJob:"), EventArgs ("UIPrintInteraction
Method: void DidFinishJob (UIPrintInteractionController printInteractionController);

Class UIPrintInteractionController

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: printFormatter
Property: UIPrintFormatter PrintFormatter { get; set; }
Selector: printInfo
Property: UIPrintInfo PrintInfo { get; set; }
Selector: printingItem
Property: NSObject PrintingItem { get; set; }
Selector: printingItems
Property: NSObject [] PrintingItems { get; set; }
Selector: printPageRenderer
Property: UIPrintPageRenderer PrintPageRenderer { get; set; }
Selector: printPaper
Property: UIPrintPaper PrintPaper { get; }
Selector: showsPageRange
Property: bool ShowsPageRange { get; set; }
Selector: canPrintData:
Method: bool CanPrint (NSData data);
Selector: canPrintURL:
Method: bool CanPrint (NSUrl url);
Selector: printingAvailable
Property: bool PrintingAvailable { [Bind ("isPrintingAvailable")] get; }
Selector: printableUTIs
Property: NSSet PrintableUTIs { get; }
Selector: sharedPrintController
Property: UIPrintInteractionController SharedPrintController { get; }
Selector: dismissAnimated:
Method: void Dismiss (bool animated);
Selector: presentAnimated:completionHandler:
Method: void Present (bool animated, UIPrintInteractionCompletionHandler completion);
Selector: presentFromBarButtonItem:animated:completionHandler:
Method: void PresentFromBarButtonItem (UIBarButtonItem item, bool animated, UIPrintInteractionCompletionHandler completion);
Selector: presentFromRect:inView:animated:completionHandler:
Method: void PresentFromRectInView (RectangleF rect, UIView view, bool animated, UIPrintInteractionCompletionHandler completion);

Class UIPrintInfo

Selector: duplex
Property: UIPrintInfoDuplex Duplex { get; set; }
Selector: jobName
Property: string JobName { get; set; }
Selector: orientation
Property: UIPrintInfoOrientation Orientation { get; set; }
Selector: outputType
Property: UIPrintInfoOutputType OutputType { get; set; }
Selector: printerID
Property: string PrinterID { get; set; }
Selector: printInfo
Property: UIPrintInfo PrintInfo { get; }
Selector: printInfoWithDictionary:
Method: UIPrintInfo FromDictionary (NSDictionary dictionary);
Selector: dictionaryRepresentation
Property: NSDictionary ToDictionary { get; }

Class UIViewPrintFormatter

Selector: view
Property: UIView View { get; }

Class UISimpleTextPrintFormatter

Selector: color
Property: UIColor Color { get; set; }
Selector: font
Property: UIFont Font { get; set; }
Selector: lineBreakMode
Property: UILineBreakMode LineBreakMode { get; set; }
Selector: text
Property: string Text { get; set; }
Selector: textAlignment
Property: UITextAlignment TextAlignment { get; set; }
Selector: initWithText:
Method: IntPtr Constructor (string text);

Class UIPrintFormatter

Selector: contentInsets
Property: UIEdgeInsets ContentInsets { get; set; }
Selector: maximumContentHeight
Property: float MaximumContentHeight { get; set; }
Selector: maximumContentWidth
Property: float MaximumContentWidth { get; set; }
Selector: pageCount
Property: int PageCount { get; }
Selector: printPageRenderer
Property: UIPrintPageRenderer PrintPageRenderer { get; }
Selector: startPage
Property: int StartPage { get; set; }
Selector: drawInRect:forPageAtIndex:
Method: void DrawRect (RectangleF rect, int pageIndex);
Selector: rectForPageAtIndex:
Method: RectangleF RectangleForPage (int pageIndex);
Selector: removeFromPrintPageRenderer
Method: void RemoveFromPrintPageRenderer ();

Class UIMarkupTextPrintFormatter

Selector: markupText
Property: string MarkupText { get; set; }
Selector: initWithMarkupText:
Method: IntPtr Constructor (string text);

Namespace MonoTouch.MapKit

Class MKAnnotation

Selector: coordinate
Property: CLLocationCoordinate2D Coordinate { get; set; }
Selector: title
Property: string Title { get; }
Selector: subtitle
Property: string Subtitle { get; }

Class MKOverlay

Selector: boundingMapRect
Property: MKMapRect BoundingMapRect { get; }
Selector: intersectsMapRect:
Method: bool Intersects (MKMapRect rect);

Class MKAnnotationView

Selector: initWithAnnotation:reuseIdentifier:
Method: IntPtr Constructor (NSObject annotation, string reuseIdentifier);
Selector: reuseIdentifier
Property: string ReuseIdentifier { get; }
Selector: prepareForReuse
Method: void PrepareForReuse ();
Selector: annotation
Property: NSObject Annotation { get; [NullAllowed] set; }
Selector: image
Property: UIImage Image { get; set; }
Selector: centerOffset
Property: PointF CenterOffset { get; set; }
Selector: calloutOffset
Property: PointF CalloutOffset { get; set; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: highlighted
Property: bool Highlighted { [Bind ("isHighlighted")] get; set; }
Selector: selected
Property: bool Selected { [Bind ("isSelected")] get; set; }
Selector: setSelected:animated:
Method: void SetSelected (bool selected, bool animated);
Selector: canShowCallout
Property: bool CanShowCallout { get; set; }
Selector: leftCalloutAccessoryView
Property: UIView LeftCalloutAccessoryView { get; set; }
Selector: rightCalloutAccessoryView
Property: UIView RightCalloutAccessoryView { get; set; }
Selector: setDragState:animated:
Method: void SetDragState (MKAnnotationViewDragState newDragState, bool animated);
Selector: dragState
Method: [Since (4,0)]
Selector: draggable
Property: bool Draggable { [Bind ("isDraggable")] get; set; }

Class MKCircle

Selector: radius
Property: double Radius { get; }
Selector: boundingMapRect
Property: MKMapRect BoundingMap { get; }
Selector: circleWithCenterCoordinate:radius:
Method: MKCircle Circle (CLLocationCoordinate2D withcenterCoordinate, double radius);
Selector: circleWithMapRect:
Method: MKCircle CircleWithMapRect (MKMapRect mapRect);

Class MKCircleView

Selector: circle
Property: MKCircle Circle { get; }
Selector: initWithCircle:
Method: IntPtr Constructor (MKCircle circle);

Class MKMapView

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: mapType
Property: MKMapType MapType { get; set; }
Selector: region
Property: MKCoordinateRegion Region { get; set; }
Selector: setRegion:animated:
Method: void SetRegion (MKCoordinateRegion region, bool animated);
Selector: centerCoordinate
Property: CLLocationCoordinate2D CenterCoordinate { get; set; }
Selector: setCenterCoordinate:animated:
Method: void SetCenterCoordinate (CLLocationCoordinate2D coordinate, bool animated);
Selector: regionThatFits:
Method: MKCoordinateRegion RegionThatFits (MKCoordinateRegion region);
Selector: convertCoordinate:toPointToView:
Method: PointF ConvertCoordinate (CLLocationCoordinate2D coordinate, [NullAllowed] UIView toPointToView);
Selector: convertPoint:toCoordinateFromView:
Method: CLLocationCoordinate2D ConvertPoint (PointF point, UIView toCoordinateFromView);
Selector: convertRegion:toRectToView:
Method: RectangleF ConvertRegion (MKCoordinateRegion region, [NullAllowed] UIView toRectToView);
Selector: convertRect:toRegionFromView:
Method: MKCoordinateRegion ConvertRect (RectangleF rect, UIView toRegiontFromView);
Selector: zoomEnabled
Property: bool ZoomEnabled { [Bind ("isZoomEnabled")] get; set; }
Selector: scrollEnabled
Property: bool ScrollEnabled { [Bind ("isScrollEnabled")] get; set; }
Selector: showsUserLocation
Property: bool ShowsUserLocation { get; set; }
Selector: userLocation
Property: MKUserLocation UserLocation { get; }
Selector: userLocationVisible
Property: bool UserLocationVisible { [Bind ("isUserLocationVisible")] get; }
Selector: addAnnotation:
Method: void AddAnnotationObject (NSObject annotation);
Selector: addAnnotations:
Method: void AddAnnotationObjects (NSObject [] annotations);
Selector: removeAnnotation:
Method: void RemoveAnnotation (NSObject annotation);
Selector: removeAnnotations:
Method: void RemoveAnnotations (NSObject [] annotations);
Selector: annotations
Property: NSObject [] Annotations { get; }
Selector: viewForAnnotation:
Method: MKAnnotationView ViewForAnnotation (MKAnnotation annotation);
Selector: dequeueReusableAnnotationViewWithIdentifier:
Method: MKAnnotationView DequeueReusableAnnotation (string withViewIdentifier);
Selector: selectAnnotation:animated:
Method: void SelectAnnotation (NSObject annotation, bool animated);
Selector: deselectAnnotation:animated:
Method: void DeselectAnnotation (MKAnnotation annotation, bool animated);
Selector: selectedAnnotations
Property: NSObject [] SelectedAnnotations { get; set; }
Selector: annotationVisibleRect
Property: RectangleF AnnotationVisibleRect { get; }
Selector: addOverlay:")][PostGet ("Overlays
Method: void AddOverlay (NSObject overlay);
Selector: addOverlays:")][PostGet ("Overlays
Method: void AddOverlays (NSObject [] overlays);
Selector: removeOverlay:")][PostGet ("Overlays
Method: void RemoveOverlay (NSObject overlay);
Selector: removeOverlays:")][PostGet ("Overlays
Method: void RemoveOverlays (NSObject [] overlays);
Selector: overlays
Property: NSObject [] Overlays { get; }
Selector: insertOverlay:atIndex:")][PostGet ("Overlays
Method: void InsertOverlay (NSObject overlay, int index);
Selector: insertOverlay:aboveOverlay:")][PostGet ("Overlays
Method: void InsertOverlayAbove (NSObject overlay, NSObject sibling);
Selector: insertOverlay:belowOverlay:")][PostGet ("Overlays
Method: void InsertOverlayBelow (NSObject overlay, NSObject sibling);
Selector: exchangeOverlayAtIndex:withOverlayAtIndex:
Method: void ExchangeOverlays (int index1, int index2);
Selector: mapRectThatFits:
Method: MKMapRect MapRectThatFits (MKMapRect mapRect);
Selector: setVisibleMapRect:edgePadding:animated:
Method: void SetVisibleMapRect (MKMapRect mapRect, UIEdgeInsets edgePadding, bool animate);
Selector: setVisibleMapRect:animated:
Method: void SetVisibleMapRect (MKMapRect mapRect, bool animate);
Selector: mapRectThatFits:edgePadding:
Method: MKMapRect MapRectThatFits (MKMapRect mapRect, UIEdgeInsets edgePadding);
Selector: viewForOverlay:
Method: MKOverlayView ViewForOverlay (NSObject overlay);
Selector: visibleMapRect
Property: MKMapRect visibleMapRect { get; set; }
Selector: annotationsInMapRect:
Method: NSSet GetAnnotations (MKMapRect mapRect);
Selector: userTrackingMode
Property: MKUserTrackingMode UserTrackingMode { get; set; }
Selector: setUserTrackingMode:animated:
Method: void SetUserTrackingMode (MKUserTrackingMode trackingMode, bool animated);

Class MKMapViewDelegate

Selector: mapView:regionWillChangeAnimated:"), EventArgs ("MKMapViewChange
Method: void RegionWillChange (MKMapView mapView, bool animated);
Selector: mapView:regionDidChangeAnimated:"), EventArgs ("MKMapViewChange
Method: void RegionChanged (MKMapView mapView, bool animated);
Selector: mapViewWillStartLoadingMap:
Method: void WillStartLoadingMap (MKMapView mapView);
Selector: mapViewDidFinishLoadingMap:
Method: void MapLoaded (MKMapView mapView);
Selector: mapViewDidFailLoadingMap:withError:"), EventArgs ("NSError
Method: void LoadingMapFailed (MKMapView mapView, NSError error);
Selector: mapView:viewForAnnotation:"), DelegateName ("MKMapViewAnnotation
Method: MKAnnotationView GetViewForAnnotation (MKMapView mapView, NSObject annotation);
Selector: mapView:didAddAnnotationViews:"), EventArgs ("MKMapViewAnnotation
Method: void DidAddAnnotationViews (MKMapView mapView, MKAnnotationView [] views);
Selector: mapView:annotationView:calloutAccessoryControlTapped:"), EventArgs ("MKMapViewAccessoryTapped
Method: void CalloutAccessoryControlTapped (MKMapView mapView, MKAnnotationView view, UIControl control);
Selector: mapView:annotationView:didChangeDragState:fromOldState:"), EventArgs ("MKMapViewDragState
Method: void ChangedDragState (MKMapView mapView, MKAnnotationView annotationView, MKAnnotationViewDragState newState, MKAnnotationViewDragState oldState);
Selector: mapView:viewForOverlay:"), DelegateName ("MKMapViewOverlay
Method: MKOverlayView GetViewForOverlay (MKMapView mapView, NSObject overlay);
Selector: mapView:didAddOverlayViews:"), EventArgs ("MKOverlayViews
Method: void DidAddOverlayViews (MKMapView mapView, MKOverlayView overlayViews);
Selector: mapView:didSelectAnnotationView:"), EventArgs ("MKAnnotationView
Method: void DidSelectAnnotationView (MKMapView mapView, MKAnnotationView view);
Selector: mapView:didFailToLocateUserWithError:"), EventArgs ("NSError
Method: void DidFailToLocateUser (MKMapView mapView, NSError error);
Selector: mapView:didDeselectAnnotationView:"), EventArgs ("MKAnnotationView
Method: void DidDeselectAnnotationView (MKMapView mapView, MKAnnotationView view);
Selector: mapViewWillStartLocatingUser:
Method: void WillStartLocatingUser (MKMapView mapView);
Selector: mapViewDidStopLocatingUser:
Method: void DidStopLocatingUser (MKMapView mapView);
Selector: mapView:didUpdateUserLocation:"), EventArgs ("MKUserLocation
Method: void DidUpdateUserLocation (MKMapView mapView, MKUserLocation userLocation);
Selector: mapView:didChangeUserTrackingMode:animated:"), EventArgs ("MMapViewUserTracking
Method: void DidChageUserTrackingMode (MKMapView mapView, MKUserTrackingMode mode, bool animated);

Class MKPinAnnotationView

Selector: initWithAnnotation:reuseIdentifier:
Method: IntPtr Constructor (NSObject annotation, string reuseIdentifier);
Selector: pinColor
Property: MKPinAnnotationColor PinColor { get; set; }
Selector: animatesDrop
Property: bool AnimatesDrop { get; set; }

Class MKPlacemark : MKAnnotation

Selector: initWithCoordinate:addressDictionary:
Method: IntPtr Constructor (CLLocationCoordinate2D coordinate, NSDictionary addressDictionary);
Selector: countryCode
Property: string CountryCode { get; }

Class MKReverseGeocoder

Selector: initWithCoordinate:
Method: IntPtr Constructor (CLLocationCoordinate2D coordinate);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: coordinate
Property: CLLocationCoordinate2D coordinate { get; }
Selector: start
Method: void Start ();
Selector: querying
Property: bool Querying { [Bind ("isQuerying")] get; }
Selector: cancel
Method: void Cancel ();
Selector: placemark
Property: MKPlacemark Placemark { get; }

Class MKReverseGeocoderDelegate

Selector: reverseGeocoder:didFailWithError:
Method: void FailedWithError (MKReverseGeocoder geocoder, NSError error);
Selector: reverseGeocoder:didFindPlacemark:
Method: void FoundWithPlacemark (MKReverseGeocoder geocoder, MKPlacemark placemark);

Class MKOverlayView

Selector: overlay
Property: NSObject Overlay { get; }
Selector: initWithOverlay:
Method: IntPtr Constructor (NSObject overlay);
Selector: pointForMapPoint:
Method: PointF PointForMapPoint (MKMapPoint mapPoint);
Selector: mapPointForPoint:
Method: MKMapPoint MapPointForPoint (PointF point);
Selector: rectForMapRect:
Method: RectangleF RectForMapRect (MKMapRect mapRect);
Selector: mapRectForRect:
Method: MKMapRect MapRectForRect (RectangleF rect);
Selector: canDrawMapRect:zoomScale:
Method: bool CanDrawMapRect (MKMapRect mapRect, float zoomScale);
Selector: drawMapRect:zoomScale:inContext:
Method: void DrawMapRect (MKMapRect mapRect, float zoomScale, CGContext context);
Selector: setNeedsDisplayInMapRect:
Method: void SetNeedsDisplay (MKMapRect mapRect);
Selector: setNeedsDisplayInMapRect:zoomScale:
Method: void SetNeedsDisplay (MKMapRect mapRect, float zoomScale);

Class MKOverlayPathView

Selector: fillColor
Property: UIColor FillColor { get; set; }
Selector: strokeColor
Property: UIColor StrokeColor { get; set; }
Selector: lineWidth
Property: float LineWidth { get; set; }
Selector: lineJoin
Property: CGLineJoin LineJoin { get; set; }
Selector: lineCap
Property: CGLineCap Linecap { get; set; }
Selector: miterLimit
Property: float MiterLimit { get; set; }
Selector: lineDashPhase
Property: float LineDashPhase { get; set; }
Selector: lineDashPattern
Property: NSNumber [] LineDashPattern { get; set; }
Selector: path
Property: CGPath Path { get; set; }
Selector: createPath
Method: void CreatePath ();
Selector: invalidatePath
Method: void InvalidatePath ();
Selector: applyStrokePropertiesToContext:atZoomScale:
Method: void ApplyStrokeProperties (CGContext context, float zoomScale);
Selector: applyFillPropertiesToContext:atZoomScale:
Method: void ApplyFillProperties (CGContext context, float zoomScale);
Selector: strokePath:inContext:
Method: void StrokePath (CGPath path, CGContext context);
Selector: fillPath:inContext:
Method: void FillPath (CGPath path, CGContext context);

Class MKShape

Selector: title
Property: string Title { get; set; }
Selector: subtitle
Property: string Subtitle { get; set; }

Class MKPointAnnotation

Class MKPolygonView

Selector: initWithPolygon:
Method: IntPtr Constructor (MKPolygon polygon);
Selector: polygon
Property: MKPolygon Polygon { get; }

Class MKPolygon

Selector: interiorPolygons
Property: MKPolygon [] InteriorPolygons { get; }
Selector: polygonWithPoints:count:
Method: MKPolygon _FromPoints (IntPtr points, int count);
Selector: polygonWithPoints:count:interiorPolygons:
Method: MKPolygon _FromPoints (IntPtr points, int count, MKPolygon [] interiorPolygons);
Selector: polygonWithCoordinates:count:
Method: MKPolygon _FromCoordinates (IntPtr coords, int count);
Selector: polygonWithCoordinates:count:interiorPolygons:
Method: MKPolygon _FromCoordinates (IntPtr coords, int count, MKPolygon [] interiorPolygons);

Class MKPolyline

Selector: polylineWithCoordinates:count:
Method: [Internal]
Selector: boundingMapRect
Property: MKMapRect BoundingMapRect { get; }
Selector: intersectsMapRect:
Method: bool Intersects (MKMapRect rect);
Selector: coordinate
Property: CLLocationCoordinate2D Coordinate { get; set; }
Selector: title
Property: string Title { get; }
Selector: subtitle
Property: string Subtitle { get; }

Class MKPolylineView

Selector: initWithPolyline:
Method: IntPtr Constructor (MKPolyline polyline);
Selector: polyline
Property: MKPolyline Polyline { get; }

Class MKMultiPoint

Selector: points
Property: IntPtr _Points { get; }
Selector: pointCount
Property: int PointCount { get; }
Selector: getCoordinates:range:
Method: void GetCoords (IntPtr dest, NSRange range);

Class MKUserLocation

Selector: updating
Property: bool Updating { [Bind ("isUpdating")] get; }
Selector: coordinate
Property: CLLocationCoordinate2D Coordinate { get; set; }
Selector: location
Property: CLLocation Location { get; }
Selector: title
Property: string Title { get; set; }
Selector: subtitle
Property: string Subtitle { get; set; }
Selector: heading
Property: CLHeading Heading { get; }

Class MKUserTrackingBarButtonItem

Selector: mapView
Property: MKMapView MapView { get; set; }
Selector: initWithMapView:
Method: IntPtr Constructor (MKMapView mapView);

Namespace MonoTouch.OpenGLES

Class EAGLSharegroup

Class EAGLContext

Selector: initWithAPI:
Method: IntPtr Constructor (EAGLRenderingAPI api);
Selector: initWithAPI:sharegroup:
Method: IntPtr Constructor (EAGLRenderingAPI api, EAGLSharegroup sharegroup);
Selector: setCurrentContext:
Method: bool SetCurrentContext([NullAllowed] EAGLContext context);
Selector: currentContext
Property: EAGLContext CurrentContext { get; }
Selector: API
Property: EAGLRenderingAPI API { get; }
Selector: sharegroup
Property: EAGLSharegroup ShareGroup { get; }
Selector: renderbufferStorage:fromDrawable:
Method: bool RenderBufferStorage (uint target, MonoTouch.CoreAnimation.CAEAGLLayer drawable);
Selector: presentRenderbuffer:
Method: bool PresentRenderBuffer (uint target);

Namespace MonoTouch.AddressBookUI

Class ABNewPersonViewController

Selector: displayedPerson
Property: IntPtr _DisplayedPerson { get; set; }
Selector: addressBook
Property: IntPtr _AddressBook { get; set; }
Selector: parentGroup
Property: IntPtr _ParentGroup {get; set;}
Selector: newPersonViewDelegate
Property: NSObject WeakDelegate { get; set; }

Class ABNewPersonViewControllerDelegate

Selector: newPersonViewController:didCompleteWithNewPerson:
Method: void DidCompleteWithNewPerson (ABNewPersonViewController controller, IntPtr person);

Class ABPeoplePickerNavigationController

Selector: displayedProperties
Property: NSNumber[] _DisplayedProperties {get; set;}
Selector: addressBook
Property: IntPtr _AddressBook {get; set;}
Selector: peoplePickerDelegate
Property: NSObject WeakDelegate {get; set;}

Class ABPeoplePickerNavigationControllerDelegate

Selector: peoplePickerNavigationController:shouldContinueAfterSelectingPerson:
Method: bool ShouldContinue (ABPeoplePickerNavigationController peoplePicker, IntPtr selectedPerson);
Selector: peoplePickerNavigationController:shouldContinueAfterSelectingPerson:property:identifier:
Method: bool ShouldContinue (ABPeoplePickerNavigationController peoplePicker, IntPtr selectedPerson, int propertyId, int identifier);
Selector: peoplePickerNavigationControllerDidCancel:
Method: void Cancelled (ABPeoplePickerNavigationController peoplePicker);

Class ABPersonViewController

Selector: displayedPerson
Property: IntPtr _DisplayedPerson {get; set;}
Selector: displayedProperties
Property: NSNumber[] _DisplayedProperties { get; set; }
Selector: addressBook
Property: IntPtr _AddressBook {get; set;}
Selector: allowsEditing
Property: bool AllowsEditing {get; set;}
Selector: personViewDelegate
Property: NSObject WeakDelegate {get; set;}
Selector: setHighlightedItemForProperty:withIdentifier:
Method: void SetHighlightedItemForProperty (int property, int identifier);

Class ABPersonViewControllerDelegate

Selector: personViewController:shouldPerformDefaultActionForPerson:property:identifier:
Method: bool ShouldPerformDefaultActionForPerson (ABPersonViewController personViewController, IntPtr person, int propertyId, int identifier);

Class ABUnknownPersonViewController

Selector: alternateName
Property: string AlternateName {get; set;}
Selector: message
Property: string Message {get; set;}
Selector: displayedPerson
Property: IntPtr _DisplayedPerson {get; set;}
Selector: addressBook
Property: IntPtr _AddressBook {get; set;}
Selector: allowsActions
Property: bool AllowsActions {get; set;}
Selector: allowsAddingToAddressBook
Property: bool AllowsAddingToAddressBook {get; set;}
Selector: unknownPersonViewDelegate
Property: NSObject WeakDelegate {get; set;}

Class ABUnknownPersonViewControllerDelegate

Selector: unknownPersonViewController:didResolveToPerson:
Method: void DidResolveToPerson (ABUnknownPersonViewController unknownPersonView, IntPtr person);
Selector: unknownPersonViewController:shouldPerformDefaultActionForPerson:property:identifier:
Method: bool ShouldPerformDefaultActionForPerson (ABUnknownPersonViewController personViewController, IntPtr person, int propertyId, int identifier);

Namespace MonoTouch.ExternalAccessory

Class EAAccessory

Selector: connected
Property: bool Connected { [Bind ("isConnected")] get; }
Selector: connectionID
Property: uint ConnectionID { get; }
Selector: name
Property: string Name { get; }
Selector: manufacturer
Property: string Manufacturer { get; }
Selector: modelNumber
Property: string ModelNumber { get; }
Selector: serialNumber
Property: string SerialNumber { get; }
Selector: firmwareRevision
Property: string FirmwareRevision { get; }
Selector: hardwareRevision
Property: string HardwareRevision { get; }
Selector: protocolStrings
Property: string[] ProtocolStrings { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class EAAccessoryDelegate

Selector: accessoryDidDisconnect:"), EventArgs ("EAAccessory
Method: void Disconnected (EAAccessory accessory);

Class EAAccessoryManager

Selector: sharedAccessoryManager
Method: EAAccessoryManager SharedAccessoryManager { get ; }
Selector: registerForLocalNotifications
Method: void RegisterForLocalNotifications ();
Selector: unregisterForLocalNotifications
Method: void UnregisterForLocalNotifications ();
Selector: connectedAccessories
Method: EAAccessory [] ConnectedAccessories { get ; }

Class EASession

Selector: initWithAccessory:forProtocol:
Method: IntPtr Constructor (EAAccessory accessory, string protocol);
Selector: accessory
Property: EAAccessory Accessory { get; }
Selector: protocolString
Property: string ProtocolString { get; }
Selector: inputStream
Property: NSInputStream InputStream { get; }
Selector: outputStream
Property: NSOutputStream OutputStream { get; }

Namespace MonoTouch.iAd

Class ADBannerView

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: bannerLoaded
Property: bool BannerLoaded { [Bind ("isBannerLoaded")] get; }
Selector: advertisingSection
Property: string AdvertisingSection { get; set; }
Selector: bannerViewActionInProgress
Property: bool BannerViewActionInProgress { [Bind ("isBannerViewActionInProgress")] get; }
Selector: requiredContentSizeIdentifiers
Property: NSSet RequiredContentSizeIdentifiers { get; set; }
Selector: cancelBannerViewAction
Method: void CancelBannerViewAction ();
Selector: currentContentSizeIdentifier
Property: string CurrentContentSizeIdentifier { get; set; }
Selector: sizeFromBannerContentSizeIdentifier:
Method: SizeF SizeFromContentSizeIdentifier (string sizeIdentifier);

Class ADBannerViewDelegate

Selector: bannerViewDidLoadAd:
Method: void AdLoaded (ADBannerView banner);
Selector: bannerView:didFailToReceiveAdWithError:"), EventArgs ("AdError
Method: void FailedToReceiveAd (ADBannerView banner, NSError error);
Selector: bannerViewActionShouldBegin:willLeaveApplication:"), DelegateName ("AdAction
Method: bool ActionShouldBegin (ADBannerView banner, bool willLeaveApplication);
Selector: bannerViewActionDidFinish:
Method: void ActionFinished (ADBannerView banner);
Selector: bannerViewWillLoadAd"), EventArgs ("EventArgs
Method: void WillLoad (ADBannerView bannerView);

Class ADInterstitialAd

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: loaded
Property: bool Loaded { [Bind ("isLoaded")] get; }
Selector: actionInProgress
Property: bool ActionInProgress { [Bind ("isActionInProgress")] get; }
Selector: cancelAction
Method: void CancelAction ();
Selector: presentInView:
Method: bool PresentInView (UIView containerView);
Selector: presentFromViewController:
Method: void PresentFromViewController (UIViewController viewController);

Class ADInterstitialAdDelegate

Selector: interstitialAdDidUnloadAd:
Method: void AdUnloaded (ADInterstitialAd interstitialAd);
Selector: interstitialAd:didFailWithError:"), EventArgs ("ADError
Method: void FailedToReceiveAd (ADInterstitialAd interstitialAd, NSError error);
Selector: interstitialAdDidLoad:
Method: void AdLoaded (ADInterstitialAd interstitialAd);
Selector: interstitialAdActionShouldBegin:willLeaveApplication:"), DelegateName ("ADPredicate
Method: bool ActionShouldBegin (ADInterstitialAd interstitialAd, bool willLeaveApplication);
Selector: interstitialAdActionDidFinish:
Method: void ActionFinished (ADInterstitialAd interstitialAd);
Selector: interstitialAdWillLoad:"), EventArgs ("EventArgs
Method: void WillLoad (ADInterstitialAd interstitialAd);

Class ADManager

Namespace MonoTouch.CoreTelephony

Class CTCall

Selector: callID
Property: string CallID { get; }
Selector: callState
Property: string CallState { get; }

Class CTTelephonyNetworkInfo

Selector: subscriberCellularProvider
Property: CTCarrier SubscriberCellularProvider { get; }
Selector: subscriberCellularProviderDidUpdateNotifier
Property: CTCarrierEventHandler CellularProviderUpdatedEventHandler { get; set; }

Class CTCallCenter

Selector: callEventHandler
Property: CTCallEventHandler CallEventHandler { get; set; }
Selector: currentCalls
Property: NSSet CurrentCalls { get; }

Class CTCarrier

Selector: mobileCountryCode
Property: string MobileCountryCode { get; }
Selector: mobileNetworkCode
Property: string MobileNetworkCode { get; }
Selector: isoCountryCode
Property: string IsoCountryCode { get; }
Selector: allowsVOIP
Property: bool AllowsVoip { get; }
Selector: carrierName
Property: string CarrierName { get; }

Namespace MonoTouch.EventKit

Class EKObject

Selector: hasChanges
Property: bool HasChanges { get; }
Selector: isNew
Property: bool IsNew { get; }
Selector: reset
Method: void Reset ();
Selector: rollback
Method: void Rollback ();
Selector: refresh
Method: bool Refresh ();

Class EKCalendarItem

Selector: UUID
Property: string UUID { get; }
Selector: calendar
Property: EKCalendar Calendar { get; set; }
Selector: title
Property: string Title { get; set; }
Selector: location
Property: string Location { get; set; }
Selector: notes
Property: string Notes { get; set; }
Selector: URL
Property: NSUrl Url { get; set; }
Selector: lastModifiedDate
Property: NSDate LastModifiedDate { get; }
Selector: creationDate
Property: NSDate CreationDate { get; }
Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: hasAlarms
Property: bool HasAlarms { get; }
Selector: hasRecurrenceRules
Property: bool HasRecurrenceRules { get; }
Selector: hasAttendees
Property: bool HasAttendees { get; }
Selector: hasNotes
Property: bool HasNotes { get; }
Selector: attendees
Property: EKParticipant [] Attendees { get; }
Selector: alarms
Property: EKAlarm [] Alarms { get; set; }
Selector: recurrenceRules
Property: EKRecurrenceRule [] RecurrenceRules { get; set; }
Selector: addAlarm:
Method: void AddAlarm (EKAlarm alarm);
Selector: removeAlarm:
Method: void RemoveAlarm (EKAlarm alarm);
Selector: addRecurrenceRule:
Method: void AddRecurrenceRule (EKRecurrenceRule rule);
Selector: removeRecurrenceRule:
Method: void RemoveRecurrenceRule (EKRecurrenceRule rule);

Class EKSource

Selector: sourceType
Property: EKSourceType SourceType { get; }
Selector: title
Property: string Title { get; }
Selector: calendars
Property: NSSet Calendars { get; }
Selector: sourceIdentifier
Property: string SourceIdentifier { get; }

Class EKAlarm

Selector: relativeOffset
Property: double RelativeOffset { get; set; }
Selector: absoluteDate
Property: NSDate AbsoluteDate { get; set; }
Selector: alarmWithAbsoluteDate:
Method: EKAlarm FromDate (NSDate date);
Selector: alarmWithRelativeOffset:
Method: EKAlarm FromTimeInterval (double offsetSeconds);

Class EKCalendar

Selector: title
Property: string Title { get; }
Selector: type
Property: EKCalendarType Type { get; }
Selector: allowsContentModifications
Property: bool AllowsContentModifications { get; }
Selector: CGColor
Property: CGColor CGColor { get; }
Selector: supportedEventAvailabilities
Property: EKCalendarEventAvailability SupportedEventAvailabilities { get; }
Selector: calendarIdentifier
Property: string CalendarIdentifier { get; }
Selector: subscribed
Property: bool Subscribed { [Bind ("isSubscribed")] get; }
Selector: immutable
Property: bool Immutable { [Bind ("isImmutable")] get; }
Selector: calendarWithEventStore:
Method: EKCalendar FromEventStore (EKEventStore eventStore);
Selector: source
Property: EKSource Source { get; set; }

Class EKEvent

Selector: eventWithEventStore:
Method: EKEvent FromStore (EKEventStore eventStore);
Selector: allDay
Property: bool AllDay { [Bind ("isAllDay")] get; set; }
Selector: startDate
Property: NSDate StartDate { get; set; }
Selector: endDate
Property: NSDate EndDate { get; set; }
Selector: organizer
Property: EKParticipant Organizer { get; }
Selector: recurrenceRule
Property: EKRecurrenceRule RecurrenceRule { get; set; }
Selector: isDetached
Property: bool IsDetached { get; }
Selector: eventIdentifier
Property: string EventIdentifier { get; }
Selector: compareStartDateWithEvent:
Method: NSComparisonResult CompareStartDateWithEvent (EKEvent other);
Selector: refresh
Method: bool Refresh ();
Selector: availability
Property: EKEventAvailability Availability { get; set; }
Selector: status
Property: EKEventStatus Status { get; }
Selector: birthdayPersonID
Property: int birthdayPersonID { get; }

Class EKParticipant

Selector: URL
Property: NSUrl Url { get; }
Selector: name
Property: string Name { get; }
Selector: participantStatus
Property: EKParticipantStatus ParticipantStatus { get; }
Selector: participantRole
Property: EKParticipantRole ParticipantRole { get; }
Selector: participantType
Property: EKParticipantType ParticipantType { get; }
Selector: ABRecordWithAddressBook:
Method: //ABRecord ABRecordWithAddressBook (ABAddressBook addressBook);

Class EKRecurrenceEnd

Selector: endDate
Property: NSDate EndDate { get; }
Selector: occurrenceCount
Property: int OccurrenceCount { get; }
Selector: recurrenceEndWithEndDate:
Method: EKRecurrenceEnd FromEndDate (NSDate endDate);
Selector: recurrenceEndWithOccurrenceCount:
Method: EKRecurrenceEnd FromOccurrenceCount (int occurrenceCount);

Class EKRecurrenceDayOfWeek

Selector: dayOfTheWeek
Property: int DayOfTheWeek { get; }
Selector: weekNumber
Property: int WeekNumber { get; }
Selector: dayOfWeek:
Method: NSObject FromDay (EKDay dayOfTheWeek);
Selector: dayOfWeek:weekNumber:
Method: NSObject FromDay (EKDay dayOfTheWeek, int weekNumber);
Selector: initWithDayOfTheWeek:weekNumber:
Method: IntPtr Constructor (int dayOfTheWeek, int weekNumber);
Selector: dayOfWeek:weekNumber:
Method: EKRecurrenceDayOfWeek FromWeekDay (int dayOfWeek, int weekNumber);

Class EKRecurrenceRule

Selector: calendarIdentifier
Property: string CalendarIdentifier { get; }
Selector: recurrenceEnd
Property: EKRecurrenceEnd RecurrenceEnd { get; set; }
Selector: frequency
Property: EKRecurrenceFrequency Frequency { get; }
Selector: interval
Property: int Interval { get; }
Selector: firstDayOfTheWeek
Property: EKDay FirstDayOfTheWeek { get; }
Selector: daysOfTheWeek
Property: EKRecurrenceDayOfWeek [] DaysOfTheWeek { get; }
Selector: daysOfTheMonth
Property: NSNumber [] DaysOfTheMonth { get; }
Selector: daysOfTheYear
Property: NSNumber [] DaysOfTheYear { get; }
Selector: weeksOfTheYear
Property: NSNumber [] WeeksOfTheYear { get; }
Selector: monthsOfTheYear
Property: NSNumber [] MonthsOfTheYear { get; }
Selector: setPositions
Property: NSObject [] SetPositions { get; }
Selector: initRecurrenceWithFrequency:interval:end:
Method: IntPtr Constructor (EKRecurrenceFrequency type, int interval, EKRecurrenceEnd end);
Selector: initRecurrenceWithFrequency:interval:daysOfTheWeek:daysOfTheMonth:monthsOfTheYear:weeksOfTheYear:daysOfTheYear:setPositions:end:
Method: IntPtr Constructor (EKRecurrenceFrequency type, int interval, EKRecurrenceDayOfWeek [] days, NSNumber [] monthDays, NSNumber [] months,

Class EKEventStore

Selector: eventStoreIdentifier
Property: string EventStoreIdentifier { get; }
Selector: calendars
Property: EKCalendar [] Calendars { get; }
Selector: defaultCalendarForNewEvents
Property: EKCalendar DefaultCalendarForNewEvents { get; }
Selector: saveEvent:span:error:
Method: bool SaveEvent (EKEvent theEvent, EKSpan span, out NSError error);
Selector: removeEvent:span:error:
Method: bool RemoveEvents (EKEvent theEvent, EKSpan span, out NSError error);
Selector: eventWithIdentifier:
Method: EKEvent EventFromIdentifier (string identifier);
Selector: eventsMatchingPredicate:
Method: EKEvent [] EventsMatching (NSPredicate predicate);
Selector: enumerateEventsMatchingPredicate:usingBlock:
Method: void EnumerateEvents (NSPredicate predicate, EKEventSearchCallback block);
Selector: predicateForEventsWithStartDate:endDate:calendars:
Method: NSPredicate PredicateForEvents (NSDate startDate, NSDate endDate, [NullAllowed] EKCalendar [] calendars);
Selector: sources
Property: EKSource [] Sources { get; }
Selector: sourceWithIdentifier:
Method: EKSource GetSource (string identifier);
Selector: calendarWithIdentifier:
Method: EKCalendar GetCalendar (string identifier);
Selector: saveCalendar:commit:error:
Method: bool SaveCalendar (EKCalendar calendar, bool commit, out NSError error);
Selector: removeCalendar:commit:error:
Method: bool RemoveCalendarc (EKCalendar calendar, bool commit, out NSError error);
Selector: saveEvent:span:commit:error:
Method: bool SaveEvent (EKEvent ekEvent, EKSpan span, bool commit, out NSError error);
Selector: removeEvent:span:commit:error:
Method: bool RemoveEvent (EKEvent ekEvent, EKSpan span, bool commit, out NSError error);
Selector: commit:
Method: bool Commit (out NSError error);
Selector: reset
Method: void Reset ();
Selector: refreshSourcesIfNecessary
Method: void RefreshSourcesIfNecessary ();

Namespace MonoTouch.EventKitUI

Class EKEventViewController

Selector: event
Property: EKEvent Event { get; set; }
Selector: allowsEditing
Property: bool AllowsEditing { get; set; }
Selector: allowsCalendarPreview
Property: bool AllowsCalendarPreview { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }

Class EKEventViewDelegate

Selector: eventViewController:didCompleteWithAction:"), EventArgs ("EKEventView
Method: void Completed (EKEventViewController controller, EKEventViewAction action);

Class EKEventEditViewController

Selector: editViewDelegate
Property: NSObject WeakEditViewDelegate { get; set; }
Selector: eventStore
Property: EKEventStore EventStore { get; set; }
Selector: event
Property: EKEvent Event { get; set; }

Class EKEventEditViewDelegate

Selector: eventEditViewController:didCompleteWithAction:"), EventArgs ("EKEventEdit
Method: void Completed (EKEventEditViewController controller, EKEventEditViewAction action);
Selector: eventEditViewControllerDefaultCalendarForNewEvents:"), DelegateName ("EKEventEditController
Method: EKCalendar GetDefaultCalendarForNewEvents (EKEventEditViewController controller);

Class EKCalendarChooser

Selector: initWithSelectionStyle:displayStyle:eventStore:
Method: IntPtr Constructor (EKCalendarChooserSelectionStyle selectionStyle, EKCalendarChooserDisplayStyle displayStyle, EKEventStore eventStore);
Selector: selectionStyle
Property: EKCalendarChooserSelectionStyle SelectionStyle { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set;}
Selector: showsDoneButton
Property: bool ShowsDoneButton { get; set; }
Selector: showsCancelButton
Property: bool ShowsCancelButton { get; set; }
Selector: selectedCalendars
Property: NSSet SelectedCalendars { get; set; }

Class EKCalendarChooserDelegate

Selector: calendarChooserSelectionDidChange:
Method: void SelectionChanged (EKCalendarChooser calendarChooser);
Selector: calendarChooserDidFinish:
Method: void Finished (EKCalendarChooser calendarChooser);
Selector: calendarChooserDidCancel:
Method: void Cancelled (EKCalendarChooser calendarChooser);

Namespace MonoTouch.CoreMotion

Class CMAccelerometerData

Selector: acceleration
Property: CMAcceleration Acceleration { get; }

Class CMLogItem

Selector: timestamp
Property: double Timestamp { get; }

Class CMMotionManager

Selector: accelerometerAvailable
Property: bool AccelerometerAvailable { [Bind ("isAccelerometerAvailable")] get; }
Selector: accelerometerActive
Property: bool AccelerometerActive { [Bind ("isAccelerometerActive")] get; }
Selector: accelerometerData
Property: CMAccelerometerData AccelerometerData { get; }
Selector: accelerometerUpdateInterval
Property: double AccelerometerUpdateInterval { get; set; }
Selector: startAccelerometerUpdates
Method: void StartAccelerometerUpdates ();
Selector: startAccelerometerUpdatesToQueue:withHandler:
Method: void StartAccelerometerUpdates (NSOperationQueue queue, CMAccelerometerHandler handler);
Selector: stopAccelerometerUpdates
Method: void StopAccelerometerUpdates ();
Selector: deviceMotionUpdateInterval
Property: double DeviceMotionUpdateInterval { get; set; }
Selector: deviceMotionAvailable
Property: bool DeviceMotionAvailable { [Bind ("isDeviceMotionAvailable")] get; }
Selector: deviceMotionActive
Property: bool DeviceMotionActive { [Bind ("isDeviceMotionActive")] get; }
Selector: deviceMotion
Property: CMDeviceMotion DeviceMotion { get; }
Selector: gyroUpdateInterval
Property: double GyroUpdateInterval { get; set; }
Selector: gyroAvailable
Property: bool GyroAvailable { [Bind ("isGyroAvailable")] get; }
Selector: gyroActive
Property: bool GyroActive { [Bind ("isGyroActive")] get; }
Selector: gyroData
Property: CMGyroData GyroData { get; }
Selector: startGyroUpdates
Method: void StartGyroUpdates ();
Selector: startGyroUpdatesToQueue:withHandler:
Method: void StartGyroUpdates (NSOperationQueue toQueue, CMGyroHandler handler);
Selector: stopGyroUpdates
Method: void StopGyroUpdates ();
Selector: startDeviceMotionUpdates
Method: void StartDeviceMotionUpdates ();
Selector: startDeviceMotionUpdatesToQueue:withHandler:
Method: void StartDeviceMotionUpdates (NSOperationQueue toQueue, CMDeviceMotionHandler handler);
Selector: stopDeviceMotionUpdates
Method: void StopDeviceMotionUpdates ();
Selector: magnetometerUpdateInterval
Property: double MagnetometerUpdateInterval { get; set; }
Selector: magnetometerAvailable
Property: bool MagnetometerAvailable { [Bind ("isMagnetometerAvailable")] get; }
Selector: magnetometerActive
Property: bool MagnetometerActive { [Bind ("isMagnetometerActive")] get; set; }
Selector: magnetometerData
Property: CMMagnetometerData MagnetometerData { get; }
Selector: startMagnetometerUpdates
Method: void StartMagnetometerUpdates ();
Selector: startMagnetometerUpdatesToQueue:withHandler
Method: void StartMagnetometerUpdates (NSOperationQueue queue, CMMagnetometerHandler handler);
Selector: stopMagnetometerUpdates
Method: void StopMagnetometerUpdates ();
Selector: availableAttitudeReferenceFrames
Property: CMAttitudeReferenceFrame AvailableAttitudeReferenceFrames { get; }
Selector: attitudeReferenceFrame
Property: CMAttitudeReferenceFrame AttitudeReferenceFrame { get; }
Selector: startDeviceMotionUpdatesUsingReferenceFrame:
Method: void StartDeviceMotionUpdates (CMAttitudeReferenceFrame referenceFrame);
Selector: startDeviceMotionUpdatesUsingReferenceFrame:toQueue:withHandler:
Method: void StartDeviceMotionUpdates (CMAttitudeReferenceFrame referenceFrame, NSOperationQueue queue, CMMagnetometerHandler handler);
Selector: showsDeviceMovementDisplay
Property: bool ShowsDeviceMovementDisplay { get; set; }

Class CMAttitude

Selector: pitch
Property: double Pitch { get; }
Selector: yaw
Property: double Yaw { get; }
Selector: rotationMatrix
Property: CMRotationMatrix RotationMatrix { get; }
Selector: quaternion
Property: CMQuaternion Quaternion { get; }
Selector: roll
Property: double Roll { get; }
Selector: multiplyByInverseOfAttitude:
Method: void MultiplyByInverseOfAttitude (CMAttitude attitude);

Class CMDeviceMotion

Selector: rotationRate
Property: CMRotationRate RotationRate { get; }
Selector: gravity
Property: CMAcceleration Gravity { get; }
Selector: userAcceleration
Property: CMAcceleration UserAcceleration { get; }
Selector: attitude
Property: CMAttitude Attitude { get; }
Selector: magneticField
Property: CMCalibratedMagneticField MagneticField { get; }

Class CMGyroData

Selector: rotationRate
Property: CMRotationRate RotationRate { get; }

Class CMMagnetometerData

Selector: magneticField
Property: CMMagneticField MagneticField { get; }

Namespace MonoTouch.AssetsLibrary

Class ALAssetsLibrary

Selector: assetForURL:resultBlock:failureBlock:
Method: void AssetForUrl (NSUrl assetURL, ALAssetsLibraryAssetForURLResultDelegate resultBlock, ALAssetsLibraryAccessFailureDelegate failureBlock);
Selector: enumerateGroupsWithTypes:usingBlock:failureBlock:
Method: void Enumerate (ALAssetsGroupType types, ALAssetsLibraryGroupsEnumerationResultsDelegate enumerationBlock, ALAssetsLibraryAccessFailureDelegate failureBlock);
Selector: videoAtPathIsCompatibleWithSavedPhotosAlbum:
Method: bool VideoAtPathIsIsCompatibleWithSavedPhotosAlbum (NSUrl videoPathURL);
Selector: writeImageDataToSavedPhotosAlbum:metadata:completionBlock:
Method: void WriteImageToSavedPhotosAlbum (NSData imageData, NSDictionary metadata, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: writeImageToSavedPhotosAlbum:metadata:completionBlock:
Method: void WriteImageToSavedPhotosAlbum (UIImage imageData, NSDictionary metadata, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: writeImageToSavedPhotosAlbum:orientation:completionBlock:
Method: void WriteImageToSavedPhotosAlbum (UIImage imageData, ALAssetOrientation orientation, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: writeVideoAtPathToSavedPhotosAlbum:completionBlock:
Method: void WriteVideoToSavedPhotosAlbum (NSUrl videoPathURL, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: groupForURL:resultBlock:failureBlock:
Method: void GroupForUrl (NSUrl groupURL, ALAssetsLibraryGroupResult resultBlock, ALAssetsLibraryAccessFailure failureBlock);
Selector: addAssetsGroupAlbumWithName:resultBlock:failureBlock:
Method: void AddAssetsGroupAlbum (string name, ALAssetsLibraryGroupResult resultBlock, ALAssetsLibraryAccessFailure failureBlock);

Class ALAsset

Selector: valueForProperty:
Method: NSObject ValueForProperty (NSString property);
Selector: defaultRepresentation
Property: ALAssetRepresentation DefaultRepresentation { get; }
Selector: representationForUTI:
Method: ALAssetRepresentation RepresentationForUti (string uti);
Selector: thumbnail
Property: CGImage Thumbnail { get; }
Selector: originalAsset
Property: ALAsset OriginalAsset { get; }
Selector: editable
Property: bool Editable { [Bind ("isEditable")] get; }
Selector: aspectRatioThumbnail
Method: CGImage AspectRatioThumbnail ();
Selector: writeModifiedImageDataToSavedPhotosAlbum:metadata:completionBlock:
Method: void WriteModifiedImageToSavedToPhotosAlbum (NSData imageData, NSDictionary metadata, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: writeModifiedVideoAtPathToSavedPhotosAlbum:completionBlock:
Method: void WriteModifiedVideoToSavedPhotosAlbum (NSUrl videoPathURL, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: setImageData:metadata:completionBlock:
Method: void SetImageData (NSData imageData, NSDictionary metadata, ALAssetsLibraryWriteCompletionDelegate completionBlock);
Selector: setVideoAtPath:completionBlock:
Method: void SetVideoAtPath (NSUrl videoPathURL, ALAssetsLibraryWriteCompletionDelegate completionBlock);

Class ALAssetRepresentation

Selector: UTI
Property: string Uti { get; }
Selector: size
Property: long Size { get; }
Selector: getBytes:fromOffset:length:error:
Method: uint GetBytes (IntPtr buffer, long offset, uint length, out NSError error);
Selector: fullResolutionImage
Method: CGImage GetImage ();
Selector: CGImageWithOptions
Method: CGImage GetImage (NSDictionary options);
Selector: fullScreenImage
Method: CGImage GetFullScreenImage ();
Selector: url
Property: NSUrl Url { get; }
Selector: metadata
Property: NSDictionary Metadata { get; }
Selector: orientation
Property: ALAssetOrientation Orientation { get; }
Selector: scale
Property: float Scale { get; }
Selector: filename
Property: string Filename { get; }

Class ALAssetsFilter

Selector: allPhotos
Property: ALAssetsFilter AllPhotos { get; }
Selector: allVideos
Property: ALAssetsFilter AllVideos { get; }
Selector: allAssets
Property: ALAssetsFilter AllAssets { get; }

Class ALAssetsGroup

Selector: valueForProperty:
Method: NSObject ValueForProperty (NSString property);
Selector: posterImage
Property: CGImage PosterImage { get; }
Selector: setAssetsFilter:
Method: void SetAssetsFilter (ALAssetsFilter filter);
Selector: numberOfAssets
Property: int Count { get; }
Selector: enumerateAssetsUsingBlock:
Method: void Enumerate (ALAssetsEnumerator result);
Selector: enumerateAssetsWithOptions:usingBlock:
Method: void Enumerate (NSEnumerationOptions options, ALAssetsEnumerator result);
Selector: enumerateAssetsAtIndexes:options:usingBlock:
Method: void Enumerate (NSIndexSet indexSet, NSEnumerationOptions options, ALAssetsEnumerator result);
Selector: editable
Property: bool Editable { [Bind ("isEditable")] get; }
Selector: addAsset:
Method: bool AddAsset (ALAsset asset);

Namespace MonoTouch.CoreBluetooth

Class CBCentralManager

Selector: state
Property: CBCentralManagerState State { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: initWithDelegate:queue:
Method: IntPtr Constructor (CBCentralManagerDelegate cbDelegate, DispatchQueue queue);
Selector: retrievePeripherals:
Method: void RetrievePeripherals (NSArray peripheralUUIDs);
Selector: retrieveConnectedPeripherals
Method: void RetrieveConnectedPeripherals ();
Selector: scanForPeripheralsWithServices:options:
Method: void ScanForPeripherals (NSArray serviceUUIDs, NSDictionary options);
Selector: stopScan
Method: void StopScan ();
Selector: connectPeripheral:options:
Method: void ConnectPeripheral (CBPeripheral peripheral, NSDictionary options);
Selector: cancelPeripheralConnection:
Method: void CancelPeripheralConnection (CBPeripheral peripheral);

Class CBCentralManagerDelegate

Selector: centralManagerDidUpdateState:
Method: void UpdatedState (CBCentralManager central);
Selector: centralManager:didRetrievePeripherals:
Method: void RetrievedPeripherals (CBCentralManager central, CBPeripheral []peripherals);
Selector: centralManager:didRetrieveConnectedPeripherals:
Method: void RetrievedConnectedPeripherals (CBCentralManager central, CBPeripheral peripherals);
Selector: centralManager:didDiscoverPeripheral:advertisementData:RSSI:
Method: void DiscoveredPeripheral (CBCentralManager central, CBPeripheral peripheral, NSDictionary advertisementData, NSNumber RSSI);
Selector: centralManager:didConnectPeripheral:
Method: void ConnectedPeripheral (CBCentralManager central, CBPeripheral peripheral);
Selector: centralManager:didFailToConnectPeripheral:error:
Method: void FailedToConnectPeripheral (CBCentralManager central, CBPeripheral peripheral, NSError error);
Selector: centralManager:didDisconnectPeripheral:error:
Method: void DisconnectedPeripheral (CBCentralManager central, CBPeripheral peripheral, NSError error);

Class CBAdvertisement

Class CBCharacteristic

Selector: UUID
Property: CBUUID UUID { get; }
Selector: properties
Property: CBCharacteristicProperties Properties { get; }
Selector: value
Property: NSData Value { get; }
Selector: descriptors
Property: CBDescriptor [] Descriptors { get; }
Selector: isBroadcasted
Property: bool IsBroadcasted { get; }
Selector: isNotifying
Property: bool IsNotifying { get; }
Selector: service
Property: CBService Service { get; }

Class CBDescriptor

Selector: UUID
Property: CBUUID UUID { get; }
Selector: value
Property: NSObject Value { get; }
Selector: characteristic
Property: CBCharacteristic Characteristic { get; }

Class CBPeripheral

Selector: UUID
Property: IntPtr UUID { get; }
Selector: name
Property: string Name { get; }
Selector: RSSI
Property: NSNumber RSSI { get; }
Selector: isConnected
Property: bool IsConnected { get; }
Selector: services
Property: CBService [] Services { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: readRSSI
Method: void ReadRSSI ();
Selector: discoverServices:
Method: void DiscoverServices (NSArray serviceUUIDs);
Selector: discoverIncludedServices:forService:
Method: void DiscoverIncludedServices (NSArray includedServiceUUIDs, CBService forService);
Selector: discoverCharacteristics:forService:
Method: void DiscoverCharacteristics (NSArray characteristicUUIDs, CBService forService);
Selector: readValueForCharacteristic:
Method: void ReadValue (CBCharacteristic characteristic);
Selector: writeValue:forCharacteristic:type:
Method: void WriteValue (NSData data, CBCharacteristic characteristic, CBCharacteristicWriteType type);
Selector: setNotifyValue:forCharacteristic:
Method: void SetNotifyValue (bool notifyValue, CBCharacteristic characteristic);
Selector: discoverDescriptorsForCharacteristic:
Method: void DiscoverDescriptors (CBCharacteristic characteristic);
Selector: readValueForDescriptor:
Method: void ReadValue (CBDescriptor descriptor);
Selector: writeValue:forDescriptor:
Method: void WriteValue (NSData data, CBDescriptor descriptor);

Class CBPeripheralDelegate

Selector: peripheralDidUpdateRSSI:error:
Method: void RssiUpdated (CBPeripheral peripheral, NSError error);
Selector: peripheral:didDiscoverServices:
Method: void DiscoveredService (CBPeripheral peripheral, NSError error);
Selector: peripheral:didDiscoverIncludedServicesForService:error:
Method: void DiscoveredIncludedService (CBPeripheral peripheral, CBService service, NSError error);
Selector: peripheral:didDiscoverCharacteristicsForService:error:
Method: void DiscoverCharacteristic (CBPeripheral peripheral, CBService service, NSError error);
Selector: peripheral:didUpdateValueForCharacteristic:error:
Method: void UpdatedCharacterteristicValue (CBPeripheral peripheral, CBCharacteristic characteristic, NSError error);
Selector: peripheral:didWriteValueForCharacteristic:error:
Method: void WroteCharacteristicValue (CBPeripheral peripheral, CBCharacteristic characteristic, NSError error);
Selector: peripheral:didUpdateNotificationStateForCharacteristic:error:
Method: void UpdatedNotificationState (CBPeripheral peripheral, CBCharacteristic characteristic, NSError error);
Selector: peripheral:didDiscoverDescriptorsForCharacteristic:error:
Method: void DiscoveredDescriptor (CBPeripheral peripheral, CBCharacteristic characteristic, NSError error);
Selector: peripheral:didUpdateValueForDescriptor:error:
Method: void UpdatedValue (CBPeripheral peripheral, CBDescriptor descriptor, NSError error);
Selector: peripheral:didWriteValueForDescriptor:error:
Method: void WroteDescriptorValue (CBPeripheral peripheral, CBDescriptor descriptor, NSError error);

Class CBService

Selector: UUID
Property: CBUUID UUID { get; }
Selector: includedServices
Property: CBService [] IncludedServices { get; }
Selector: characteristics
Property: CBCharacteristic [] Characteristics { get; }
Selector: peripheral
Property: CBPeripheral Peripheral { get; }

Class CBUUID

Selector: data
Property: NSData Data{ get; }
Selector: UUIDWithString:
Method: CBUUID FromString (string theString);
Selector: UUIDWithData:
Method: CBUUID FromData (NSData theData);
Selector: UUIDWithCFUUID:
Method: CBUUID FromCFUUID (IntPtr theUUID);

Namespace MonoTouch.AVFoundation

Class AVMediaType

Class AVMediaCharacteristic

Class AVFileType

Class AVVideo

Class AVAudioPlayer

Selector: initWithContentsOfURL:error:
Method: IntPtr Constructor (NSUrl url, IntPtr outError);
Selector: initWithData:error:
Method: IntPtr Constructor (NSData data, IntPtr outError);
Selector: prepareToPlay
Method: bool PrepareToPlay ();
Selector: play
Method: bool Play ();
Selector: pause
Method: void Pause ();
Selector: stop
Method: void Stop ();
Selector: playing
Property: bool Playing { [Bind ("isPlaying")] get; }
Selector: numberOfChannels
Property: uint NumberOfChannels { get; }
Selector: duration
Property: double Duration { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: url
Property: NSUrl Url { get; }
Selector: data
Property: NSData Data { get; }
Selector: volume
Property: float Volume { get; set; }
Selector: currentTime
Property: double CurrentTime { get; set; }
Selector: numberOfLoops
Property: int NumberOfLoops { get; set; }
Selector: meteringEnabled
Property: bool MeteringEnabled { [Bind ("isMeteringEnabled")] get; set; }
Selector: updateMeters
Method: void UpdateMeters ();
Selector: peakPowerForChannel:
Method: float PeakPower (uint channelNumber);
Selector: averagePowerForChannel:
Method: float AveragePower (uint channelNumber);
Selector: deviceCurrentTime
Property: double DeviceCurrentTime { get; }
Selector: pan
Property: float Pan { get; set; }
Selector: playAtTime:
Method: bool PlayAtTimetime (double time);
Selector: settings
Property: NSDictionary Settings { get; }

Class AVAudioPlayerDelegate

Selector: audioPlayerDidFinishPlaying:successfully:
Method: void FinishedPlaying (AVAudioPlayer player, bool flag);
Selector: audioPlayerDecodeErrorDidOccur:error:
Method: void DecoderError (AVAudioPlayer player, NSError error);
Selector: audioPlayerBeginInterruption:
Method: void BeginInterruption (AVAudioPlayer player);
Selector: audioPlayerEndInterruption:
Method: void EndInterruption (AVAudioPlayer player);
Selector: audioPlayerEndInterruption:withFlags:
Method: void EndInterruption (AVAudioPlayer player, AVAudioSessionInterruptionFlags flags);

Class AVAudioRecorder

Selector: initWithURL:settings:error:
Method: IntPtr Constructor (NSUrl url, NSDictionary settings, IntPtr outError);
Selector: prepareToRecord
Method: bool PrepareToRecord ();
Selector: record
Method: bool Record ();
Selector: recordForDuration:
Method: bool RecordFor (double duration);
Selector: pause
Method: void Pause ();
Selector: stop
Method: void Stop ();
Selector: deleteRecording
Method: bool DeleteRecording ();
Selector: recording
Property: bool Recording { [Bind ("isRecording")] get; }
Selector: url
Property: NSUrl Url { get; }
Selector: settings
Property: NSDictionary Settings { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: currentTime
Property: double currentTime { get; }
Selector: meteringEnabled
Property: bool MeteringEnabled { [Bind ("isMeteringEnabled")] get; set; }
Selector: updateMeters
Method: void UpdateMeters ();
Selector: peakPowerForChannel:
Method: float PeakPower (uint channelNumber);
Selector: averagePowerForChannel:
Method: float AveragePower (uint channelNumber);

Class AVAudioRecorderDelegate

Selector: audioRecorderDidFinishRecording:successfully:
Method: void FinishedRecording (AVAudioRecorder recorder, bool flag);
Selector: audioRecorderEncodeErrorDidOccur:error:
Method: void EncoderError (AVAudioRecorder recorder, NSError error);
Selector: audioRecorderBeginInterruption:
Method: void BeginInterruption (AVAudioRecorder recorder);
Selector: audioRecorderEndInterruption:
Method: void EndInterruption (AVAudioRecorder recorder);
Selector: audioRecorderEndInterruption:withFlags:
Method: void EndInterruption (AVAudioRecorder recorder, AVAudioSessionInterruptionFlags flags);

Class AVAudioSession

Selector: sharedInstance
Method: AVAudioSession SharedInstance ();
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: setActive:error:
Method: bool SetActive (bool beActive, IntPtr outError);
Selector: setActive:withFlags:error:
Method: [Since (4,0)]
Selector: setCategory:error:
Method: bool SetCategory (NSString theCategory, IntPtr outError);
Selector: setPreferredHardwareSampleRate:error:
Method: bool SetPreferredHardwareSampleRate (double sampleRate, IntPtr outError);
Selector: setPreferredIOBufferDuration:error:
Method: bool SetPreferredIOBufferDuration (double duration, IntPtr outError);
Selector: category
Property: NSString Category { get; }
Selector: mode
Property: NSString Mode { get; }
Selector: setMode:error:
Method: bool SetMode (NSString mode, out NSError error);
Selector: preferredHardwareSampleRate
Property: double PreferredHardwareSampleRate { get; }
Selector: preferredIOBufferDuration
Property: double PreferredIOBufferDuration { get; }
Selector: inputIsAvailable
Property: bool InputIsAvailable { get; }
Selector: currentHardwareSampleRate
Property: double CurrentHardwareSampleRate { get; }
Selector: currentHardwareInputNumberOfChannels
Property: int currentHardwareInputNumberOfChannels { get; }
Selector: currentHardwareOutputNumberOfChannels
Property: int CurrentHardwareOutputNumberOfChannels { get; }

Class AVAudioSessionDelegate

Selector: beginInterruption
Method: void BeginInterruption ();
Selector: endInterruption
Method: void EndInterruption ();
Selector: inputIsAvailableChanged:
Method: void InputIsAvailableChanged (bool isInputAvailable);
Selector: endInterruptionWithFlags:
Method: void EndInterruption (AVAudioSessionInterruptionFlags flags);

Class AVAsset

Selector: duration
Property: CMTime Duration { get; }
Selector: preferredRate
Property: float PreferredRate { get; }
Selector: preferredVolume
Property: float PreferredVolume { get; }
Selector: preferredTransform
Property: CGAffineTransform PreferredTransform { get; }
Selector: naturalSize"), Obsolete ("Instead use NaturalSize/PreferredTransform as appropriate on the video track
Property: SizeF NaturalSize { get; }
Selector: providesPreciseDurationAndTiming
Property: bool ProvidesPreciseDurationAndTiming { get; }
Selector: cancelLoading
Method: void CancelLoading ();
Selector: tracks
Property: AVAssetTrack [] Tracks { get; }
Selector: trackWithTrackID:
Method: AVAssetTrack TrackWithTrackID (int trackID);
Selector: tracksWithMediaType:
Method: AVAssetTrack [] TracksWithMediaType (string mediaType);
Selector: tracksWithMediaCharacteristic:
Method: AVAssetTrack [] TracksWithMediaCharacteristic (string mediaCharacteristic);
Selector: lyrics
Property: string Lyrics { get; }
Selector: commonMetadata
Property: AVMetadataItem [] CommonMetadata { get; }
Selector: availableMetadataFormats
Property: string [] AvailableMetadataFormats { get; }
Selector: metadataForFormat:
Method: AVMetadataItem [] MetadataForFormat (string format);
Selector: hasProtectedContent
Property: bool ProtectedContent { get; }
Selector: availableChapterLocales
Property: NSLocale [] AvailableChapterLocales { get; }
Selector: chapterMetadataGroupsWithTitleLocale:containingItemsWithCommonKeys:
Method: AVMetadataItem [] ChapterMetadataGroups (NSLocale forLocale, [NullAllowed] AVMetadataItem [] commonKeys);
Selector: isPlayable
Property: bool Playable { get; }
Selector: isExportable
Property: bool Exportable { get; }
Selector: isReadable
Property: bool Readable { get; }
Selector: isComposable
Property: bool Composable { get; }
Selector: assetWithURL:
Method: AVAsset FromUrl (NSUrl url);
Selector: availableMediaCharacteristicsWithMediaSelectionOptions
Property: string [] AvailableMediaCharacteristicsWithMediaSelectionOptions { get; }
Selector: compatibleWithSavedPhotosAlbum
Property: bool CompatibleWithSavedPhotosAlbum { get; }
Selector: creationDate
Property: AVMetadataItem CreationDate { get; }
Selector: mediaSelectionGroupForMediaCharacteristic:
Method: AVMediaSelectionGroup MediaSelectionGroupForMediaCharacteristic (string avMediaCharacteristic);

Class AVAssetImageGenerator

Selector: maximumSize
Property: SizeF MaximumSize { get; set; }
Selector: apertureMode
Property: NSString ApertureMode { get; set; }
Selector: videoComposition
Property: AVVideoComposition VideoComposition { get; set; }
Selector: appliesPreferredTrackTransform
Property: bool AppliesPreferredTrackTransform { get; }
Selector: assetImageGeneratorWithAsset:
Method: AVAssetImageGenerator FromAsset (AVAsset asset);
Selector: initWithAsset:
Method: IntPtr Constructor (AVAsset asset);
Selector: copyCGImageAtTime:actualTime:error:
Method: CGImage CopyCGImageAtTime (CMTime requestedTime, CMTime actualTime, NSError outError);
Selector: generateCGImagesAsynchronouslyForTimes:completionHandler:
Method: void GenerateCGImagesAsynchronously (NSValue cmTimesRequestedTimes, AVAssetImageGeneratorCompletionHandler handler);
Selector: cancelAllCGImageGeneration
Method: void CancelAllCGImageGeneration ();
Selector: requestedTimeToleranceBefore
Property: CMTime RequestedTimeToleranceBefore { get; set; }
Selector: requestedTimeToleranceAfter
Property: CMTime RequestedTimeToleranceAfter { get; set; }

Class AVAssetReader

Selector: asset
Property: AVAsset Asset { get; }
Selector: status
Property: AVAssetReaderStatus Status { get; }
Selector: error
Property: NSError Error { get; }
Selector: timeRange
Property: CMTimeRange TimeRange { get; set; }
Selector: outputs
Property: AVAssetReaderOutput [] Outputs { get; }
Selector: assetReaderWithAsset:error:
Method: AVAssetReader _FromAsset (AVAsset asset, IntPtr ptrToNsError);
Selector: initWithAsset:error:
Method: IntPtr Constructor (AVAsset asset, IntPtr ptrToNsError);
Selector: canAddOutput:
Method: bool CanAddOutput (AVAssetReaderOutput output);
Selector: addOutput:
Method: void AddOutput (AVAssetReaderOutput output);
Selector: startReading
Method: bool StartReading ();
Selector: cancelReading
Method: void CancelReading ();

Class AVAssetReaderOutput

Selector: mediaType
Property: string MediaType { get; }
Selector: copyNextSampleBuffer
Method: CMSampleBuffer CopyNextSampleBuffer ();
Selector: alwaysCopiesSampleData
Property: bool AlwaysCopiesSampleData { get; set; }

Class AVAssetReaderTrackOutput

Selector: track
Property: AVAssetTrack Track { get; }
Selector: assetReaderTrackOutputWithTrack:outputSettings:
Method: AVAssetReaderTrackOutput FromTrack (AVAssetTrack track, [NullAllowed] NSDictionary outputSettings);
Selector: initWithTrack:outputSettings:
Method: IntPtr Constructor (AVAssetTrack track, [NullAllowed] NSDictionary outputSettings);
Selector: outputSettings
Property: NSDictionary OutputSettings { get; }

Class AVAssetReaderAudioMixOutput

Selector: audioTracks
Property: AVAssetTrack [] AudioTracks { get; }
Selector: audioMix
Property: AVAudioMix AudioMix { get; set; }
Selector: assetReaderAudioMixOutputWithAudioTracks:audioSettings:
Method: AVAssetReaderAudioMixOutput FromTracks (AVAssetTrack [] audioTracks, [NullAllowed] NSDictionary audioSettings);
Selector: initWithAudioTracks:audioSettings:
Method: IntPtr Constructor (AVAssetTrack [] audioTracks, [NullAllowed] NSDictionary audioSettings);
Selector: audioSettings
Property: NSDictionary AudioSettings { get; }

Class AVAssetReaderVideoCompositionOutput

Selector: videoTracks
Property: AVAssetTrack [] VideoTracks { get; }
Selector: videoComposition
Property: AVVideoComposition VideoComposition { get; set; }
Selector: assetReaderVideoCompositionOutputWithVideoTracks:videoSettings:
Method: AVAssetReaderVideoCompositionOutput WeakFromTracks (AVAssetTrack [] videoTracks, [NullAllowed] NSDictionary videoSettings);
Selector: initWithVideoTracks:videoSettings:
Method: IntPtr Constructor (AVAssetTrack [] videoTracks, NSDictionary videoSettings);
Selector: videoSettings
Property: NSDictionary WeakVideoSettings { get; }

Class AVAssetWriter

Selector: outputURL
Property: NSUrl OutputURL { get; }
Selector: outputFileType
Property: string OutputFileType { get; }
Selector: status
Property: AVAssetWriterStatus Status { get; }
Selector: error
Property: NSError Error { get; }
Selector: movieFragmentInterval
Property: CMTime MovieFragmentInterval { get; set; }
Selector: shouldOptimizeForNetworkUse
Property: bool ShouldOptimizeForNetworkUse { get; set; }
Selector: inputs
Property: AVAssetWriterInput [] inputs { get; }
Selector: metadata
Property: AVMetadataItem [] Metadata { get; set; }
Selector: assetWriterWithURL:fileType:error:
Method: AVAssetWriter FromUrl (NSUrl outputUrl, string outputFileType, IntPtr ptrToNSError);
Selector: initWithURL:fileType:error:
Method: IntPtr Constructor (NSUrl outputUrl, string outputFileType, IntPtr ptrToNSError);
Selector: canApplyOutputSettings:forMediaType:
Method: bool CanApplyOutputSettings (NSDictionary outputSettings, string toMediaType);
Selector: canAddInput:
Method: bool CanAddInput (AVAssetWriterInput input);
Selector: addInput:
Method: void AddInput (AVAssetWriterInput input);
Selector: startWriting
Method: bool StartWriting ();
Selector: startSessionAtSourceTime:
Method: void StartSessionAtSourceTime (CMTime startTime);
Selector: endSessionAtSourceTime:
Method: void EndSessionAtSourceTime (CMTime endTime);
Selector: cancelWriting
Method: void CancelWriting ();
Selector: finishWriting
Method: bool FinishWriting ();
Selector: movieTimeScale
Property: int MovieTimeScale { get; set; }

Class AVAssetWriterInput

Selector: mediaType
Property: string MediaType { get; }
Selector: outputSettings
Property: NSDictionary OutputSettings { get; }
Selector: transform
Property: CGAffineTransform Transform { get; set; }
Selector: metadata
Property: AVMetadataItem [] Metadata { get; set; }
Selector: readyForMoreMediaData
Property: bool ReadyForMoreMediaData { [Bind ("isReadyForMoreMediaData")] get; }
Selector: expectsMediaDataInRealTime
Property: bool ExpectsMediaDataInRealTime { get; set; }
Selector: assetWriterInputWithMediaType:outputSettings:
Method: AVAssetWriterInput FromType (string mediaType, NSDictionary outputSettings);
Selector: initWithMediaType:outputSettings:
Method: IntPtr Constructor (string mediaType, NSDictionary outputSettings);
Selector: requestMediaDataWhenReadyOnQueue:usingBlock:
Method: void RequestMediaData (DispatchQueue queue, NSAction action);
Selector: appendSampleBuffer:
Method: bool AppendSampleBuffer (CMSampleBuffer sampleBuffer);
Selector: markAsFinished
Method: void MarkAsFinished ();
Selector: mediaTimeScale
Property: int MediaTimeScale { get; set; }

Class AVAssetWriterInputPixelBufferAdaptor

Selector: assetWriterInput
Property: AVAssetWriterInput AssetWriterInput { get; }
Selector: sourcePixelBufferAttributes
Property: NSDictionary SourcePixelBufferAttributes { get; }
Selector: pixelBufferPool
Property: //CVPixelBufferPoolRef pixelBufferPool { get; }
Selector: assetWriterInputPixelBufferAdaptorWithAssetWriterInput:sourcePixelBufferAttributes:
Method: AVAssetWriterInputPixelBufferAdaptor FromInput (AVAssetWriterInput input, NSDictionary sourcePixelBufferAttributes);
Selector: initWithAssetWriterInput:sourcePixelBufferAttributes:
Method: IntPtr Constructor (AVAssetWriterInput input, NSDictionary sourcePixelBufferAttributes);
Selector: appendPixelBuffer:withPresentationTime:
Method: bool AppendPixelBufferWithPresentationTime (CVPixelBuffer pixelBuffer, CMTime presentationTime);

Class AVUrlAsset

Selector: URL
Property: NSUrl Url { get; }
Selector: URLAssetWithURL:options:
Method: AVUrlAsset FromUrl (NSUrl URL, [NullAllowed] NSDictionary options);
Selector: initWithURL:options:
Method: IntPtr Constructor (NSUrl URL, [NullAllowed] NSDictionary options);
Selector: compatibleTrackForCompositionTrack:
Method: AVAssetTrack CompatibleTrack (AVCompositionTrack forCompositionTrack);
Selector: audiovisualMIMETypes
Property: string [] AudiovisualMimeTypes { get; }
Selector: audiovisualTypes
Property: string [] AudiovisualTypes { get; }
Selector: isPlayableExtendedMIMEType
Method: bool IsPlayable (string extendedMimeType);

Class AVAssetTrack

Selector: trackID
Property: int TrackID { get; }
Selector: asset
Property: AVAsset Asset { get; }
Selector: mediaType
Property: string MediaType { get; }
Selector: formatDescriptions
Property: NSObject [] FormatDescriptionsAsObjects { get; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; }
Selector: selfContained
Property: bool SelfContained { [Bind ("isSelfContained")] get; }
Selector: totalSampleDataLength
Property: long TotalSampleDataLength { get; }
Selector: hasMediaCharacteristic:
Method: bool HasMediaCharacteristic (string mediaCharacteristic);
Selector: timeRange
Property: CMTimeRange TimeRange { get; }
Selector: naturalTimeScale
Property: int NaturalTimeScale { get; }
Selector: estimatedDataRate
Property: float EstimatedDataRate { get; }
Selector: languageCode
Property: string LanguageCode { get; }
Selector: extendedLanguageTag
Property: string ExtendedLanguageTag { get; }
Selector: naturalSize
Property: SizeF NaturalSize { get; }
Selector: preferredVolume
Property: float PreferredVolume { get; }
Selector: preferredTransform
Property: CGAffineTransform PreferredTransform { get; }
Selector: nominalFrameRate
Property: float NominalFrameRate { get; }
Selector: segments
Property: AVAssetTrackSegment [] Segments { get; }
Selector: segmentForTrackTime:
Method: AVAssetTrackSegment SegmentForTrackTime (CMTime trackTime);
Selector: samplePresentationTimeForTrackTime:
Method: CMTime SamplePresentationTimeForTrackTime (CMTime trackTime);
Selector: availableMetadataFormats
Property: string [] AvailableMetadataFormats { get; }
Selector: commonMetadata
Property: AVMetadataItem [] CommonMetadata { get; }
Selector: metadataForFormat:
Method: AVMetadataItem [] MetadataForFormat (string format);
Selector: isPlayable
Property: bool Playable { get; }

Class AVMediaSelectionGroup

Selector: options
Property: AVMediaSelectionOption [] Options { get; }
Selector: allowsEmptySelection
Property: bool AllowsEmptySelection { get; }
Selector: mediaSelectionOptionWithPropertyList:
Method: AVMediaSelectionOption GetMediaSelectionOptionForPropertyList (NSObject propertyList);
Selector: playableMediaSelectionOptionsFromArray:
Method: AVMediaSelectionOption [] PlayableMediaSelectionOptions (AVMediaSelectionOption [] source);
Selector: mediaSelectionOptionsFromArray:withLocale:
Method: AVMediaSelectionOption [] MediaSelectionOptions (AVMediaSelectionOption [] source, NSLocale locale);
Selector: mediaSelectionOptionsFromArray:withMediaCharacteristics:
Method: AVMediaSelectionOption [] MediaSelectionOptions (AVMediaSelectionOption [] source, NSString [] avmediaCharacteristics);
Selector: mediaSelectionOptionsFromArray:withoutMediaCharacteristics:
Method: AVMediaSelectionOption [] MediaSelectionOptionsExcludingCharacteristics (NSArray array, NSString [] avmediaCharacteristics);

Class AVMediaSelectionOption

Selector: mediaType
Property: string MediaType { get; }
Selector: mediaSubTypes
Property: NSNumber [] MediaSubTypes { get; }
Selector: playable
Property: bool Playable { [Bind ("isPlayable")] get; }
Selector: locale
Property: NSLocale Locale { get; }
Selector: commonMetadata
Property: AVMetadataItem [] CommonMetadata { get; }
Selector: availableMetadataFormats
Property: string [] AvailableMetadataFormats { get; }
Selector: hasMediaCharacteristic:
Method: bool HasMediaCharacteristic (string mediaCharacteristic);
Selector: metadataForFormat:
Method: AVMetadataItem [] GetMetadataForFormat (string format);
Selector: associatedMediaSelectionOptionInMediaSelectionGroup:
Method: AVMediaSelectionOption AssociatedMediaSelectionOptionInMediaSelectionGroup (AVMediaSelectionGroup mediaSelectionGroup);
Selector: propertyList
Property: NSObject PropertyList { get; }

Class AVMetadataItem

Selector: commonKey
Property: string CommonKey { get; }
Selector: keySpace
Property: string KeySpace { get; }
Selector: locale
Property: NSLocale Locale { get; }
Selector: time
Property: CMTime Time { get; }
Selector: value
Property: NSObject Value { get; }
Selector: extraAttributes
Property: NSDictionary ExtraAttributes { get; }
Selector: key
Property: NSObject Key { get; }
Selector: stringValue
Property: string StringValue { get; }
Selector: numberValue
Property: NSNumber NumberValue { get; }
Selector: dateValue
Property: NSDate DateValue { get; }
Selector: dataValue
Property: NSData DataValue { get; }
Selector: metadataItemsFromArray:withLocale:
Method: AVMetadataItem [] FilterWithLocale (AVMetadataItem [] arrayToFilter, NSLocale locale);
Selector: metadataItemsFromArray:withKey:keySpace:
Method: AVMetadataItem [] FilterWithKey (AVMetadataItem [] array, NSObject key, string keySpace);
Selector: duration
Property: CMTime Duration { get; }
Selector: statusOfValueForKey:error:
Method: AVKeyValueStatus StatusOfValueForKeyerror (string key, IntPtr outError);
Selector: loadValuesAsynchronouslyForKeys:completionHandler:
Method: void LoadValuesAsynchronously (string [] keys, NSAction handler);

Class AVMutableMetadataItem

Selector: keySpace
Property: string KeySpace { get; set; }
Selector: metadataItem
Method: AVMutableMetadataItem Create ();
Selector: locale
Property: NSLocale Locale { get; set; }
Selector: time
Property: CMTime Time { get; set; }
Selector: value
Property: NSObject Value { get; set; }
Selector: extraAttributes
Property: NSDictionary ExtraAttributes { get; set; }
Selector: key
Property: NSObject Key { get; }
Selector: duration
Property: CMTime Duration { get; }

Class AVCompositionTrack

Selector: segments
Property: AVCompositionTrackSegment [] Segments { get; }

Class AVMutableCompositionTrack

Selector: segments
Property: AVCompositionTrackSegment [] Segments { get; set; }
Selector: insertTimeRange:ofTrack:atTime:error:
Method: bool InsertTimeRange (CMTimeRange timeRange, AVAssetTrack ofTrack, CMTime atTime, out NSError error);
Selector: insertEmptyTimeRange:
Method: void InsertEmptyTimeRange (CMTimeRange timeRange);
Selector: removeTimeRange:
Method: void RemoveTimeRange (CMTimeRange timeRange);
Selector: scaleTimeRange:toDuration:
Method: void ScaleTimeRange (CMTimeRange timeRange, CMTime duration);
Selector: validateTrackSegments:error:
Method: bool ValidateTrackSegments (AVCompositionTrackSegment [] trackSegments, out NSError error);
Selector: extendedLanguageTag
Property: string ExtendedLanguageTag { get; set; }
Selector: languageCode
Property: string LanguageCode { get; set; }
Selector: naturalTimeScale
Property: int NaturalTimeScale { get; set; }
Selector: preferredTransform
Property: CGAffineTransform PreferredTransform { get; set; }
Selector: preferredVolume
Property: float PreferredVolume { get; set; }
Selector: insertTimeRanges:ofTracks:atTime:error:
Method: bool InsertTimeRanges (NSValue cmTimeRanges, AVAssetTrack [] tracks, CMTime startTime, out NSError error);

Class AVAssetTrackSegment

Selector: empty
Property: bool Empty { [Bind ("isEmpty")] get; }
Selector: timeMapping
Property: CMTimeMapping TimeMapping { get; }

Class AVComposition

Selector: tracks
Property: AVCompositionTrack [] Tracks { get; }
Selector: naturalSize
Property: SizeF NaturalSize { get; set; }

Class AVMutableComposition

Selector: composition
Method: AVMutableComposition Create ();
Selector: insertTimeRange:ofAsset:atTime:error:
Method: bool Insert (CMTimeRange insertTimeRange, AVAsset sourceAsset, CMTime atTime, NSError outError);
Selector: insertEmptyTimeRange:
Method: void InserEmptyTimeRange (CMTimeRange timeRange);
Selector: removeTimeRange:
Method: void RemoveTimeRange (CMTimeRange timeRange);
Selector: scaleTimeRange:toDuration:
Method: void ScaleTimeRange (CMTimeRange timeRange, CMTime duration);
Selector: addMutableTrackWithMediaType:preferredTrackID:
Method: AVMutableCompositionTrack AddMutableTrack (string mediaType, int preferredTrackId);
Selector: removeTrack:
Method: void RemoveTrack (AVCompositionTrack track);
Selector: mutableTrackCompatibleWithTrack:
Method: AVMutableCompositionTrack CreateMutableTrack (AVAssetTrack referenceTrack);

Class AVCompositionTrackSegment

Selector: sourceURL
Property: NSUrl SourceUrl { get; }
Selector: sourceTrackID
Property: int SourceTrackID { get; }
Selector: compositionTrackSegmentWithURL:trackID:sourceTimeRange:targetTimeRange:
Method: IntPtr FromUrl (NSUrl url, int trackID, CMTimeRange sourceTimeRange, CMTimeRange targetTimeRange);
Selector: compositionTrackSegmentWithTimeRange:
Method: IntPtr FromTimeRange (CMTimeRange timeRange);
Selector: initWithURL:trackID:sourceTimeRange:targetTimeRange:
Method: IntPtr Constructor (NSUrl URL, int trackID, CMTimeRange sourceTimeRange, CMTimeRange targetTimeRange);
Selector: initWithTimeRange:
Method: IntPtr Constructor (CMTimeRange timeRange);

Class AVAssetExportSession

Selector:
Method: [Export ("presetName")]
Selector: supportedFileTypes
Property: NSObject [] SupportedFileTypes { get; }
Selector: outputFileType
Property: string OutputFileType { get; set; }
Selector: outputURL
Property: NSUrl OutputUrl { get; set; }
Selector: status
Property: AVAssetExportSessionStatus Status { get; }
Selector: progress
Property: float Progress { get; }
Selector: maxDuration
Property: CMTime MaxDuration { get; }
Selector: timeRange
Property: CMTimeRange TimeRange { get; set; }
Selector: metadata
Property: AVMetadataItem [] Metadata { get; set; }
Selector: fileLengthLimit
Property: long FileLengthLimit { get; set; }
Selector: audioMix
Property: AVAudioMix AudioMix { get; set; }
Selector: videoComposition
Property: AVVideoComposition VideoComposition { get; set; }
Selector: shouldOptimizeForNetworkUse
Property: bool ShouldOptimizeForNetworkUse { get; set; }
Selector: allExportPresets
Property: string [] AllExportPresets { get; }
Selector: exportPresetsCompatibleWithAsset:
Method: string [] ExportPresetsCompatibleWithAsset (AVAsset asset);
Selector: initWithAsset:presetName:
Method: IntPtr Constructor (AVAsset asset, string presetName);
Selector: exportAsynchronouslyWithCompletionHandler:
Method: void ExportAsynchronously (AVCompletionHandler handler);
Selector: cancelExport
Method: void CancelExport ();
Selector: error
Property: NSError Error { get; }
Selector: AVAssetExportPresetLowQuality
Property: NSString PresetLowQuality { get; }
Selector: AVAssetExportPresetMediumQuality
Property: NSString PresetMediumQuality { get; }
Selector: AVAssetExportPresetHighestQuality
Property: NSString PresetHighestQuality { get; }
Selector: AVAssetExportPreset640x480
Property: NSString Preset640x480 { get; }
Selector: AVAssetExportPreset960x540
Property: NSString Preset960x540 { get; }
Selector: AVAssetExportPreset1280x720
Property: NSString Preset1280x720 { get; }
Selector: AVAssetExportPresetAppleM4A
Property: NSString PresetAppleM4A { get; }
Selector: AVAssetExportPresetPassthrough
Property: NSString PresetPassthrough { get; }
Selector: asset
Property: AVAsset Asset { get; }
Selector: estimatedOutputFileLength
Property: long EstimatedOutputFileLength { get; }

Class AVAudioMix

Selector: inputParameters
Property: AVAudioMixInputParameters [] InputParameters { get; }

Class AVMutableAudioMix

Selector: inputParameters
Property: AVAudioMixInputParameters [] InputParameters { get; set; }
Selector: audioMix
Method: AVMutableAudioMix Create ();

Class AVAudioMixInputParameters

Selector: trackID
Property: int TrackID { get; }
Selector: getVolumeRampForTime:startVolume:endVolume:timeRange:
Method: bool GetVolumeRamp (CMTime forTime, float startVolume, float endVolume, CMTimeRange timeRange);

Class AVMutableAudioMixInputParameters

Selector: trackID
Property: int TrackID { get; set; }
Selector: audioMixInputParametersWithTrack:
Method: AVMutableAudioMixInputParameters FromTrack (AVAssetTrack track);
Selector: audioMixInputParameters
Method: AVMutableAudioMixInputParameters Create ();
Selector: setVolumeRampFromStartVolume:toEndVolume:timeRange:
Method: void SetVolumeRamp (float startVolume, float endVolume, CMTimeRange timeRange);
Selector: setVolume:atTime:
Method: void SetVolume (float volume, CMTime atTime);

Class AVVideoComposition

Selector: frameDuration
Property: CMTime FrameDuration { get; }
Selector: renderSize
Property: SizeF RenderSize { get; }
Selector: instructions
Property: AVVideoCompositionInstruction [] Instructions { get; }
Selector: animationTool
Property: AVVideoCompositionCoreAnimationTool AnimationTool { get; }
Selector: renderScale
Property: float RenderScale { get; set; }
Selector: isValidForAsset:timeRange:validationDelegate:
Method: bool IsValidForAsset (AVAsset asset, CMTimeRange timeRange, AVVideoCompositionValidationHandling validationDelegate);

Class AVVideoCompositionValidationHandling

Selector: videoComposition:shouldContinueValidatingAfterFindingInvalidValueForKey:
Method: bool ShouldContinueValidatingAfterFindingInvalidValueForKey (AVVideoComposition videoComposition, string key);
Selector: videoComposition:shouldContinueValidatingAfterFindingEmptyTimeRange:
Method: bool ShouldContinueValidatingAfterFindingEmptyTimeRange (AVVideoComposition videoComposition, CMTimeRange timeRange);
Selector: videoComposition:shouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction:
Method: bool ShouldContinueValidatingAfterFindingInvalidTimeRangeInInstruction (AVVideoComposition videoComposition, AVVideoCompositionInstruction videoCompositionInstruction);
Selector: videoComposition:shouldContinueValidatingAfterFindingInvalidTrackIDInInstruction:layerInstruction:asset:
Method: bool ShouldContinueValidatingAfterFindingInvalidTrackIDInInstruction (AVVideoComposition videoComposition, AVVideoCompositionInstruction videoCompositionInstruction, AVVideoCompositionLayerInstruction layerInstruction, AVAsset asset);

Class AVMutableVideoComposition

Selector: frameDuration
Property: CMTime FrameDuration { get; set; }
Selector: renderSize
Property: SizeF RenderSize { get; set; }
Selector: instructions
Property: AVVideoCompositionInstruction [] Instructions { get; set; }
Selector: animationTool
Property: AVVideoCompositionCoreAnimationTool AnimationTool { get; set; }
Selector: renderScale
Property: float RenderScale { get; }
Selector: videoComposition
Method: AVMutableVideoComposition Create ();

Class AVVideoCompositionInstruction

Selector: timeRange
Property: CMTimeRange TimeRange { get; }
Selector: backgroundColor
Property: CGColor BackgroundColor { get; set; }
Selector: layerInstructions
Property: AVVideoCompositionLayerInstruction [] LayerInstructions { get; }
Selector: enablePostProcessing
Property: bool EnablePostProcessing { get; }

Class AVMutableVideoCompositionInstruction

Selector: timeRange
Property: CMTimeRange TimeRange { get; set; }
Selector: backgroundColor
Property: CGColor BackgroundColor { get; set; }
Selector: enablePostProcessing
Property: //bool EnablePostProcessing { get; }
Selector: layerInstructions
Property: AVVideoCompositionLayerInstruction [] LayerInstructions { get; set; }
Selector: videoComposition
Method: AVVideoCompositionInstruction Create ();

Class AVVideoCompositionLayerInstruction

Selector: trackID
Property: int TrackID { get; }
Selector: getTransformRampForTime:startTransform:endTransform:timeRange:
Method: bool GetTransformRamp (CMTime time, CGAffineTransform startTransform, CGAffineTransform endTransform, CMTimeRange timeRange);
Selector: getOpacityRampForTime:startOpacity:endOpacity:timeRange:
Method: bool GetOpacityRamp (CMTime time, float startOpacity, float endOpacity, CMTimeRange timeRange);

Class AVMutableVideoCompositionLayerInstruction

Selector: trackID
Property: int TrackID { get; set; }
Selector: videoCompositionLayerInstructionWithAssetTrack:
Method: AVMutableVideoCompositionLayerInstruction FromAssetTrack (AVAssetTrack track);
Selector: videoCompositionLayerInstruction
Method: AVMutableVideoCompositionLayerInstruction Create ();
Selector: setTransformRampFromStartTransform:toEndTransform:timeRange:
Method: void SetTransformRamp (CGAffineTransform startTransform, CGAffineTransform endTransform, CMTimeRange timeRange);
Selector: setTransform:atTime:
Method: void SetTransform (CGAffineTransform transform, CMTime atTime);
Selector: setOpacityRampFromStartOpacity:toEndOpacity:timeRange:
Method: void SetOpacityRamp (float startOpacity, float endOpacity, CMTimeRange timeRange);
Selector: setOpacity:atTime:
Method: void SetOpacity (float opacity, CMTime time);

Class AVVideoCompositionCoreAnimationTool

Selector: videoCompositionCoreAnimationToolWithAdditionalLayer:asTrackID:
Method: AVVideoCompositionCoreAnimationTool FromLayer (CALayer layer, int trackID);
Selector: videoCompositionCoreAnimationToolWithPostProcessingAsVideoLayer:inLayer:
Method: AVVideoCompositionCoreAnimationTool FromLayer (CALayer videoLayer, CALayer animationLayer);

Class AVCaptureSession

Selector: sessionPreset
Property: NSString SessionPreset { get; set; }
Selector: inputs
Property: AVCaptureInput [] Inputs { get; }
Selector: outputs
Property: AVCaptureOutput [] Outputs { get; }
Selector: running
Property: bool Running { [Bind ("isRunning")] get; }
Selector: interrupted
Property: bool Interrupted { [Bind ("isInterrupted")] get; }
Selector: canSetSessionPreset:
Method: bool CanSetSessionPreset (NSString preset);
Selector: canAddInput:
Method: bool CanAddInput (AVCaptureInput input);
Selector: addInput:
Method: void AddInput (AVCaptureInput input);
Selector: removeInput:
Method: void RemoveInput (AVCaptureInput input);
Selector: canAddOutput:
Method: bool CanAddOutput (AVCaptureOutput output);
Selector: addOutput:
Method: void AddOutput (AVCaptureOutput output);
Selector: removeOutput:
Method: void RemoveOutput (AVCaptureOutput output);
Selector: beginConfiguration
Method: void BeginConfiguration ();
Selector: commitConfiguration
Method: void CommitConfiguration ();
Selector: startRunning
Method: void StartRunning ();
Selector: stopRunning
Method: void StopRunning ();

Class AVCaptureConnection

Selector: output
Property: AVCaptureOutput Output { get; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: audioChannels
Property: AVCaptureAudioChannel AudioChannels { get; }
Selector: videoMirrored
Property: bool VideoMirrored { [Bind ("isVideoMirrored")] get; set; }
Selector: videoOrientation
Property: AVCaptureVideoOrientation VideoOrientation { get; set; }
Selector: inputPorts
Property: AVCaptureInputPort [] inputPorts { get; }
Selector: isActive
Property: bool Active { get; }
Selector: isVideoMirroringSupported
Property: bool SupportsVideoMirroring { get; }
Selector: isVideoOrientationSupported
Property: bool SupportsVideoOrientation { get; }
Selector: supportsVideoMinFrameDuration
Property: bool _SupportsVideoMinFrameDuration { [Bind ("isVideoMinFrameDurationSupported")] get; }
Selector: videoMinFrameDuration
Property: CMTime VideoMinFrameDuration { get; set; }
Selector: supportsVideoMaxFrameDuration
Property: bool _SupportsVideoMaxFrameDuration { [Bind ("isVideoMaxFrameDurationSupported")] get; }
Selector: videoMaxFrameDuration
Property: CMTime VideoMaxFrameDuration { get; set; }
Selector: videoMaxScaleAndCropFactor
Property: float VideoMaxScaleAndCropFactor { get; }
Selector: videoScaleAndCropFactor
Property: float VideoScaleAndCropFactor { get; set; }

Class AVCaptureAudioChannel

Selector: peakHoldLevel
Property: float PeakHoldLevel { get; }
Selector: averagePowerLevel
Property: float AveragePowerLevel { get; }

Class AVCaptureInput

Selector: ports
Property: AVCaptureInputPort [] Ports { get; }

Class AVCaptureInputPort

Selector: mediaType
Property: string MediaType { get; }
Selector: formatDescription
Property: //CMFormatDescriptionRef FormatDescription { get; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: input
Property: AVCaptureInput Input { get; }

Class AVCaptureDeviceInput

Selector: device
Property: AVCaptureDevice Device { get; }
Selector: deviceInputWithDevice:error:
Method: AVCaptureDeviceInput FromDevice (AVCaptureDevice device, out NSError error);
Selector: initWithDevice:error:
Method: IntPtr Constructor (AVCaptureDevice device, out NSError error);

Class AVCaptureOutput

Selector: connections
Property: NSObject [] Connections { get; }
Selector: connectionWithMediaType:
Method: AVCaptureConnection ConnectionFromMediaType (NSString avMediaType);

Class AVCaptureVideoPreviewLayer

Selector: session
Property: AVCaptureSession Session { get; set; }
Selector: orientation
Property: AVCaptureVideoOrientation Orientation { get; set; }
Selector: automaticallyAdjustsMirroring
Property: bool AutomaticallyAdjustsMirroring { get; set; }
Selector: mirrored
Property: bool Mirrored { [Bind ("isMirrored")] get; set; }
Selector: isMirroringSupported
Property: bool MirroringSupported { get; }
Selector: isOrientationSupported
Property: bool OrientationSupported { get; }
Selector: videoGravity
Property: string VideoGravity { get; set; }
Selector: layerWithSession:
Method: AVCaptureVideoPreviewLayer FromSession (AVCaptureSession session);
Selector: initWithSession:
Method: IntPtr Constructor (AVCaptureSession session);

Class AVCaptureVideoDataOutput

Selector: sampleBufferDelegate
Property: AVCaptureVideoDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
Selector: sampleBufferCallbackQueue
Property: DispatchQueue SampleBufferCallbackQueue { get; }
Selector: videoSettings
Property: NSDictionary WeakVideoSettings { get; set; }
Selector: minFrameDuration
Method: [Obsolete ("On iOS 5.0 and later, you can use AVCaptureConnection's MinVideoFrameDuration")]
Selector: alwaysDiscardsLateVideoFrames
Property: bool AlwaysDiscardsLateVideoFrames { get; set; }
Selector: setSampleBufferDelegate:queue:
Method: [PostGet ("SampleBufferDelegate")]
Selector: availableVideoCVPixelFormatTypes
Property: NSNumber [] AvailableVideoCVPixelFormatTypes { get; }
Selector: availableVideoCodecTypes
Property: NSString [] AvailableVideoCodecTypes { get; }

Class AVCaptureVideoDataOutputSampleBufferDelegate

Selector: captureOutput:didOutputSampleBuffer:fromConnection:
Method: // CMSampleBufferRef

Class AVCaptureAudioDataOutput

Selector: sampleBufferDelegate
Property: AVCaptureAudioDataOutputSampleBufferDelegate SampleBufferDelegate { get; }
Selector: sampleBufferCallbackQueue
Property: DispatchQueue SampleBufferCallbackQueue { get; }
Selector: setSampleBufferDelegate:queue:
Method: void SetSampleBufferDelegatequeue (AVCaptureAudioDataOutputSampleBufferDelegate sampleBufferDelegate, DispatchQueue sampleBufferCallbackDispatchQueue);

Class AVCaptureAudioDataOutputSampleBufferDelegate

Selector: captureOutput:didOutputSampleBuffer:fromConnection:
Method: void DidOutputSampleBuffer (AVCaptureOutput captureOutput, CMSampleBuffer sampleBuffer, AVCaptureConnection connection);

Class AVCaptureFileOutput

Selector: recordedDuration
Property: CMTime RecordedDuration { get; }
Selector: recordedFileSize
Property: long RecordedFileSize { get; }
Selector: isRecording
Property: bool Recording { get; }
Selector: maxRecordedDuration
Property: CMTime MaxRecordedDuration { get; set; }
Selector: maxRecordedFileSize
Property: long MaxRecordedFileSize { get; set; }
Selector: minFreeDiskSpaceLimit
Property: long MinFreeDiskSpaceLimit { get; set; }
Selector: outputFileURL
Property: NSUrl OutputFileURL { get; }
Selector: startRecordingToOutputFileURL:recordingDelegate:
Method: void StartRecordingToOutputFile (NSUrl outputFileUrl, AVCaptureFileOutputRecordingDelegate recordingDelegate);
Selector: stopRecording
Method: void StopRecording ();

Class AVCaptureFileOutputRecordingDelegate

Selector: captureOutput:didStartRecordingToOutputFileAtURL:fromConnections:
Method: void DidStartRecording (AVCaptureFileOutput captureOutput, NSUrl outputFileUrl, NSObject [] connections);
Selector: captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error:
Method: void FinishedRecording (AVCaptureFileOutput captureOutput, NSUrl outputFileUrl, NSObject [] connections, NSError error);

Class AVCaptureMovieFileOutput

Selector: metadata
Property: AVMetadataItem [] Metadata { get; set; }
Selector: movieFragmentInterval
Property: CMTime MovieFragmentInterval { get; }

Class AVCaptureStillImageOutput

Selector: availableImageDataCVPixelFormatTypes
Property: NSNumber [] AvailableImageDataCVPixelFormatTypes { get; }
Selector: availableImageDataCodecTypes
Property: string [] AvailableImageDataCodecTypes { get; }
Selector: outputSettings
Property: NSDictionary OutputSettings { get; set; }
Selector: captureStillImageAsynchronouslyFromConnection:completionHandler:
Method: void CaptureStillImageAsynchronously (AVCaptureConnection connection, AVCaptureCompletionHandler completionHandler);
Selector: jpegStillImageNSDataRepresentation:
Method: NSData JpegStillToNSData (MonoTouch.CoreMedia.CMSampleBuffer buffer);
Selector: capturingStillImage
Property: bool CapturingStillImage { [Bind ("isCapturingStillImage")] get; }

Class AVCaptureDevice

Selector: uniqueID
Property: string UniqueID { get; }
Selector: modelID
Property: string ModelID { get; }
Selector: localizedName
Property: string LocalizedName { get; }
Selector: connected
Property: bool Connected { [Bind ("isConnected")] get; }
Selector: devices
Property: AVCaptureDevice [] Devices { get; }
Selector: devicesWithMediaType:
Method: AVCaptureDevice [] DevicesWithMediaType (string mediaType);
Selector: defaultDeviceWithMediaType:
Method: AVCaptureDevice DefaultDeviceWithMediaType (string mediaType);
Selector: deviceWithUniqueID:
Method: AVCaptureDevice DeviceWithUniqueID (string deviceUniqueID);
Selector: hasMediaType:
Method: bool HasMediaType (string mediaType);
Selector: lockForConfiguration:
Method: bool LockForConfiguration (out NSError error);
Selector: unlockForConfiguration
Method: void UnlockForConfiguration ();
Selector: supportsAVCaptureSessionPreset:
Method: bool SupportsAVCaptureSessionPreset (string preset);
Selector: flashMode
Property: AVCaptureFlashMode FlashMode { get; set; }
Selector: isFlashModeSupported:
Method: bool IsFlashModeSupported (AVCaptureFlashMode flashMode);
Selector: torchMode
Property: AVCaptureTorchMode TorchMode { get; set; }
Selector: isTorchModeSupported:
Method: bool IsTorchModeSupported (AVCaptureTorchMode torchMode);
Selector: focusMode
Property: AVCaptureFocusMode FocusMode { get; set; }
Selector: focusPointOfInterestSupported
Property: bool FocusPointOfInterestSupported { [Bind ("isFocusPointOfInterestSupported")] get; }
Selector: focusPointOfInterest
Property: PointF FocusPointOfInterest { get; set; }
Selector: adjustingFocus
Property: bool AdjustingFocus { [Bind ("isAdjustingFocus")] get; }
Selector: exposureMode
Property: AVCaptureExposureMode ExposureMode { get; set; }
Selector: exposurePointOfInterestSupported
Property: bool ExposurePointOfInterestSupported { [Bind ("isExposurePointOfInterestSupported")] get; }
Selector: exposurePointOfInterest
Property: PointF ExposurePointOfInterest { get; set; }
Selector: adjustingExposure
Property: bool AdjustingExposure { [Bind ("isAdjustingExposure")] get; }
Selector: whiteBalanceMode
Property: AVCaptureWhiteBalanceMode WhiteBalanceMode { get; set; }
Selector: adjustingWhiteBalance
Property: bool AdjustingWhiteBalance { [Bind ("isAdjustingWhiteBalance")] get; }
Selector: position
Property: AVCaptureDevicePosition Position { get; }
Selector: isFlashAvailable
Property: bool FlashAvailable { get; }
Selector: isFlashActive
Property: bool FlashActive { get; }
Selector: isTorchAvailable
Property: bool TorchAvailable { get; }
Selector: torchLevel
Property: float TorchLevel { get; }

Class AVPlayer

Selector: currentItem
Property: AVPlayerItem CurrentItem { get; }
Selector: rate
Property: float Rate { get; set; }
Selector: currentTime
Property: CMTime CurrentTime { get; set; }
Selector: actionAtItemEnd
Property: AVPlayerActionAtItemEnd ActionAtItemEnd { get; set; }
Selector: closedCaptionDisplayEnabled
Property: bool ClosedCaptionDisplayEnabled { [Bind ("isClosedCaptionDisplayEnabled")] get; set; }
Selector: playerWithURL:
Method: AVPlayer FromUrl (NSUrl URL);
Selector: playerWithPlayerItem:
Method: AVPlayer FromPlayerItem (AVPlayerItem item);
Selector: initWithURL:
Method: IntPtr Constructor (NSUrl URL);
Selector: initWithPlayerItem:
Method: IntPtr Constructor (AVPlayerItem item);
Selector: play
Method: void Play ();
Selector: pause
Method: void Pause ();
Selector: replaceCurrentItemWithPlayerItem:
Method: void ReplaceCurrentItemWithPlayerItem (AVPlayerItem item);
Selector: addPeriodicTimeObserverForInterval:queue:usingBlock:
Method: NSObject AddPeriodicTimeObserver (CMTime interval, DispatchQueue queue, AVTimeHandler handler);
Selector: addBoundaryTimeObserverForTimes:queue:usingBlock:
Method: NSObject AddBoundaryTimeObserver (NSValue []times, DispatchQueue queue, NSAction handler);
Selector: removeTimeObserver:
Method: void RemoveTimeObserver (NSObject observer);
Selector: seekToTime:
Method: void Seek (CMTime toTime);
Selector: seekToTime:toleranceBefore:toleranceAfter:
Method: void Seek (CMTime toTime, CMTime toleranceBefore, CMTime toleranceAfter);
Selector: error
Property: NSError Error { get; }
Selector: status
Property: AVPlayerStatus Status { get; }
Selector: allowsAirPlayVideo
Property: bool AllowsAirPlayVideo { get; set; }
Selector: airPlayVideoActive
Property: bool AirPlayVideoActive { [Bind ("isAirPlayVideoActive")] get; }
Selector: usesAirPlayVideoWhileAirPlayScreenIsActive
Property: bool UsesAirPlayVideoWhileAirPlayScreenIsActive { get; set; }
Selector: seekToTime:completionHandler:
Method: void Seek (CMTime time, AVCompletionHandler completion);
Selector: seekToTime:toleranceBefore:toleranceAfter:completionHandler:
Method: void Seek (CMTime time, CMTime toleranceBefore, CMTime toleranceAfter, AVCompletionHandler completion);

Class AVTimedMetadataGroup

Selector: timeRange
Property: CMTimeRange TimeRange { get; }
Selector: items
Property: AVMetadataItem [] Items { get; }
Selector: initWithItems:timeRange:
Method: IntPtr Constructor (AVMetadataItem [] items, CMTimeRange timeRange);

Class AVMutableTimedMetadataGroup

Selector: items
Property: AVMetadataItem [] Items { get; set; }
Selector: timeRange
Property: CMTimeRange Timerange { get; set; }

Class AVPlayerItem

Selector: status
Property: AVPlayerItemStatus Status { get; }
Selector: asset
Property: AVAsset Asset { get; }
Selector: tracks
Property: AVPlayerItem [] Tracks { get; }
Selector: presentationSize
Property: SizeF PresentationSize { get; }
Selector: forwardPlaybackEndTime
Property: CMTime ForwardPlaybackEndTime { get; set; }
Selector: reversePlaybackEndTime
Property: CMTime ReversePlaybackEndTime { get; set; }
Selector: audioMix
Property: AVAudioMix AudioMix { get; set; }
Selector: videoComposition
Property: AVVideoComposition VideoComposition { get; set; }
Selector: currentTime
Property: CMTime CurrentTime { get; set; }
Selector: playbackLikelyToKeepUp
Property: bool PlaybackLikelyToKeepUp { [Bind ("isPlaybackLikelyToKeepUp")] get; }
Selector: playbackBufferFull
Property: bool PlaybackBufferFull { [Bind ("isPlaybackBufferFull")] get; }
Selector: playbackBufferEmpty
Property: bool PlaybackBufferEmpty { [Bind ("isPlaybackBufferEmpty")] get; }
Selector: seekableTimeRanges
Property: //CMTimeRange [] seekableTimeRanges { get; }
Selector: loadedTimeRanges
Property: // NSArray loadedTimeRanges { get; }
Selector: timedMetadata
Property: NSObject [] TimedMetadata { get; }
Selector: playerItemWithURL:
Method: AVPlayerItem FromUrl (NSUrl URL);
Selector: playerItemWithAsset:
Method: AVPlayerItem FromAsset (AVAsset asset);
Selector: initWithURL:
Method: IntPtr Constructor (NSUrl URL);
Selector: initWithAsset:
Method: IntPtr Constructor (AVAsset asset);
Selector: stepByCount:
Method: void StepByCount (int stepCount);
Selector: seekToDate:
Method: bool Seek (NSDate date);
Selector: seekToTime:
Method: bool Seek (CMTime time);
Selector: seekToDate:
Method: bool SeekToDate (CMTime time, CMTime toleranceBefore, CMTime toleranceAfter);
Selector: error
Property: NSError Error { get; }
Selector: accessLog
Property: AVPlayerItemAccessLog AccessLog { get; }
Selector: errorLog
Property: AVPlayerItemErrorLog ErrorLog { get; }
Selector: currentDate
Property: NSDate CurrentDate { get; }
Selector: canPlayFastReverse
Property: bool CanPlayFastReverse { get; }
Selector: canPlayFastForward
Property: bool CanPlayFastForward { get; }
Selector: seekToTime:completionHandler:
Method: void Seek (CMTime time, AVCompletion completion);
Selector: cancelPendingSeeks
Method: void CancelPendingSeeks ();
Selector: seekToTime:toleranceBefore:toleranceAfter:completionHandler:
Method: void Seek (CMTime time, CMTime toleranceBefore, CMTime toleranceAfter, AVCompletionHandler completion);
Selector: selectMediaOption:inMediaSelectionGroup:
Method: void SelectMediaOption (AVMediaSelectionOption mediaSelectionOption, AVMediaSelectionGroup mediaSelectionGroup);
Selector: selectedMediaOptionInMediaSelectionGroup:
Method: AVMediaSelectionOption SelectedMediaOption (AVMediaSelectionGroup inMediaSelectionGroup);

Class AVPlayerItemAccessLog

Selector: events
Property: AVPlayerItemAccessLogEvent [] Events { get; }
Selector: extendedLogDataStringEncoding
Property: NSStringEncoding ExtendedLogDataStringEncoding { get; }
Selector: extendedLogData
Property: NSData ExtendedLogData { get; }

Class AVPlayerItemErrorLog

Selector: events
Property: AVPlayerItemErrorLogEvent [] Events { get; }
Selector: extendedLogDataStringEncoding
Property: NSStringEncoding ExtendedLogDataStringEncoding { get; }
Selector: extendedLogData
Property: NSData ExtendedLogData { get; }

Class AVPlayerItemAccessLogEvent

Selector: numberOfSegmentsDownloaded
Property: int SegmentedDownloadedCount { get; }
Selector: playbackStartDate
Property: NSData PlaybackStartDate { get; }
Selector: URI
Property: string Uri { get; }
Selector: serverAddress
Property: string ServerAddress { get; }
Selector: numberOfServerAddressChanges
Property: int ServerAddressChangeCount { get; }
Selector: playbackSessionID
Property: string PlaybackSessionID { get; }
Selector: playbackStartOffset
Property: double PlaybackStartOffset { get; }
Selector: segmentsDownloadedDuration
Property: double SegmentsDownloadedDuration { get; }
Selector: durationWatched
Property: double DurationWatched { get; }
Selector: numberOfStalls
Property: int StallCount { get; }
Selector: numberOfBytesTransferred
Property: long BytesTransferred { get; }
Selector: observedBitrate
Property: double ObservedBitrate { get; }
Selector: indicatedBitrate
Property: double IndicatedBitrate { get; }
Selector: numberOfDroppedVideoFrames
Property: int DroppedVideoFrameCount { get; }

Class AVPlayerItemErrorLogEvent

Selector: date
Property: NSDate Date { get; }
Selector: URI
Property: string Uri { get; }
Selector: serverAddress
Property: string ServerAddress { get; }
Selector: playbackSessionID
Property: string PlaybackSessionID { get; }
Selector: errorStatusCode
Property: int ErrorStatusCode { get; }
Selector: errorDomain
Property: string ErrorDomain { get; }
Selector: errorComment
Property: string ErrorComment { get; }

Class AVPlayerLayer

Selector: player
Property: AVPlayer Player { get; set; }
Selector: playerLayerWithPlayer:
Method: AVPlayerLayer FromPlayer (AVPlayer player);
Selector: videoGravity
Property: string VideoGravity { get; set; }
Selector: isReadyForDisplay
Property: bool ReadyForDisplay { get; }

Class AVPlayerItemTrack

Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: assetTrack
Property: AVAssetTrack AssetTrack { get; }

Class AVAsynchronousKeyValueLoading

Selector: statusOfValueForKey:error:
Method: AVKeyValueStatus StatusOfValueForKeyerror (string key, IntPtr outError);
Selector: loadValuesAsynchronouslyForKeys:completionHandler:
Method: void LoadValuesAsynchronously (string [] keys, NSAction handler);

Class AVQueuePlayer

Selector: queuePlayerWithItems:
Method: AVQueuePlayer FromItems (AVPlayerItem [] items);
Selector: initWithItems:
Method: IntPtr Constructor (AVPlayerItem [] items);
Selector: items
Property: AVPlayerItem [] Items { get; }
Selector: advanceToNextItem
Method: void AdvanceToNextItem ();
Selector: canInsertItem:afterItem:
Method: bool CanInsert (AVPlayerItem item, AVPlayerItem afterItem);
Selector: i