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: insertItem:afterItem:
Method: void InsertItem (AVPlayerItem item, AVPlayerItem afterItem);
Selector: removeItem:
Method: void RemoveItem (AVPlayerItem item);
Selector: removeAllItems
Method: void RemoveAllItems ();

Class NSArray

Selector: count
Property: uint Count { get; }
Selector: objectAtIndex:
Method: IntPtr ValueAt (uint idx);
Selector: arrayWithObjects:count:
Method: NSArray FromObjects (IntPtr array, int count);
Selector: valueForKey:
Method: NSObject ValueForKey (NSString key);
Selector: setValue:forKey:
Method: void SetValueForKey (NSObject value, NSString key);
Selector: writeToFile:atomically:
Method: bool WriteToFile (string path, bool useAuxiliaryFile);
Selector: arrayWithContentsOfFile:
Method: NSArray FromFile (string path);

Class NSAttributedString

Selector: string
Property: string Value { get; }
Selector: attributesAtIndex:effectiveRange:
Method: NSDictionary GetAttributes (int location, out NSRange effectiveRange);
Selector: length
Property: int Length { get; }
Selector: attribute:atIndex:effectiveRange:
Method: NSObject GetAttribute (string attribute, int location, out NSRange effectiveRange);
Selector: attributedSubstringFromRange:
Method: NSAttributedString Substring (NSRange range);
Selector: attributesAtIndex:longestEffectiveRange:inRange:
Method: NSDictionary GetAttributes (int location, out NSRange longestEffectiveRange, NSRange rangeLimit);
Selector: attribute:atIndex:longestEffectiveRange:inRange:
Method: NSObject GetAttribute (string attribute, int location, out NSRange longestEffectiveRange, NSRange rangeLimit);
Selector: isEqualToAttributedString:
Method: bool IsEqual (NSAttributedString other);
Selector: initWithString:
Method: IntPtr Constructor (string str);
Selector: initWithString:attributes:
Method: IntPtr Constructor (string str, NSDictionary attributes);
Selector: initWithAttributedString:
Method: IntPtr Constructor (NSAttributedString other);
Selector: size
Property: SizeF Size { get; }
Selector: initWithData:options:documentAttributes:error:
Method: IntPtr Constructor (NSData data, NSDictionary options, out NSDictionary docAttributes, out NSError error);
Selector: initWithDocFormat:documentAttributes:
Method: IntPtr Constructor(NSData wordDocFormat, out NSDictionary docAttributes);
Selector: initWithHTML:baseURL:documentAttributes:
Method: IntPtr Constructor (NSData htmlData, NSUrl baseUrl, out NSDictionary docAttributes);
Selector: drawAtPoint:
Method: void DrawString (PointF point);
Selector: drawInRect:
Method: void DrawString (RectangleF rect);
Selector: drawWithRect:options:
Method: void DrawString (RectangleF rect, NSStringDrawingOptions options);

Class NSCache

Selector: objectForKey:
Method: NSObject ObjectForKey (NSObject key);
Selector: setObject:forKey:
Method: void SetObjectforKey (NSObject obj, NSObject key);
Selector: setObject:forKey:cost:
Method: void SetCost (NSObject obj, NSObject key, uint cost);
Selector: removeObjectForKey:
Method: void RemoveObjectForKey (NSObject key);
Selector: removeAllObjects
Method: void RemoveAllObjects ();
Selector: name
Property: string Name { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: totalCostLimit
Property: uint TotalCostLimit { get; set; }
Selector: countLimit
Property: uint CountLimit { get; set; }
Selector: evictsObjectsWithDiscardedContent
Property: bool EvictsObjectsWithDiscardedContent { get; set; }

Class NSCacheDelegate

Selector: cache:willEvictObject:"), EventArgs ("NSObject
Method: void WillEvictObject (NSCache cache, NSObject obj);

Class NSCachedUrlResponse

Selector: initWithResponse:data:userInfo:storagePolicy:
Method: IntPtr Constructor (NSUrlResponse response, NSData data, NSDictionary userInfo, NSUrlCacheStoragePolicy storagePolicy);
Selector: response
Property: NSUrlResponse Response { get; }
Selector: data
Property: NSData Data { get; }
Selector: userInfo
Property: NSDictionary UserInfo { get; }
Selector: storagePolicy
Property: NSUrlCacheStoragePolicy StoragePolicy { get; }

Class NSCalendar

Selector: initWithCalendarIdentifier:
Method: IntPtr Constructor (string identifier);
Selector: calendarIdentifier
Property: string Identifier { get; }
Selector: currentCalendar
Property: NSCalendar CurrentCalendar { get; }
Selector: locale
Property: NSLocale Locale { get; set; }
Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: firstWeekday
Property: uint FirstWeekDay { get; set; }
Selector: minimumDaysInFirstWeek
Property: uint MinimumDaysInFirstWeek { get; set; }

Class NSCharacterSet

Selector: alphanumericCharacterSet
Property: NSCharacterSet Alphanumerics {get;}
Selector: capitalizedLetterCharacterSet
Property: NSCharacterSet Capitalized {get;}
Selector: characterSetWithBitmapRepresentation:
Method: NSCharacterSet FromBitmap (NSData data);
Selector: characterSetWithCharactersInString:
Method: NSCharacterSet FromString (string aString);
Selector: characterSetWithContentsOfFile:
Method: NSCharacterSet FromFile (string path);
Selector: characterSetWithRange:
Method: NSCharacterSet FromRange (NSRange aRange);
Selector: controlCharacterSet
Property: NSCharacterSet Controls {get;}
Selector: decimalDigitCharacterSet
Property: NSCharacterSet DecimalDigits {get;}
Selector: decomposableCharacterSet
Property: NSCharacterSet Decomposables {get;}
Selector: illegalCharacterSet
Property: NSCharacterSet Illegals {get;}
Selector: letterCharacterSet
Property: NSCharacterSet Letters {get;}
Selector: lowercaseLetterCharacterSet
Property: NSCharacterSet LowercaseLetters {get;}
Selector: newlineCharacterSet
Property: NSCharacterSet Newlines {get;}
Selector: nonBaseCharacterSet
Property: NSCharacterSet Marks {get;}
Selector: punctuationCharacterSet
Property: NSCharacterSet Punctuation {get;}
Selector: symbolCharacterSet
Property: NSCharacterSet Symbols {get;}
Selector: uppercaseLetterCharacterSet
Property: NSCharacterSet UppercaseLetters {get;}
Selector: whitespaceAndNewlineCharacterSet
Property: NSCharacterSet WhitespaceAndNewlines {get;}
Selector: whitespaceCharacterSet
Property: NSCharacterSet Whitespaces {get;}
Selector: bitmapRepresentation
Method: NSData GetBitmapRepresentation ();
Selector: characterIsMember:
Method: bool Contains (char aCharacter);
Selector: hasMemberInPlane:
Method: bool HasMemberInPlane (byte thePlane);
Selector: invertedSet
Property: NSCharacterSet InvertedSet {get;}
Selector: isSupersetOfSet:
Method: bool IsSupersetOf (NSCharacterSet theOtherSet);
Selector: longCharacterIsMember:
Method: bool Contains (uint theLongChar);

Class NSCoder

Selector: encodeObject:
Method: void Encode (NSObject obj);
Selector: encodeRootObject:
Method: void EncodeRoot (NSObject obj);
Selector: decodeObject
Method: NSObject DecodeObject ();
Selector: encodeConditionalObject:forKey:
Method: void EncodeConditionalObject (NSObject val, string key);
Selector: encodeObject:forKey:
Method: void Encode (NSObject val, string key);
Selector: encodeBool:forKey:
Method: void Encode (bool val, string key);
Selector: encodeDouble:forKey:
Method: void Encode (double val, string key);
Selector: encodeFloat:forKey:
Method: void Encode (float val, string key);
Selector: encodeInt32:forKey:
Method: void Encode (int val, string key);
Selector: encodeInt64:forKey:
Method: void Encode (long val, string key);
Selector: encodeBytes:length:forKey:
Method: void EncodeBlock (IntPtr bytes, int length, string key);
Selector: containsValueForKey:
Method: bool ContainsKey (string key);
Selector: decodeBoolForKey:
Method: bool DecodeBool (string key);
Selector: decodeDoubleForKey:
Method: double DecodeDouble (string key);
Selector: decodeFloatForKey:
Method: float DecodeFloat (string key);
Selector: decodeInt32ForKey:
Method: int DecodeInt (string key);
Selector: decodeInt64ForKey:
Method: long DecodeLong (string key);
Selector: decodeObjectForKey:
Method: NSObject DecodeObject (string key);
Selector: decodeBytesForKey:returnedLength:
Method: IntPtr DecodeBytes (string key, IntPtr length_ptr);

Class NSComparisonPredicate

Selector: predicateWithLeftExpression:rightExpression:modifier:type:options:
Method: NSPredicate Create (NSExpression leftExpression, NSExpression rightExpression, NSComparisonPredicateModifier comparisonModifier, NSPredicateOperatorType operatorType, NSComparisonPredicateOptions comparisonOptions);
Selector: predicateWithLeftExpression:rightExpression:customSelector:
Method: NSPredicate FromSelector (NSExpression leftExpression, NSExpression rightExpression, Selector selector);
Selector: initWithLeftExpression:rightExpression:modifier:type:options:
Method: IntPtr Constructor (NSExpression leftExpression, NSExpression rightExpression, NSComparisonPredicateModifier comparisonModifier, NSPredicateOperatorType operatorType, NSComparisonPredicateOptions comparisonOptions);
Selector: initWithLeftExpression:rightExpression:customSelector:
Method: IntPtr Constructor (NSExpression leftExpression, NSExpression rightExpression, Selector selector);
Selector: predicateOperatorType
Property: NSPredicateOperatorType PredicateOperatorType { get; }
Selector: comparisonPredicateModifier
Property: NSComparisonPredicateModifier ComparisonPredicateModifier { get; }
Selector: leftExpression
Property: NSExpression LeftExpression { get; }
Selector: rightExpression
Property: NSExpression RightExpression { get; }
Selector: customSelector
Property: Selector CustomSelector { get; }
Selector: options
Property: NSComparisonPredicateOptions Options { get; }

Class NSCompoundPredicate

Selector: initWithType:subpredicates:
Method: IntPtr Constructor (NSCompoundPredicateType type, NSPredicate[] subpredicates);
Selector: compoundPredicateType
Property: NSCompoundPredicateType Type { get; }
Selector: subpredicates
Property: NSPredicate[] Subpredicates { get; }
Selector: andPredicateWithSubpredicates:
Method: NSPredicate CreateAndPredicate (NSPredicate[] subpredicates);
Selector: orPredicateWithSubpredicates:
Method: NSPredicate CreateOrPredicate (NSPredicate [] subpredicates);
Selector: notPredicateWithSubpredicate:
Method: NSPredicate CreateNotPredicate (NSPredicate predicate);

Class NSData

Selector: dataWithContentsOfURL:
Method: [Static]
Selector: dataWithContentsOfURL:options:error:
Method: [Static]
Selector: dataWithContentsOfFile:
Method: NSData FromFile (string path);
Selector: dataWithBytes:length:
Method: NSData FromBytes (IntPtr bytes, uint size);
Selector: bytes
Property: IntPtr Bytes { get; }
Selector: length
Property: uint Length { get; }
Selector: writeToFile:options:error:
Method: bool _Save (string file, int options, IntPtr addr);
Selector: writeToURL:options:error:
Method: bool _Save (NSUrl url, int options, IntPtr addr);
Selector: rangeOfData:options:range:
Method: [Since (4,0)]

Class NSDateComponents

Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: calendar
Method: [Since (4,0)]
Selector: quarter
Method: [Since (4,0)]
Selector: date
Method: [Since (4,0)]
Selector: era
Property: int Era { get; set; }
Selector: year
Property: int Year { get; set; }
Selector: month
Property: int Month { get; set; }
Selector: day
Property: int Day { get; set; }
Selector: hour
Property: int Hour { get; set; }
Selector: minute
Property: int Minute { get; set; }
Selector: second
Property: int Second { get; set; }
Selector: week
Property: int Week { get; set; }
Selector: weekday
Property: int Weekday { get; set; }
Selector: weekdayOrdinal
Property: int WeekdayOrdinal { get; set; }
Selector: weekOfMonth
Property: int WeekOfMonth { get; set; }
Selector: weekOfYear
Property: int WeekOfYear { get; set; }
Selector: yearForWeekOfYear
Property: int YearForWeekOfYear { get; set; }

Class NSDateFormatter

Selector: stringFromDate:
Method: string ToString (NSDate date);
Selector: dateFromString:
Method: NSDate Parse (string date);
Selector: dateFormat
Property: string DateFormat { get; set; }
Selector: dateStyle
Property: NSDateFormatterStyle DateStyle { get; set; }
Selector: timeStyle
Property: NSDateFormatterStyle TimeStyle { get; set; }
Selector: locale
Property: NSLocale Locale { get; set; }
Selector: generatesCalendarDates
Property: bool GeneratesCalendarDates { get; set; }
Selector: formatterBehavior
Property: NSDateFormatterBehavior Behavior { get; set; }
Selector: defaultFormatterBehavior
Property: NSDateFormatterBehavior DefaultBehavior { get; set; }
Selector: timeZone
Property: NSTimeZone TimeZone { get; set; }
Selector: calendar
Property: NSCalendar Calendar { get; set; }
Selector: isLenient
Property: bool IsLenient { get; set; }
Selector: twoDigitStartDate
Property: NSDate TwoDigitStartDate { get; set; }
Selector: defaultDate
Property: NSDate DefaultDate { get; set; }
Selector: eraSymbols
Property: string [] EraSymbols { get; set; }
Selector: monthSymbols
Property: string [] MonthSymbols { get; set; }
Selector: shortMonthSymbols
Property: string [] ShortMonthSymbols { get; set; }
Selector: weekdaySymbols
Property: string [] WeekdaySymbols { get; set; }
Selector: shortWeekdaySymbols
Property: string [] ShortWeekdaySymbols { get; set; }
Selector: AMSymbol
Property: string AMSymbol { get; set; }
Selector: PMSymbol
Property: string PMSymbol { get; set; }
Selector: longEraSymbols
Property: string [] LongEraSymbols { get; set; }
Selector: veryShortMonthSymbols
Property: string [] VeryShortMonthSymbols { get; set; }
Selector: standaloneMonthSymbols
Property: string [] StandaloneMonthSymbols { get; set; }
Selector: shortStandaloneMonthSymbols
Property: string [] ShortStandaloneMonthSymbols { get; set; }
Selector: veryShortStandaloneMonthSymbols
Property: string [] VeryShortStandaloneMonthSymbols { get; set; }
Selector: veryShortWeekdaySymbols
Property: string [] VeryShortWeekdaySymbols { get; set; }
Selector: standaloneWeekdaySymbols
Property: string [] StandaloneWeekdaySymbols { get; set; }
Selector: shortStandaloneWeekdaySymbols
Property: string [] ShortStandaloneWeekdaySymbols { get; set; }
Selector: veryShortStandaloneWeekdaySymbols
Property: string [] VeryShortStandaloneWeekdaySymbols { get; set; }
Selector: quarterSymbols
Property: string [] QuarterSymbols { get; set; }
Selector: shortQuarterSymbols
Property: string [] ShortQuarterSymbols { get; set; }
Selector: standaloneQuarterSymbols
Property: string [] StandaloneQuarterSymbols { get; set; }
Selector: shortStandaloneQuarterSymbols
Property: string [] ShortStandaloneQuarterSymbols { get; set; }
Selector: gregorianStartDate
Property: NSDate GregorianStartDate { get; set; }

Class NSFormatter

Selector: stringForObjectValue:
Method: string StringFor (NSObject value);
Selector: editingStringForObjectValue:
Method: string EditingStringFor (NSObject value);

Class NSKeyedArchiverDelegate

Selector: archiver:didEncodeObject:"), EventArgs ("NSObject
Method: void EncodedObject (NSKeyedArchiver archiver, NSObject obj);
Selector: archiverDidFinish:
Method: void Finished (NSKeyedArchiver archiver);
Selector: archiver:willEncodeObject:"), DelegateName ("NSEncodeHook
Method: NSObject WillEncode (NSKeyedArchiver archiver, NSObject obj);
Selector: archiverWillFinish:
Method: void Finishing (NSKeyedArchiver archiver);
Selector: archiver:willReplaceObject:withObject:"), EventArgs ("NSArchiveReplace
Method: void ReplacingObject (NSKeyedArchiver archiver, NSObject oldObject, NSObject newObject);

Class NSKeyedUnarchiverDelegate

Selector: unarchiver:didDecodeObject:"), DelegateName ("NSDecoderCallback
Method: NSObject DecodedObject (NSKeyedUnarchiver unarchiver, NSObject obj);
Selector: unarchiverDidFinish:
Method: void Finished (NSKeyedUnarchiver unarchiver);
Selector: unarchiver:cannotDecodeObjectOfClassName:originalClasses:"), DelegateName ("NSDecoderHandler
Method: Class CannotDecodeClass (NSKeyedUnarchiver unarchiver, string klass, string [] classes);
Selector: unarchiverWillFinish:
Method: void Finishing (NSKeyedUnarchiver unarchiver);
Selector: unarchiver:willReplaceObject:withObject:"), EventArgs ("NSArchiveReplace
Method: void ReplacingObject (NSKeyedUnarchiver unarchiver, NSObject oldObject, NSObject newObject);

Class NSKeyedArchiver

Selector: initForWritingWithMutableData:
Method: IntPtr Constructor (NSMutableData data);
Selector: archivedDataWithRootObject:
Method: [Static]
Selector: archiveRootObject:toFile:
Method: [Static]
Selector: finishEncoding
Method: void FinishEncoding ();
Selector: outputFormat
Property: NSPropertyListFormat PropertyListFormat { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: setClassName:forClass:
Method: void SetClassName (string name, Class kls);
Selector: classNameForClass:
Method: string GetClassName (Class kls);

Class NSKeyedUnarchiver

Selector: initForReadingWithData:
Method: IntPtr Constructor (NSData data);
Selector: unarchiveObjectWithData:
Method: NSObject UnarchiveObject (NSData data);
Selector: unarchiveObjectWithFile:
Method: NSObject UnarchiveFile (string file);
Selector: finishDecoding
Method: void FinishDecoding ();
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: setClass:forClassName:
Method: void SetClass (Class kls, string codedName);
Selector: classForClassName:
Method: Class GetClass (string codedName);

Class NSMetadataQuery

Selector: startQuery
Method: bool StartQuery ();
Selector: stopQuery
Method: void StopQuery ();
Selector: isStarted
Property: bool IsStarted { get; }
Selector: isGathering
Property: bool IsGathering { get; }
Selector: isStopped
Property: bool IsStopped { get; }
Selector: disableUpdates
Method: void DisableUpdates ();
Selector: enableUpdates
Method: void EnableUpdates ();
Selector: resultCount
Property: int ResultCount { get; }
Selector: resultAtIndex:
Method: NSObject ResultAtIndex (int idx);
Selector: results
Property: NSMetadataItem[] Results { get; }
Selector: indexOfResult:
Method: int IndexOfResult (NSObject result);
Selector: valueLists
Property: NSDictionary ValueLists { get; }
Selector: groupedResults
Property: NSObject [] GroupedResults { get; }
Selector: valueOfAttribute:forResultAtIndex:
Method: NSObject ValueOfAttribute (string attribyteName, int atIndex);
Selector: delegate
Property: NSMetadataQueryDelegate WeakDelegate { get; set; }
Selector: predicate
Property: NSPredicate Predicate { get; set; }
Selector: sortDescriptors
Property: NSSortDescriptor[] SortDescriptors { get; set; }
Selector: valueListAttributes
Property: NSObject[] ValueListAttributes { get; set; }
Selector: groupingAttributes
Property: NSArray GroupingAttributes { get; set; }
Selector: notificationBatchingInterval
Property: double NotificationBatchingInterval { get; set; }
Selector: searchScopes
Property: NSObject [] SearchScopes { get; set; }

Class NSMetadataQueryDelegate

Selector: metadataQuery:replacementObjectForResultObject:"), DelegateName ("NSMetadataQueryObject
Method: NSObject ReplacementObjectForResultObject (NSMetadataQuery query, NSMetadataItem result);
Selector: metadataQuery:replacementValueForAttribute:value:"), DelegateName ("NSMetadataQueryValue
Method: NSObject ReplacementValueForAttributevalue (NSMetadataQuery query, string attributeName, NSObject value);

Class NSMetadataItem

Selector: valueForAttribute:
Method: NSObject ValueForAttribute (string key);
Selector: valuesForAttributes:
Method: NSDictionary ValuesForAttributes (NSArray keys);
Selector: attributes
Property: NSObject [] Attributes { get; }

Class NSMetadataQueryAttributeValueTuple

Selector: attribute
Property: string Attribute { get; }
Selector: value
Property: NSObject Value { get; }
Selector: count
Property: int Count { get; }

Class NSMetadataQueryResultGroup

Selector: attribute
Property: string Attribute { get; }
Selector: value
Property: NSObject Value { get; }
Selector: subgroups
Property: NSObject [] Subgroups { get; }
Selector: resultCount
Property: int ResultCount { get; }
Selector: resultAtIndex:
Method: NSObject ResultAtIndex (uint idx);
Selector: results
Property: NSObject [] Results { get; }

Class NSMutableAttributedString

Selector: initWithString:
Method: IntPtr Constructor (string str);
Selector: initWithString:attributes:
Method: IntPtr Constructor (string str, NSDictionary attributes);
Selector: initWithAttributedString:
Method: IntPtr Constructor (NSAttributedString other);
Selector: replaceCharactersInRange:withString:
Method: void Replace (NSRange range, string newValue);
Selector: setAttributes:range:
Method: void SetAttributes (NSDictionary attrs, NSRange range);
Selector: addAttribute:value:range:
Method: void AddAttribute (NSString attributeName, NSObject value, NSRange range);
Selector: addAttributes:range:
Method: void AddAttributes (NSDictionary attrs, NSRange range);
Selector: removeAttribute:range:
Method: void RemoveAttribute (string name, NSRange range);
Selector: replaceCharactersInRange:withAttributedString:
Method: void Replace (NSRange range, NSAttributedString value);
Selector: insertAttributedString:atIndex:
Method: void Insert (NSAttributedString attrString, int location);
Selector: appendAttributedString:
Method: void Append (NSAttributedString attrString);
Selector: deleteCharactersInRange:
Method: void DeleteRange (NSRange range);
Selector: setAttributedString:
Method: void SetString (NSAttributedString attrString);
Selector: beginEditing
Method: void BeginEditing ();
Selector: endEditing
Method: void EndEditing ();

Class NSMutableData

Selector: dataWithCapacity:
Method: NSMutableData FromCapacity (int capacity);
Selector: dataWithLength:
Method: NSMutableData FromLength (int length);
Selector: data
Method: NSMutableData Create ();
Selector: setLength:
Method: void SetLength (uint len);
Selector: mutableBytes
Property: IntPtr MutableBytes { get; }
Selector: initWithCapacity:
Method: IntPtr Constructor (uint len);
Selector: appendData:
Method: void AppendData (NSData other);
Selector: appendBytes:length:
Method: void AppendBytes (IntPtr bytes, uint len);
Selector: setData:
Method: void SetData (NSData data);

Class NSDate

Selector: timeIntervalSinceReferenceDate
Property: double SecondsSinceReferenceDate { get; }
Selector: dateWithTimeIntervalSinceReferenceDate:
Method: [Static]
Selector: dateWithTimeIntervalSince1970:
Method: NSDate FromTimeIntervalSince1970 (double secs);
Selector: date
Method: [Static]
Selector: distantPast
Method: [Static]
Selector: distantFuture
Method: [Static]
Selector: dateByAddingTimeInterval:
Method: NSDate AddSeconds (double seconds);
Selector: description
Property: string Description { get; }
Selector: dateWithTimeIntervalSinceNow:
Method: [Static]

Class NSDictionary

Selector: dictionaryWithContentsOfFile:
Method: [Static]
Selector: dictionaryWithContentsOfURL:
Method: [Static]
Selector: dictionaryWithObject:forKey:
Method: [Static]
Selector: dictionaryWithDictionary:
Method: [Static]
Selector: dictionaryWithObjects:forKeys:count:
Method: [Static, Internal]
Selector: dictionaryWithObjects:forKeys:
Method: [Static, Internal]
Selector: initWithDictionary:
Method: IntPtr Constructor (NSDictionary other);
Selector: initWithContentsOfFile:
Method: IntPtr Constructor (string fileName);
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl url);
Selector: count
Property: uint Count { get; }
Selector: objectForKey:
Method: NSObject ObjectForKey (NSObject key);
Selector: allKeys
Property: NSObject [] Keys { get; }
Selector: allKeysForObject:
Method: NSObject [] KeysForObject (NSObject obj);
Selector: allValues
Property: NSObject [] Values { get; }
Selector: description
Property: string Description {get; }
Selector: descriptionInStringsFileFormat
Property: string DescriptionInStringsFileFormat { get; }
Selector: isEqualToDictionary:
Method: bool IsEqualToDictionary (NSDictionary other);
Selector: objectEnumerator
Property: NSEnumerator ObjectEnumerator { get; }
Selector: objectsForKeys:notFoundMarker:
Method: NSObject [] ObjectsForKeys (NSArray keys, NSObject marker);
Selector: writeToFile:atomically:
Method: bool WriteToFile (string path, bool useAuxiliaryFile);
Selector: writeToURL:atomically:
Method: bool WriteToUrl (NSUrl url, bool atomically);

Class NSEnumerator

Selector: nextObject
Method: NSObject NextObject ();

Class NSError

Selector: errorWithDomain:code:userInfo:
Method: NSError FromDomain (NSString domain, int code, [NullAllowed] NSDictionary userInfo);
Selector: initWithDomain:code:userInfo:
Method: IntPtr Constructor (NSString domain, int code, [NullAllowed] NSDictionary userInfo);
Selector: domain
Property: string Domain { get; }
Selector: code
Property: int Code { get; }
Selector: userInfo
Property: NSDictionary UserInfo { get; }
Selector: localizedDescription
Property: string LocalizedDescription { get; }

Class NSException

Selector: name
Property: string Name { get; }
Selector: reason
Property: string Reason { get; }
Selector: userInfo
Property: NSObject UserInfo { get; }
Selector: callStackReturnAddresses
Property: NSNumber[] CallStackReturnAddresses { get; }

Class NSExpression

Selector: expressionForConstantValue:
Method: NSExpression FromConstant (NSObject obj);
Selector: expressionForEvaluatedObject
Property: NSExpression ExpressionForEvaluatedObject { get; }
Selector: expressionForVariable:
Method: NSExpression FromVariable (string string1);
Selector: expressionForKeyPath:
Method: NSExpression FromKeyPath (string keyPath);
Selector: expressionForFunction:arguments:
Method: NSExpression FromFunction (string name, NSExpression[] parameters);
Selector: expressionWithFormat:argumentArray:
Method: NSExpression FromFormat (string format, NSExpression [] parameters);
Selector: expressionForAggregate:
Method: NSExpression FromAggregate (NSExpression [] subexpressions);
Selector: expressionForUnionSet:with:
Method: NSExpression FromUnionSet (NSExpression left, NSExpression right);
Selector: expressionForIntersectSet:with:
Method: NSExpression FromIntersectSet (NSExpression left, NSExpression right);
Selector: expressionForMinusSet:with:
Method: NSExpression FromMinusSet (NSExpression left, NSExpression right);
Selector: expressionForSubquery:usingIteratorVariable:predicate:
Method: NSExpression FromSubquery (NSExpression expression, string variable, NSObject predicate);
Selector: expressionForFunction:selectorName:arguments:
Method: NSExpression FromFunction (NSExpression target, string name, NSExpression[] parameters);
Selector: expressionForBlock:selectorName:arguments:
Method: NSExpression FromFunction (NSExpressionHandler target, NSExpression[] parameters);
Selector: initWithExpressionType:
Method: IntPtr Constructor (NSExpressionType type);
Selector: expressionType
Property: NSExpressionType ExpressionType { get; }
Selector: constantValue
Property: NSObject ConstantValue { get; }
Selector: keyPath
Property: string KeyPath { get; }
Selector: function
Property: string Function { get; }
Selector: variable
Property: string Variable { get; }
Selector: operand
Property: NSExpression Operand { get; }
Selector: arguments
Property: NSExpression[] Arguments { get; }
Selector: collection
Property: NSObject Collection { get; }
Selector: predicate
Property: NSPredicate Predicate { get; }
Selector: leftExpression
Property: NSExpression LeftExpression { get; }
Selector: rightExpression
Property: NSExpression RightExpression { get; }
Selector: expressionValueWithObject:context:
Method: NSExpression ExpressionValueWithObject (NSObject object1, NSMutableDictionary context);

Class NSNull

Selector: null
Property: NSNull Null { get; }

Class NSLinguisticTagger

Selector: initWithTagSchemes:options:
Method: IntPtr Constructor (NSString [] tagSchemes, NSLinguisticTaggerOptions opts);
Selector: tagSchemes
Property: NSString [] TagSchemes { get; }
Selector: availableTagSchemesForLanguage:
Method: NSString [] GetAvailableTagSchemesForLanguage (string language);
Selector: setOrthography:range:
Method: void SetOrthographyrange (NSOrthography orthography, NSRange range);
Selector: orthographyAtIndex:effectiveRange:
Method: NSOrthography GetOrthography (int charIndex, IntPtr effectiveRangePtr);
Selector: stringEditedInRange:changeInLength:
Method: void StringEditedInRange (NSRange newRange, int delta);
Selector: enumerateTagsInRange:scheme:options:usingBlock:
Method: void EnumerateTagsInRange (NSRange range, NSString tagScheme, NSLinguisticTaggerOptions opts, NSLingusticEnumerator enumerator);
Selector: sentenceRangeForRange:
Method: NSRange GetSentenceRangeForRange (NSRange range);
Selector: tagAtIndex:scheme:tokenRange:sentenceRange:
Method: string GetTag (int charIndex, NSString tagScheme, IntPtr tokenRangePtr, IntPtr sentenceRangePtr);
Selector: tagsInRange:scheme:options:tokenRanges:
Method: NSString [] GetTangsInRange (NSRange range, NSString tagScheme, NSLinguisticTaggerOptions opts, IntPtr refToNSArrayTokenRanges);
Selector: possibleTagsAtIndex:scheme:tokenRange:sentenceRange:scores:
Method: NSString [] GetPossibleTags (int charIndex, NSString tagScheme, IntPtr tokenRangePointer, IntPtr sentenceRangePointer, IntPtr IntPtrToReturnArrayScores);
Selector: string
Property: string AnalysisString { get; set; }

Class NSLinguisticTag

Class NSLocale

Selector: systemLocale
Property: NSLocale SystemLocale { get; }
Selector: currentLocale
Property: NSLocale CurrentLocale { get; }
Selector: autoUpdatingCurrentLocale
Property: NSLocale AutoUpdatingCurrentLocale { get; }
Selector: initWithLocaleIdentifier:
Method: IntPtr Constructor (string identifier);
Selector: localeIdentifier
Property: string LocaleIdentifier { get; }
Selector: availableLocaleIdentifiers
Property: string [] AvailableLocaleIdentifiers { get; }
Selector: ISOLanguageCodes
Property: string [] ISOLanguageCodes { get; }
Selector: ISOCurrencyCodes
Property: string [] ISOCurrencyCodes { get; }
Selector: ISOCountryCodes
Property: string [] ISOCountryCodes { get; }
Selector: commonISOCurrencyCodes
Property: string [] CommonISOCurrencyCodes { get; }
Selector: preferredLanguages
Property: string [] PreferredLanguages { get; }
Selector: componentsFromLocaleIdentifier:
Method: NSDictionary ComponentsFromLocaleIdentifier (string identifier);
Selector: localeIdentifierFromComponents:
Method: string LocaleIdentifierFromComponents (NSDictionary dict);
Selector: canonicalLanguageIdentifierFromString
Method: string CanonicalLanguageIdentifierFromString (string str);
Selector: canonicalLocaleIdentifierFromString:
Method: string CanonicalLocaleIdentifierFromString (string str);
Selector: characterDirectionForLanguage
Method: NSLocaleLanguageDirection GetCharacterDirection (string isoLanguageCode);
Selector: lineDirectionForLanguage
Method: NSLocaleLanguageDirection GetLineDirection (string isoLanguageCode);
Selector: objectForKey:
Method: NSObject ObjectForKey (NSString key);

Class NSRunLoop

Selector: currentRunLoop
Property: NSRunLoop Current { get; }
Selector: mainRunLoop
Property: NSRunLoop Main { get; }
Selector: currentMode
Property: NSString CurrentMode { get; }
Selector: getCFRunLoop
Method: CFRunLoop GetCFRunLoop ();
Selector: addTimer:forMode:
Method: void AddTimer (NSTimer timer, NSString forMode);
Selector: limitDateForMode:
Method: NSDate LimitDateForMode (NSString mode);
Selector: acceptInputForMode:beforeDate:
Method: void AcceptInputForMode (NSString mode, NSDate limitDate);
Selector: run
Method: void Run ();
Selector: runUntilDate:
Method: void RunUntil (NSDate date);
Selector: runMode:beforeDate:
Method: bool RunUntil (NSString runLoopMode, NSDate limitdate);

Class NSSet

Selector: set
Method: NSSet CreateSet ();
Selector: initWithArray:
Method: IntPtr Constructor (NSArray other);
Selector: count
Property: uint Count { get; }
Selector: anyObject
Property: NSObject AnyObject { get; }
Selector: containsObject:
Method: bool Contains (NSObject id);
Selector: allObjects
Method: IntPtr _AllObjects ();
Selector: description
Property: string Description { get; }
Selector: isEqualToSet:
Method: bool IsEqualToSet (NSSet other);
Selector: isSubsetOfSet:
Method: bool IsSubsetOf (NSSet other);
Selector: enumerateObjectsUsingBlock:
Method: [Since (4,0)]

Class NSSortDescriptor

Selector: initWithKey:ascending:
Method: IntPtr Constructor (string key, bool ascending);
Selector: initWithKey:ascending:selector:
Method: IntPtr Constructor (string key, bool ascending, Selector selector);
Selector: key
Property: string Key { get; }
Selector: ascending
Property: bool Ascending { get; }
Selector: selector
Property: Selector Selector { get; }
Selector: compareObject:toObject:
Method: NSComparisonResult Compare (NSObject object1, NSObject object2);
Selector: reversedSortDescriptor
Property: NSObject ReversedSortDescriptor { get; }

Class NSTimer

Selector: scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:
Method: NSTimer CreateScheduledTimer (double seconds, NSObject target, Selector selector, [NullAllowed] NSObject userInfo, bool repeats);
Selector: timerWithTimeInterval:target:selector:userInfo:repeats:
Method: NSTimer CreateTimer (double seconds, NSObject target, Selector selector, [NullAllowed] NSObject userInfo, bool repeats);
Selector: initWithFireDate:interval:target:selector:userInfo:repeats:
Method: IntPtr Constructor (NSDate date, double seconds, NSObject target, Selector selector, [NullAllowed] NSObject userInfo, bool repeats);
Selector: fire
Method: void Fire ();
Selector: fireDate
Property: NSDate FireDate { get; set; }
Selector: invalidate
Method: void Invalidate ();
Selector: isValid
Property: bool IsValid { get; }
Selector: timeInterval
Property: double TimeInterval { get; }
Selector: userInfo
Property: NSObject UserInfo { get; }

Class NSTimeZone

Selector: initWithName:
Method: IntPtr Constructor (string name);
Selector: name
Property: string Name { get; }
Selector: data
Property: NSData Data { get; }
Selector: secondsFromGMTForDate:
Method: int SecondsFromGMT (NSDate date);
Selector: abbreviationForDate:
Method: string Abbreviation (NSDate date);
Selector: isDaylightSavingTimeForDate:
Method: bool IsDaylightSavingsTime (NSDate date);
Selector: daylightSavingTimeOffsetForDate:
Method: double DaylightSavingTimeOffset (NSDate date);
Selector: nextDaylightSavingTimeTransitionAfterDate:
Method: NSDate NextDaylightSavingTimeTransitionAfter (NSDate date);
Selector: timeZoneWithName:
Method: NSTimeZone FromName (string tzName);
Selector: localTimeZone
Property: NSTimeZone LocalTimeZone { get; }
Selector: description
Property: string Description { get; }
Selector: secondsFromGMT
Property: int GetSecondsFromGMT { get; }
Selector: defaultTimeZone
Property: NSTimeZone DefaultTimeZone { get; set; }
Selector: resetSystemTimeZone
Method: void ResetSystemTimeZone ();
Selector: systemTimeZone
Property: NSTimeZone SystemTimeZone { get; }
Selector: timeZoneWithAbbreviation:
Method: NSTimeZone FromAbbreviation (string abbreviation);

Class NSUbiquitousKeyValueStore

Selector: defaultStore
Property: NSUbiquitousKeyValueStore DefaultStore { get; }
Selector: objectForKey:
Method: NSObject ObjectForKey (string aKey);
Selector: setObject:forKey:
Method: void SetObjectForKey (NSObject anObject, string aKey);
Selector: removeObjectForKey:
Method: void Remove (string aKey);
Selector: stringForKey:
Method: string GetString (string aKey);
Selector: arrayForKey:
Method: NSObject [] GetArray (string aKey);
Selector: dictionaryForKey:
Method: NSDictionary GetDictionary (string aKey);
Selector: dataForKey:
Method: NSData GetData (string aKey);
Selector: longLongForKey:
Method: long GetLong (string aKey);
Selector: doubleForKey:
Method: double GetDouble (string aKey);
Selector: boolForKey:
Method: bool GetBool (string aKey);
Selector: setString:forKey:
Method: void _SetString (string aString, string aKey);
Selector: setData:forKey:
Method: void _SetData (NSData data, string key);
Selector: setArray:forKey:
Method: void _SetArray (NSObject [] array, string key);
Selector: setDictionary:forKey:
Method: void _SetDictionary (NSDictionary aDictionary, string aKey);
Selector: setLongLong:forKey:
Method: void _SetLong (long value, string aKey);
Selector: setDouble:forKey:
Method: void _SetDouble (double value, string aKey);
Selector: setBool:forKey:
Method: void _SetBool (bool value, string aKey);
Selector: dictionaryRepresentation
Method: NSDictionary DictionaryRepresentation ();
Selector: synchronize
Method: bool Synchronize ();

Class NSUserDefaults

Selector: standardUserDefaults
Property: NSUserDefaults StandardUserDefaults { get; }
Selector: resetStandardUserDefaults
Method: void ResetStandardUserDefaults ();
Selector: initWithUser:
Method: IntPtr Constructor (string username);
Selector: objectForKey:
Method: NSObject ObjectForKey (string defaultName);
Selector: setObject:forKey:
Method: void SetObjectForKey (NSObject value, string defaultName);
Selector: removeObjectForKey:
Method: void RemoveObject (string defaultName);
Selector: stringForKey:
Method: string StringForKey (string defaultName);
Selector: arrayForKey:
Method: NSObject [] ArrayForKey (string defaultName);
Selector: dictionaryForKey:
Method: NSDictionary DictionaryForKey (string defaultName);
Selector: dataForKey:
Method: NSData DataForKey (string defaultName);
Selector: stringArrayForKey:
Method: string [] StringArrayForKey (string defaultName);
Selector: integerForKey:
Method: int IntForKey (string defaultName);
Selector: floatForKey:
Method: float FloatForKey (string defaultName);
Selector: doubleForKey:
Method: double DoubleForKey (string defaultName);
Selector: boolForKey:
Method: bool BoolForKey (string defaultName);
Selector: setInteger:forKey:
Method: void SetInt (int value, string defaultName);
Selector: setFloat:forKey:
Method: void SetFloat (float value, string defaultName);
Selector: setDouble:forKey:
Method: void SetDouble (double value, string defaultName);
Selector: setBool:forKey:
Method: void SetBool (bool value, string defaultName);
Selector: registerDefaults:
Method: void RegisterDefaults (NSDictionary registrationDictionary);
Selector: addSuiteNamed:
Method: void AddSuite (string suiteName);
Selector: removeSuiteNamed:
Method: void RemoveSuite (string suiteName);
Selector: dictionaryRepresentation
Method: NSDictionary AsDictionary ();
Selector: volatileDomainNames
Method: string [] VolatileDomainNames ();
Selector: volatileDomainForName:
Method: NSDictionary GetVolatileDomain (string domainName);
Selector: setVolatileDomain:forName:
Method: void SetVolatileDomain (NSDictionary domain, string domainName);
Selector: removeVolatileDomainForName:
Method: void RemoveVolatileDomain (string domainName);
Selector: persistentDomainNames
Method: string [] PersistentDomainNames ();
Selector: persistentDomainForName:
Method: NSDictionary PersistentDomainForName (string domainName);
Selector: setPersistentDomain:forName:
Method: void SetPersistentDomain (NSDictionary domain, string domainName);
Selector: removePersistentDomainForName:
Method: void RemovePersistentDomain (string domainName);
Selector: synchronize
Method: bool Synchronize ();
Selector: objectIsForcedForKey:
Method: bool ObjectIsForced (string key);
Selector: objectIsForcedForKey:inDomain:
Method: bool ObjectIsForced (string key, string domain);

Class NSUrl

Selector: initWithScheme:host:path:
Method: IntPtr Constructor (string scheme, string host, string path);
Selector: initFileURLWithPath:isDirectory:
Method: IntPtr Constructor (string path, bool isDir);
Selector: initWithString:
Method: IntPtr Constructor (string path);
Selector: initWithString:relativeToURL:
Method: IntPtr Constructor (string path, string relativeToUrl);
Selector: URLWithString:
Method: NSUrl FromString (string s);
Selector: URLWithString:relativeToURL:
Method: NSUrl _FromStringRelative (string url, NSUrl relative);
Selector: absoluteString
Property: string AbsoluteString { get; }
Selector: absoluteURL
Property: NSUrl AbsoluteUrl { get; }
Selector: baseURL
Property: NSUrl BaseUrl { get; }
Selector: fragment
Property: string Fragment { get; }
Selector: host
Property: string Host { get; }
Selector: isEqual:
Method: bool IsEqual (NSUrl other);
Selector: isFileURL
Property: bool IsFileUrl { get; }
Selector: parameterString
Property: string ParameterString { get;}
Selector: password
Property: string Password { get;}
Selector: path
Property: string Path { get;}
Selector: query
Property: string Query { get;}
Selector: relativePath
Property: string RelativePath { get;}
Selector: relativeString
Property: string RelativeString { get;}
Selector: resourceSpecifier
Property: string ResourceSpecifier { get;}
Selector: scheme
Property: string Scheme { get;}
Selector: user
Property: string User { get;}
Selector: standardizedURL
Property: NSUrl StandardizedUrl { get; }
Selector: URLByAppendingPathComponent:isDirectory:
Method: NSUrl Append (string pathComponent, bool isDirectory);
Selector: URLFromPasteboard:
Method: NSUrl FromPasteboard (NSPasteboard pasteboard);
Selector: writeToPasteboard:
Method: void WriteToPasteboard (NSPasteboard pasteboard);
Selector: getResourceValue:forKey:error:
Method: bool GetResourceValue (out NSObject value, string key, out NSError error);
Selector: resourceValuesForKeys:error:
Method: NSDictionary GetResourceValues (NSString [] keys, out NSError error);
Selector: setResourceValue:forKey:error:
Method: bool SetResourceValue (NSObject value, string key, out NSError error);
Selector: port
Property: //NSNumber Port { get;}

Class NSUrlCache

Selector: sharedURLCache
Property: NSUrlCache SharedCache { get; set; }
Selector: initWithMemoryCapacity:diskCapacity:diskPath:
Method: IntPtr Constructor (uint memoryCapacity, uint diskCapacity, string diskPath);
Selector: cachedResponseForRequest:
Method: NSCachedUrlResponse CachedResponseForRequest (NSUrlRequest request);
Selector: storeCachedResponse:forRequest:
Method: void StoreCachedResponse (NSCachedUrlResponse cachedResponse, NSUrlRequest forRequest);
Selector: removeCachedResponseForRequest:
Method: void RemoveCachedResponse (NSUrlRequest request);
Selector: removeAllCachedResponses
Method: void RemoveAllCachedResponses ();
Selector: memoryCapacity
Property: uint MemoryCapacity { get; set; }
Selector: diskCapacity
Property: uint DiskCapacity { get; set; }
Selector: currentMemoryUsage
Property: uint CurrentMemoryUsage { get; }
Selector: currentDiskUsage
Property: uint CurrentDiskUsage { get; }

Class NSUrlAuthenticationChallenge

Selector: initWithProtectionSpace:proposedCredential:previousFailureCount:failureResponse:error:sender:
Method: IntPtr Constructor (NSUrlProtectionSpace space, NSUrlCredential credential, int previousFailureCount, NSUrlResponse response, NSError error, NSUrlConnection sender);
Selector: initWithAuthenticationChallenge:sender:
Method: IntPtr Constructor (NSUrlAuthenticationChallenge challenge, NSUrlConnection sender);
Selector: protectionSpace
Property: NSUrlProtectionSpace ProtectionSpace { get; }
Selector: proposedCredential
Property: NSUrlCredential ProposedCredential { get; }
Selector: previousFailureCount
Property: int PreviousFailureCount { get; }
Selector: failureResponse
Property: NSUrlResponse FailureResponse { get; }
Selector: error
Property: NSError Error { get; }
Selector: sender
Property: NSUrlConnection Sender { get; }
Selector: performDefaultHandlingForAuthenticationChallenge:
Method: void PerformDefaultHandlingForChallenge (NSUrlAuthenticationChallenge challenge);
Selector: rejectProtectionSpaceAndContinueWithChallenge:
Method: void PejectProtectionSpaceAndContinueWithChallenge (NSUrlAuthenticationChallenge challenge);

Class NSUrlConnection

Selector: canHandleRequest:
Method: bool CanHandleRequest (NSUrlRequest request);
Selector: connectionWithRequest:delegate:
Method: NSUrlConnection FromRequest (NSUrlRequest request, NSUrlConnectionDelegate del);
Selector: initWithRequest:delegate:
Method: IntPtr Constructor (NSUrlRequest request, NSUrlConnectionDelegate del);
Selector: initWithRequest:delegate:startImmediately:
Method: IntPtr Constructor (NSUrlRequest request, NSUrlConnectionDelegate del, bool startImmediately);
Selector: start
Method: void Start ();
Selector: cancel
Method: void Cancel ();
Selector: scheduleInRunLoop:forMode:
Method: void Schedule (NSRunLoop aRunLoop, string forMode);
Selector: unscheduleFromRunLoop:forMode:
Method: void Unschedule (NSRunLoop aRunLoop, string forMode);
Selector: useCredential:forAuthenticationChallenge:
Method: void UseCredentials (NSUrlCredential credential, NSUrlAuthenticationChallenge challenge);
Selector: continueWithoutCredentialForAuthenticationChallenge:
Method: void ContinueWithoutCredentialForAuthenticationChallenge (NSUrlAuthenticationChallenge challenge);
Selector: cancelAuthenticationChallenge:
Method: void CancelAuthenticationChallenge (NSUrlAuthenticationChallenge challenge);
Selector: originalRequest
Property: NSUrlRequest OriginalRequest { get; }
Selector: currentRequest
Property: NSUrlRequest CurrentRequest { get; }
Selector: setDelegateQueue:
Method: [Since (5,0)]
Selector: sendAsynchronousRequest:queue:completionHandler:
Method: void SendAsynchronousRequest (NSUrlRequest request, NSOperationQueue queue, NSUrlConnectionDataResponse completionHandler);
Selector: newsstandAssetDownload
Property: MonoTouch.NewsstandKit.NKAssetDownload NewsstandAssetDownload { get; }

Class NSUrlConnectionDelegate

Selector: connection:willSendRequest:redirectResponse:
Method: NSUrlRequest WillSendRequest (NSUrlConnection connection, NSUrlRequest request, NSUrlResponse response);
Selector: connection:canAuthenticateAgainstProtectionSpace:
Method: bool CanAuthenticateAgainstProtectionSpace (NSUrlConnection connection, NSUrlProtectionSpace protectionSpace);
Selector: connection:needNewBodyStream:
Method: NSInputStream NeedNewBodyStream (NSUrlConnection connection, NSUrlRequest request);
Selector: connection:didReceiveAuthenticationChallenge:
Method: void ReceivedAuthenticationChallenge (NSUrlConnection connection, NSUrlAuthenticationChallenge challenge);
Selector: connection:didCancelAuthenticationChallenge:
Method: void CanceledAuthenticationChallenge (NSUrlConnection connection, NSUrlAuthenticationChallenge challenge);
Selector: connectionShouldUseCredentialStorage:
Method: bool ConnectionShouldUseCredentialStorage (NSUrlConnection connection);
Selector: connection:didReceiveResponse:
Method: void ReceivedResponse (NSUrlConnection connection, NSUrlResponse response);
Selector: connection:didReceiveData:
Method: void ReceivedData (NSUrlConnection connection, NSData data);
Selector: connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite:
Method: void SentBodyData (NSUrlConnection connection, int bytesWritten, int totalBytesWritten, int totalBytesExpectedToWrite);
Selector: connectionDidFinishLoading:
Method: void FinishedLoading (NSUrlConnection connection);
Selector: connection:didFailWithError:
Method: void FailedWithError (NSUrlConnection connection, NSError error);
Selector: connection:willCacheResponse:
Method: NSCachedUrlResponse WillCacheResponse (NSUrlConnection connection, NSCachedUrlResponse cachedResponse);

Class NSUrlConnectionDownloadDelegate

Selector: connection:didWriteData:totalBytesWritten:expectedTotalBytes:
Method: void WroteData (NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes);
Selector: connectionDidResumeDownloading:totalBytesWritten:expectedTotalBytes:
Method: void ResumedDownloading (NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes);
Selector: connectionDidFinishDownloading:destinationURL:
Method: void FinishedDownloading (NSUrlConnection connection, NSUrl destinationUrl);

Class NSUrlCredential

Selector: persistence
Property: NSUrlCredentialPersistence Persistence { get; }
Selector: initWithUser:password:persistence:
Method: IntPtr Constructor (string user, string password, NSUrlCredentialPersistence persistence);
Selector: credentialWithUser:password:persistence:
Method: NSUrlCredential FromUserPasswordPersistance (string user, string password, NSUrlCredentialPersistence persistence);
Selector: user
Property: string User { get; }
Selector: password
Property: string Password { get; }
Selector: hasPassword
Property: bool HasPassword {get; }
Selector: initWithIdentity:certificates:persistence:
Method: //IntPtr Constructor (IntPtr SecIdentityRef, IntPtr [] secCertificateRefArray, NSUrlCredentialPersistence persistance);
Selector: credentialWithIdentity:certificates:persistence:
Method: //NSUrlCredential FromIdentityCertificatesPersistance (IntPtr SecIdentityRef, IntPtr [] secCertificateRefArray, NSUrlCredentialPersistence persistence);
Selector: identity
Property: IntPtr Identity {get; }
Selector: certificates
Property: //IntPtr [] Certificates { get; }
Selector: initWithTrust:
Method: IntPtr Constructor (IntPtr SecTrustRef_trust, bool ignored);
Selector: credentialForTrust:
Method: NSUrlCredential FromTrust (IntPtr SecTrustRef_trust);

Class NSUndoManager

Selector: beginUndoGrouping
Method: void BeginUndoGrouping ();
Selector: endUndoGrouping
Method: void EndUndoGrouping ();
Selector: groupingLevel
Property: int GroupingLevel { get; }
Selector: disableUndoRegistration
Method: void DisableUndoRegistration ();
Selector: enableUndoRegistration
Method: void EnableUndoRegistration ();
Selector: isUndoRegistrationEnabled
Property: bool IsUndoRegistrationEnabled { get; }
Selector: groupsByEvent
Property: bool GroupsByEvent { get; set; }
Selector: levelsOfUndo
Property: int LevelsOfUndo { get; set; }
Selector: runLoopModes
Property: string [] RunLoopModes { get; set; }
Selector: undo
Method: void Undo ();
Selector: redo
Method: void Redo ();
Selector: undoNestedGroup
Method: void UndoNestedGroup ();
Selector: canUndo
Property: bool CanUndo { get; }
Selector: canRedo
Property: bool CanRedo { get; }
Selector: isUndoing
Property: bool IsUndoing { get; }
Selector: isRedoing
Property: bool IsRedoing { get; }
Selector: removeAllActions
Method: void RemoveAllActions ();
Selector: removeAllActionsWithTarget:
Method: void RemoveAllActions (NSObject target);
Selector: registerUndoWithTarget:selector:object:
Method: void RegisterUndoWithTarget (NSObject target, Selector selector, NSObject anObject);
Selector: prepareWithInvocationTarget:
Method: NSObject PrepareWithInvocationTarget (NSObject target);
Selector: undoActionName
Property: string UndoActionName { get; }
Selector: redoActionName
Property: string RedoActionName { get; }
Selector: setActionName:
Method: void SetActionname (string actionName);
Selector: undoMenuItemTitle
Property: string UndoMenuItemTitle { get; }
Selector: redoMenuItemTitle
Property: string RedoMenuItemTitle { get; }
Selector: undoMenuTitleForUndoActionName:
Method: string UndoMenuTitleForUndoActionName (string name);
Selector: redoMenuTitleForUndoActionName:
Method: string RedoMenuTitleForUndoActionName (string name);
Selector: setActionIsDiscardable:
Method: void SetActionIsDiscardable (bool discardable);
Selector: undoActionIsDiscardable
Property: bool UndoActionIsDiscardable { get; }
Selector: redoActionIsDiscardable
Property: bool RedoActionIsDiscardable { get; }

Class NSUrlProtectionSpace

Selector: initWithHost:port:protocol:realm:authenticationMethod:
Method: IntPtr Constructor (string host, int port, string protocol, string realm, string authenticationMethod);
Selector: initWithProxyHost:port:type:realm:authenticationMethod:
Method: //IntPtr Constructor (string host, int port, string type, string realm, string authenticationMethod);
Selector: realm
Property: string Realm { get; }
Selector: receivesCredentialSecurely
Property: bool ReceivesCredentialSecurely { get; }
Selector: isProxy
Property: bool IsProxy { get; }
Selector: host
Property: string Host { get; }
Selector: port
Property: int Port { get; }
Selector: proxyType
Property: string ProxyType { get; }
Selector: protocol
Property: string Protocol { get; }
Selector: authenticationMethod
Property: string AuthenticationMethod { get; }
Selector: distinguishedNames
Property: NSData [] DistinguishedNames { get; }
Selector: serverTrust
Method: IntPtr ServerTrust { get ; }

Class NSUrlRequest

Selector: initWithURL:
Method: IntPtr Constructor (NSUrl url);
Selector: initWithURL:cachePolicy:timeoutInterval:
Method: IntPtr Constructor (NSUrl url, NSUrlRequestCachePolicy cachePolicy, double timeoutInterval);
Selector: requestWithURL:
Method: NSUrlRequest FromUrl (NSUrl url);
Selector: URL
Property: NSUrl Url { get; }
Selector: cachePolicy
Property: NSUrlRequestCachePolicy CachePolicy { get; }
Selector: timeoutInterval
Property: double TimeoutInterval { get; }
Selector: mainDocumentURL
Property: NSUrl MainDocumentURL { get; }
Selector: HTTPMethod
Property: string HttpMethod { get; }
Selector: allHTTPHeaderFields
Property: NSDictionary Headers { get; }
Selector: valueForHTTPHeaderField:
Method: string Header (string field);
Selector: HTTPBody
Property: NSData Body { get; }
Selector: HTTPBodyStream
Property: NSInputStream BodyStream { get; }
Selector: HTTPShouldHandleCookies
Property: bool ShouldHandleCookies { get; }

Class NSMutableDictionary

Selector: dictionaryWithContentsOfFile:
Method: [Static]
Selector: dictionaryWithContentsOfURL:
Method: [Static]
Selector: dictionaryWithObject:forKey:
Method: [Static]
Selector: dictionaryWithDictionary:
Method: [Static,New]
Selector: dictionaryWithObjects:forKeys:count:
Method: [Static, Internal]
Selector: dictionaryWithObjects:forKeys:
Method: [Static, Internal, New]
Selector: initWithDictionary:
Method: IntPtr Constructor (NSDictionary other);
Selector: initWithContentsOfFile:
Method: IntPtr Constructor (string fileName);
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl url);
Selector: removeAllObjects
Method: void RemoveAllObjects ();
Selector: removeObjectForKey:
Method: void RemoveObjectForKey (NSObject key);
Selector: setObject:forKey:
Method: void SetObject (NSObject obj, NSObject key);

Class NSMutableSet

Selector: addObject:
Method: void Add (NSObject nso);
Selector: removeObject:
Method: void Remove (NSObject nso);

Class NSMutableUrlRequest

Selector: initWithURL:
Method: IntPtr Constructor (NSUrl url);
Selector: initWithURL:cachePolicy:timeoutInterval:
Method: IntPtr Constructor (NSUrl url, NSUrlRequestCachePolicy cachePolicy, double timeoutInterval);
Selector: URL
Property: NSUrl Url { get; set; }
Selector: cachePolicy
Property: NSUrlRequestCachePolicy CachePolicy { get; set; }
Selector: timeoutInterval
Property: double TimeoutInterval { set; get; }
Selector: mainDocumentURL
Property: NSUrl MainDocumentURL { get; set; }
Selector: HTTPMethod
Property: string HttpMethod { get; set; }
Selector: allHTTPHeaderFields
Property: NSDictionary Headers { get; set; }
Selector: setValue:forHTTPHeaderField:
Method: void _SetValue (string value, string field);
Selector: HTTPBody
Property: NSData Body { get; set; }
Selector: HTTPBodyStream
Property: NSInputStream BodyStream { get; set; }
Selector: HTTPShouldHandleCookies
Property: bool ShouldHandleCookies { get; set; }

Class NSUrlResponse

Selector: initWithURL:MIMEType:expectedContentLength:textEncodingName:
Method: IntPtr Constructor (NSUrl url, string mimetype, int expectedContentLength, [NullAllowed] string textEncodingName);
Selector: URL
Property: NSUrl Url { get; }
Selector: MIMEType
Property: string MimeType { get; }
Selector: expectedContentLength
Property: long ExpectedContentLength { get; }
Selector: textEncodingName
Property: string TextEncodingName { get; }
Selector: suggestedFilename
Property: string SuggestedFilename { get; }

Class NSStream

Selector: open
Method: void Open ();
Selector: close
Method: void Close ();
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: propertyForKey:
Method: NSObject PropertyForKey (NSString key);
Selector: setProperty:forKey:
Method: bool SetPropertyForKey (NSObject property, NSString key);
Selector: scheduleInRunLoop:forMode:
Method: void Schedule (NSRunLoop aRunLoop, string mode);
Selector: removeFromRunLoop:forMode:
Method: void Unschedule (NSRunLoop aRunLoop, string mode);
Selector: streamStatus
Property: NSStreamStatus Status { get; }
Selector: streamError
Property: NSError Error { get; }

Class NSStreamDelegate

Selector: stream:handleEvent:"), EventArgs ("NSStream"), EventName ("OnEvent
Method: void HandleEvent (NSStream theStream, NSStreamEvent streamEvent);

Class NSString2

Selector: characterAtIndex:
Method: char _characterAtIndex (int index);
Selector: length
Property: int Length {get;}
Selector: hash
Method: int Hash ();
Selector: isEqualToString:
Method: bool IsEqualTo (IntPtr handle);

Class NSInputStream

Selector: read:maxLength:
Method: //int Read (byte [] buffer, uint len);
Selector: getBuffer:length:
Method: //bool GetBuffer (ref byte buffer, ref uint len);
Selector: hasBytesAvailable
Method: bool HasBytesAvailable ();
Selector: initWithFileAtPath:
Method: IntPtr Constructor (string path);
Selector: inputStreamWithData:
Method: NSInputStream FromData (NSData data);
Selector: inputStreamWithFileAtPath:
Method: NSInputStream FromFile (string path);

Class NSObject2

Selector: observeValueForKeyPath:ofObject:change:context:
Method: void ObserveValue (NSString keyPath, NSObject ofObject, NSDictionary change, IntPtr context);
Selector: addObserver:forKeyPath:options:context:
Method: void AddObserver (NSObject observer, NSString keyPath, NSKeyValueObservingOptions options, IntPtr context);
Selector: removeObserver:forKeyPath:
Method: void RemoveObserver (NSObject observer, NSString keyPath);
Selector: willChangeValueForKey:
Method: void WillChangeValue (string forKey);
Selector: didChangeValueForKey:
Method: void DidChangeValue (string forKey);
Selector: willChange:valuesAtIndexes:forKey:
Method: void WillChange (NSKeyValueChange changeKind, NSIndexSet indexes, NSString forKey);
Selector: didChange:valuesAtIndexes:forKey:
Method: void DidChange (NSKeyValueChange changeKind, NSIndexSet indexes, NSString forKey);
Selector: willChangeValueForKey:withSetMutation:usingObjects:
Method: void WillChange (NSString forKey, NSKeyValueSetMutationKind mutationKind, NSSet objects);
Selector: didChangeValueForKey:withSetMutation:usingObjects:
Method: void DidChange (NSString forKey, NSKeyValueSetMutationKind mutationKind, NSSet objects);
Selector: keyPathsForValuesAffectingValueForKey:
Method: NSSet GetKeyPathsForValuesAffecting (NSString key);
Selector: automaticallyNotifiesObserversForKey:
Method: bool AutomaticallyNotifiesObserversForKey (string key);
Selector: valueForKey:
Method: NSObject ValueForKey (NSString key);
Selector: setValue:forKey:
Method: void SetValueForKey (NSObject value, NSString key);
Selector: valueForKeyPath:
Method: NSObject ValueForKeyPath (NSString keyPath);
Selector: setValue:forKeyPath:
Method: void SetValueForKeyPath (NSObject value, NSString keyPath);
Selector: valueForUndefinedKey:
Method: NSObject ValueForUndefinedKey (NSString key);
Selector: setValue:forUndefinedKey:
Method: void SetValueForUndefinedKey (NSObject value, NSString undefinedKey);
Selector: setNilValueForKey:
Method: void SetNilValueForKey (NSString key);
Selector: dictionaryWithValuesForKeys:
Method: NSDictionary GetDictionaryOfValuesFromKeys (NSString [] keys);
Selector: setValuesForKeysWithDictionary:
Method: void SetValuesForKeysWithDictionary (NSDictionary keyedValues);
Selector: exposedBindings
Method: NSString[] ExposedBindings ();
Selector: valueClassForBinding:
Method: Class BindingValueClass (string binding);
Selector: bind:toObject:withKeyPath:options:
Method: void Bind (string binding, NSObject observable, string keyPath, [NullAllowed] NSDictionary options);
Selector: unbind:
Method: void Unbind (string binding);
Selector: infoForBinding:
Method: NSDictionary BindingInfo (string binding);
Selector: optionDescriptionsForBinding:
Method: NSObject[] BindingOptionDescriptions (string aBinding);
Selector: defaultPlaceholderForMarker:withBinding:
Method: NSObject GetDefaultPlaceholder (NSObject marker, string binding);
Selector: objectDidEndEditing:
Method: void ObjectDidEndEditing (NSObject editor);
Selector: commitEditing
Method: bool CommitEditing ();
Selector: commitEditingWithDelegate:didCommitSelector:contextInfo:
Method: //void CommitEditingWithDelegateDidCommitSelectorContextInfo (NSObject objDelegate, Selector didCommitSelector, IntPtr contextInfo);

Class NSOperation

Selector: start
Method: void Start ();
Selector: main
Method: void Main ();
Selector: isCancelled
Property: bool IsCancelled { get; }
Selector: cancel
Method: void Cancel ();
Selector: isExecuting
Property: bool IsExecuting { get; }
Selector: isFinished
Property: bool IsFinished { get; }
Selector: isConcurrent
Property: bool IsConcurrent { get; }
Selector: isReady
Property: bool IsReady { get; }
Selector: addDependency:")][PostGet ("Dependencies
Method: void AddDependency (NSOperation op);
Selector: removeDependency:")][PostGet ("Dependencies
Method: void RemoveDependency (NSOperation op);
Selector: dependencies
Property: NSOperation [] Dependencies { get; }
Selector: waitUntilFinished
Method: void WaitUntilFinishedNS ();
Selector: threadPriority
Property: double ThreadPriority { get; set; }
Selector: queuePriority
Property: NSOperationQueuePriority QueuePriority { get; set; }

Class NSBlockOperation

Selector: blockOperationWithBlock:
Method: NSBlockOperation Create (NSAction method);
Selector: addExecutionBlock:
Method: void AddExecutionBlock (NSAction method);
Selector: executionBlocks
Property: NSObject [] ExecutionBlocks { get; }

Class NSOperationQueue

Selector: addOperation:")][PostGet ("Operations
Method: void AddOperation (NSOperation op);
Selector: addOperations:waitUntilFinished:")][PostGet ("Operations
Method: void AddOperations (NSOperation [] operations, bool waitUntilFinished);
Selector: addOperationWithBlock:")][PostGet ("Operations
Method: void AddOperation (NSAction operation);
Selector: operations
Property: NSOperation [] Operations { get; }
Selector: operationCount
Property: int OperationCount { get; }
Selector: name
Property: string Name { get; set; }
Selector: cancelAllOperations")][PostGet ("Operations
Method: void CancelAllOperations ();
Selector: waitUntilAllOperationsAreFinished
Method: void WaitUntilAllOperationsAreFinished ();
Selector: currentQueue
Property: NSOperationQueue CurrentQueue { get; }
Selector: mainQueue
Property: NSOperationQueue MainQueue { get; }
Selector: maxConcurrentOperationCount
Property: int MaxConcurrentOperationCount { get; set; }
Selector: suspended
Property: bool Suspended { [Bind ("isSuspended")]get; set; }

Class NSOrthography

Selector: dominantScript
Property: string DominantScript { get; }
Selector: languageMap
Property: NSDictionary LanguageMap { get; }
Selector: dominantLanguage
Property: string DominantLanguage { get; }
Selector: allScripts
Property: string [] AllScripts { get; }
Selector: allLanguages
Property: string [] AllLanguages { get; }
Selector: languagesForScript:
Method: string [] LanguagesForScript (string script);
Selector: dominantLanguageForScript:
Method: string DominantLanguageForScript (string script);
Selector: initWithDominantScript:languageMap:
Method: IntPtr Constructor (string dominantScript, NSDictionary languageMap);

Class NSOutputStream

Selector: hasSpaceAvailable
Method: bool HasSpaceAvailable ();
Selector: initToBuffer:capacity:
Method: //IntPtr Constructor (uint8_t buffer, NSUInteger capacity);
Selector: initToFileAtPath:append:
Method: IntPtr Constructor (string path, bool shouldAppend);
Selector: outputStreamToMemory
Method: NSObject OutputStreamToMemory ();
Selector: outputStreamToBuffer:capacity:
Method: //NSObject OutputStreamToBuffer (uint8_t buffer, NSUInteger capacity);
Selector: outputStreamToFileAtPath:append:
Method: NSOutputStream CreateFile (string path, bool shouldAppend);

Class NSHttpCookie

Selector: initWithProperties:
Method: IntPtr Constructor (NSDictionary properties);
Selector: cookieWithProperties:
Method: NSHttpCookie CookieFromProperties (NSDictionary properties);
Selector: requestHeaderFieldsWithCookies:
Method: NSDictionary RequestHeaderFieldsWithCookies (NSHttpCookie [] cookies);
Selector: cookiesWithResponseHeaderFields:forURL:
Method: NSHttpCookie [] CookiesWithResponseHeaderFields (NSDictionary headerFields, NSUrl url);
Selector: properties
Property: NSDictionary Properties { get; }
Selector: version
Property: uint Version { get; }
Selector: value
Property: string Value { get; }
Selector: expiresDate
Property: NSDate ExpiresDate { get; }
Selector: isSessionOnly
Property: bool IsSessionOnly { get; }
Selector: domain
Property: string Domain { get; }
Selector: name
Property: string Name { get; }
Selector: path
Property: string Path { get; }
Selector: isSecure
Property: bool IsSecure { get; }
Selector: isHTTPOnly
Property: bool IsHttpOnly { get; }
Selector: comment
Property: string Comment { get; }
Selector: commentURL
Property: NSUrl CommentUrl { get; }
Selector: portList
Property: NSNumber [] PortList { get; }

Class NSHttpCookieStorage

Selector: sharedHTTPCookieStorage
Property: NSHttpCookieStorage SharedStorage { get; }
Selector: cookies
Property: NSHttpCookie [] Cookies { get; }
Selector: setCookie:
Method: void SetCookie (NSHttpCookie cookie);
Selector: deleteCookie:
Method: void DeleteCookie (NSHttpCookie cookie);
Selector: cookiesForURL:
Method: NSHttpCookie [] CookiesForUrl (NSUrl url);
Selector: setCookies:forURL:mainDocumentURL:
Method: void SetCookies (NSHttpCookie [] cookies, NSUrl forUrl, NSUrl mainDocumentUrl);
Selector: cookieAcceptPolicy
Property: NSHttpCookieAcceptPolicy AcceptPolicy { get; set; }
Selector: sortedCookiesUsingDescriptors:
Method: NSHttpCookie [] GetSortedCookies (NSSortDescriptor [] sortDescriptors);

Class NSHttpUrlResponse

Selector: initWithURL:statusCode:HTTPVersion:headerFields:
Method: IntPtr Constructor (NSUrl url, int statusCode, string httpVersion, NSDictionary headerFields);
Selector: statusCode
Property: int StatusCode { get; }
Selector: allHeaderFields
Property: NSDictionary AllHeaderFields { get; }
Selector: localizedStringForStatusCode:
Method: string LocalizedStringForStatusCode (int statusCode);

Class NSBundle

Selector: mainBundle
Property: NSBundle MainBundle { get; }
Selector: bundleWithPath:
Method: NSBundle FromPath (string path);
Selector: initWithPath:
Method: IntPtr Constructor (string path);
Selector: bundleForClass:
Method: NSBundle FromClass (Class c);
Selector: bundleWithIdentifier:
Method: NSBundle FromIdentifier (string str);
Selector: allBundles
Property: NSBundle [] _AllBundles { get; }
Selector: allFrameworks
Property: NSBundle [] AllFrameworks { get; }
Selector: load
Method: void Load ();
Selector: isLoaded
Property: bool IsLoaded { get; }
Selector: unload
Method: void Unload ();
Selector: bundlePath
Property: string BundlePath { get; }
Selector: resourcePath
Property: string ResourcePath { get; }
Selector: executablePath
Property: string ExecutablePath { get; }
Selector: pathForAuxiliaryExecutable:
Method: string PathForAuxiliaryExecutable (string s);
Selector: privateFrameworksPath
Property: string PrivateFrameworksPath { get; }
Selector: sharedFrameworksPath
Property: string SharedFrameworksPath { get; }
Selector: sharedSupportPath
Property: string SharedSupportPath { get; }
Selector: builtInPlugInsPath
Property: string BuiltinPluginsPath { get; }
Selector: bundleIdentifier
Property: string BundleIdentifier { get; }
Selector: classNamed:
Method: Class ClassNamed (string className);
Selector: principalClass
Property: Class PrincipalClass { get; }
Selector: pathForResource:ofType:inDirectory:
Method: string PathForResourceAbsolute (string name, [NullAllowed] string ofType, string bundleDirectory);
Selector: pathForResource:ofType:
Method: string PathForResource (string name, [NullAllowed] string ofType);
Selector: pathForResource:ofType:inDirectory:
Method: //string PathForResource (string name, string ofType, string subpath);
Selector: pathForResource:ofType:inDirectory:forLocalization:
Method: string PathForResource (string name, [NullAllowed] string ofType, string subpath, string localizationName);
Selector: localizedStringForKey:value:table:
Method: string LocalizedString (string key, string value, string table);
Selector: objectForInfoDictionaryKey:
Method: NSObject ObjectForInfoDictionary (string key);
Selector: developmentLocalization
Property: string DevelopmentLocalization { get; }
Selector: infoDictionary
Property: NSDictionary InfoDictionary{ get; }
Selector: loadNibNamed:owner:
Method: bool LoadNib (string nibName, NSObject owner);
Selector: loadNibNamed:owner:options:
Method: NSArray LoadNib (string nibName, NSObject owner, [NullAllowed] NSDictionary options);
Selector: pathForImageResource:
Method: string PathForImageResource (string resource);
Selector: pathForSoundResource:
Method: string PathForSoundResource (string resource);
Selector: bundleURL
Method: [Since (4,0)]
Selector: resourceURL
Method: [Since (4,0)]
Selector: executableURL
Method: [Since (4,0)]
Selector: URLForAuxiliaryExecutable:
Method: [Since (4,0)]
Selector: privateFrameworksURL
Method: [Since (4,0)]
Selector: sharedFrameworksURL
Method: [Since (4,0)]
Selector: sharedSupportURL
Method: [Since (4,0)]
Selector: builtInPlugInsURL
Method: [Since (4,0)]
Selector: initWithURL:
Method: [Since (4,0)]
Selector: bundleWithURL:
Method: [Since (4,0)]

Class NSIndexPath

Selector: indexPathWithIndex:
Method: NSIndexPath FromIndex (uint index);
Selector: indexPathWithIndexes:length:
Method: NSIndexPath _FromIndex (IntPtr indexes, int len);
Selector: indexPathByAddingIndex:
Method: NSIndexPath IndexPathByAddingIndex (uint index);
Selector: indexPathByRemovingLastIndex
Method: NSIndexPath IndexPathByRemovingLastIndex ();
Selector: indexAtPosition:
Method: uint IndexAtPosition (int position);
Selector: length
Property: int Length { get; }
Selector: getIndexes:
Method: void _GetIndexes (IntPtr target);
Selector: compare:
Method: int Compare (NSIndexPath other);
Selector: indexPathForRow:inSection:
Method: NSIndexPath FromRowSection (int row, int section);
Selector: row
Property: int Row { get; }
Selector: section
Property: int Section { get; }

Class NSIndexSet

Selector: indexSetWithIndex:
Method: NSIndexSet FromIndex (int idx);
Selector: indexSetWithIndexesInRange:
Method: NSIndexSet FromNSRange (NSRange indexRange);
Selector: initWithIndex:
Method: IntPtr Constructor (uint index);
Selector: initWithIndexSet:
Method: IntPtr Constructor (NSIndexSet other);
Selector: count
Property: int Count { get; }
Selector: isEqualToIndexSet:
Method: bool IsEqual (NSIndexSet other);
Selector: firstIndex
Property: uint FirstIndex { get; }
Selector: lastIndex
Property: uint LastIndex { get; }
Selector: indexGreaterThanIndex:
Method: uint IndexGreaterThan (uint index);
Selector: indexLessThanIndex:
Method: uint IndexLessThan (uint index);
Selector: indexGreaterThanOrEqualToIndex:
Method: uint IndexGreaterThanOrEqual (uint index);
Selector: indexLessThanOrEqualToIndex:
Method: uint IndexLessThanOrEqual (uint index);
Selector: containsIndex:
Method: bool Contains (uint index);
Selector: containsIndexes:
Method: bool Contains (NSIndexSet indexes);
Selector: enumerateRangesUsingBlock:
Method: void EnumerateRanges (NSRangeIterator iterator);
Selector: enumerateRangesWithOptions:usingBlock:
Method: void EnumerateRanges (NSEnumerationOptions opts, NSRangeIterator iterator);
Selector: enumerateRangesInRange:options:usingBlock:
Method: void EnumerateRanges (NSRange range, NSEnumerationOptions opts, NSRangeIterator iterator);

Class NSJsonSerialization

Selector: isValidJSONObject:
Method: bool IsValidJSONObject (NSObject obj);
Selector: dataWithJSONObject:options:error:
Method: NSData Serialize (NSObject obj, NSJsonWritingOptions opt, out NSError error);
Selector: JSONObjectWithData:options:error:
Method: NSObject Deserialize (NSData data, NSJsonReadingOptions opt, NSError error);
Selector: writeJSONObject:toStream:options:error:
Method: int Serialize (NSObject obj, NSOutputStream stream, NSJsonWritingOptions opt, out NSError error);
Selector: JSONObjectWithStream:options:error:
Method: NSObject Deserialize (NSInputStream stream, NSJsonReadingOptions opt, out NSError error);

Class NSMutableIndexSet

Selector: initWithIndex:
Method: IntPtr Constructor (uint index);
Selector: initWithIndexSet:
Method: IntPtr Constructor (NSIndexSet other);
Selector: addIndexes:
Method: void Add (NSIndexSet other);
Selector: removeIndexes:
Method: void Remove (NSIndexSet other);
Selector: removeAllIndexes
Method: void Clear ();
Selector: addIndex:
Method: void Add (uint index);
Selector: removeIndex:
Method: void Remove (uint index);
Selector: shiftIndexesStartingAtIndex:by:
Method: void ShiftIndexes (uint startIndex, uint delta);

Class NSNetService

Selector: initWithDomain:type:name:port:
Method: IntPtr Constructor (string domain, string type, string name, int port);
Selector: initWithDomain:type:name:
Method: IntPtr Constructor (string domain, string type, string name);
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: scheduleInRunLoop:forMode:
Method: void Schedule (NSRunLoop aRunLoop, string forMode);
Selector: removeFromRunLoop:forMode:
Method: void Unschedule (NSRunLoop aRunLoop, string forMode);
Selector: domain
Property: string Domain { get; }
Selector: type
Property: string Type { get; }
Selector: name
Property: string Name { get; }
Selector: addresses
Property: NSData [] Addresses { get; }
Selector: port
Property: int Port { get; }
Selector: publish
Method: void Publish ();
Selector: publishWithOptions:
Method: void Publish (NSNetServiceOptions options);
Selector: resolve
Method: void Resolve ();
Selector: resolveWithTimeout:
Method: void Resolve (double timeOut);
Selector: stop
Method: void Stop ();
Selector: dictionaryFromTXTRecordData:
Method: NSDictionary DictionaryFromTxtRecord (NSData data);
Selector: dataFromTXTRecordDictionary:
Method: NSData DataFromTxtRecord (NSDictionary dictionary);
Selector: hostName
Property: string HostName { get; }
Selector: getInputStream:outputStream:
Method: bool GetStreams (IntPtr ptrToInputStorage, IntPtr ptrToOutputStorage);
Selector: TXTRecordData
Property: NSData TxtRecordData { get; set; }
Selector: startMonitoring
Method: void StartMonitoring ();
Selector: stopMonitoring
Method: void StopMonitoring ();

Class NSNetServiceDelegate

Selector: netServiceWillPublish:
Method: void WillPublish (NSNetService sender);
Selector: netServiceDidPublish:
Method: void Published (NSNetService sender);
Selector: netService:didNotPublish:"), EventArgs ("NSNetServiceError
Method: void PublishFailure (NSNetService sender, NSDictionary errors);
Selector: netServiceWillResolve:
Method: void WillResolve (NSNetService sender);
Selector: netServiceDidResolveAddress:
Method: void AddressResolved (NSNetService sender);
Selector: netService:didNotResolve:"), EventArgs ("NSNetServiceError
Method: void ResolveFailure (NSNetService sender, NSDictionary errors);
Selector: netServiceDidStop:
Method: void Stopped (NSNetService sender);
Selector: netService:didUpdateTXTRecordData:"), EventArgs ("NSNetServiceData
Method: void UpdatedTxtRecordData (NSNetService sender, NSData data);

Class NSNetServiceBrowser

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: scheduleInRunLoop:forMode:
Method: void Schedule (NSRunLoop aRunLoop, string forMode);
Selector: removeFromRunLoop:forMode:
Method: void Unschedule (NSRunLoop aRunLoop, string forMode);
Selector: searchForBrowsableDomains
Method: void SearchForBrowsableDomains ();
Selector: searchForRegistrationDomains
Method: void SearchForRegistrationDomains ();
Selector: searchForServicesOfType:inDomain:
Method: void SearchForServices (string type, string domain);
Selector: stop
Method: void Stop ();

Class NSNetServiceBrowserDelegate

Selector: netServiceBrowserWillSearch:
Method: void SearchStarted (NSNetServiceBrowser sender);
Selector: netServiceBrowserDidStopSearch:
Method: void SearchStopped (NSNetServiceBrowser sender);
Selector: netServiceBrowser:didNotSearch:"), EventArgs ("NSNetServiceError
Method: void NotSearched (NSNetServiceBrowser sender, NSDictionary errors);
Selector: netServiceBrowser:didFindDomain:moreComing:"), EventArgs ("NSNetDomain
Method: void FoundDomain (NSNetServiceBrowser sender, string domain, bool moreComing);
Selector: netServiceBrowser:didFindService:moreComing:"), EventArgs ("NSNetService
Method: void FoundService (NSNetServiceBrowser sender, NSNetService service, bool moreComing);
Selector: netServiceBrowser:didRemoveDomain:moreComing:"), EventArgs ("NSNetDomain
Method: void DomainRemoved (NSNetServiceBrowser sender, string domain, bool moreComing);
Selector: netServiceBrowser:didRemoveService:moreComing:"), EventArgs ("NSNetService
Method: void ServiceRemoved (NSNetServiceBrowser sender, NSNetService service, bool moreComing);

Class NSNotification

Selector: name
Property: string Name { get; }
Selector: object
Property: NSObject Object { get; }
Selector: userInfo
Property: NSDictionary UserInfo { get; }
Selector: notificationWithName:object:
Method: NSNotification FromName (string name, NSObject obj);
Selector: notificationWithName:object:userInfo:
Method: NSNotification FromName (string name, NSObject obj, NSDictionary userInfo);

Class NSNotificationCenter

Selector: defaultCenter
Property: NSNotificationCenter DefaultCenter { get; }
Selector: addObserver:selector:name:object:
Method: void AddObserver ([RetainList (true, "ObserverList")] NSObject observer, Selector aSelector, [NullAllowed] NSString aName, [NullAllowed] NSObject anObject);
Selector: postNotification:
Method: void PostNotification (NSNotification notification);
Selector: postNotificationName:object:
Method: void PostNotificationName (string aName, [NullAllowed] NSObject anObject);
Selector: postNotificationName:object:userInfo:
Method: void PostNotificationName (string aName, [NullAllowed] NSObject anObject, [NullAllowed] NSDictionary aUserInfo);
Selector: removeObserver:
Method: void RemoveObserver ([RetainList (false, "ObserverList")] NSObject observer);
Selector: removeObserver:name:object:
Method: void RemoveObserver ([RetainList (false, "ObserverList")] NSObject observer, [NullAllowed] string aName, [NullAllowed] NSObject anObject);
Selector: addObserverForName:object:queue:usingBlock:
Method: void AddObserver (string name, NSObject obj, NSOperationQueue queue, NSNotificationHandler handler);

Class NSDistributedNotificationCenter

Selector: defaultCenter
Property: NSObject DefaultCenter { get; }
Selector: addObserver:selector:name:object:suspensionBehavior:
Method: void AddObserver (NSObject observer, Selector selector, string name, string anObject, NSNotificationSuspensionBehavior suspensionBehavior);
Selector: postNotificationName:object:userInfo:deliverImmediately:
Method: void PostNotificationName (string name, string anObject, NSDictionary userInfo, bool deliverImmediately);
Selector: postNotificationName:object:userInfo:options:
Method: void PostNotificationName (string name, string anObject, NSDictionary userInfo, NSNotificationFlags options);
Selector: addObserver:selector:name:object:
Method: void AddObserver (NSObject observer, Selector aSelector, string aName, string anObject);
Selector: postNotificationName:object:
Method: void PostNotificationName (string aName, string anObject);
Selector: postNotificationName:object:userInfo:
Method: void PostNotificationName (string aName, string anObject, NSDictionary aUserInfo);
Selector: removeObserver:name:object:
Method: void RemoveObserver (NSObject observer, string aName, string anObject);
Selector: suspended
Property: bool Suspended { get; set; }

Class NSNotificationQueue

Selector: defaultQueue
Property: NSObject DefaultQueue { get; }
Selector: initWithNotificationCenter:
Method: IntPtr Constructor (NSNotificationCenter notificationCenter);
Selector: enqueueNotification:postingStyle:
Method: void EnqueueNotification (NSNotification notification, NSPostingStyle postingStyle);
Selector: enqueueNotification:postingStyle:coalesceMask:forModes:
Method: void EnqueueNotification (NSNotification notification, NSPostingStyle postingStyle, NSNotificationCoalescing coalesceMask, string [] modes);
Selector: dequeueNotificationsMatching:coalesceMask:
Method: void DequeueNotificationsMatchingcoalesceMask (NSNotification notification, NSNotificationCoalescing coalesceMask);

Class NSValue

Selector: getValue:
Method: void StoreValueAtAddress (IntPtr value);
Selector: objCType
Method: IntPtr ObjCTypePtr ();
Selector: initWithBytes:objCType:
Method: //NSValue InitFromBytes (IntPtr byte_ptr, IntPtr char_ptr_type);
Selector: valueWithBytes:objCType:
Method: //+ (NSValue *)valueWithBytes:(const void *)value objCType:(const char *)type;
Selector: valueWithNonretainedObject:
Method: NSValue ValueFromNonretainedObject (NSObject anObject);
Selector: nonretainedObjectValue
Property: NSObject NonretainedObjectValue { get; }
Selector: valueWithPointer:
Method: NSValue ValueFromPointer (IntPtr pointer);
Selector: pointerValue
Property: IntPtr PointerValue { get; }
Selector: isEqualToValue:
Method: bool IsEqualTo (NSValue value);
Selector: valueWithCMTime:
Method: NSValue FromCMTime (CMTime time);
Selector: CMTimeValue
Property: CMTime CMTimeValue { get; }
Selector: valueWithCMTimeMapping:
Method: NSValue FromCMTimeMapping (CMTimeMapping timeMapping);
Selector: CMTimeMappingValue
Property: CMTimeMapping CMTimeMappingValue { get; }
Selector: valueWithCMTimeRange:
Method: NSValue FromCMTimeRange (CMTimeRange timeRange);
Selector: CMTimeRangeValue
Property: CMTimeRange CMTimeRangeValue { get; }
Selector: valueWithRect:
Method: NSValue FromRectangleF (System.Drawing.RectangleF rect);
Selector: valueWithSize:
Method: NSValue FromSizeF (System.Drawing.SizeF size);
Selector: valueWithPoint:
Method: NSValue FromPointF (System.Drawing.PointF point);
Selector: rectValue
Property: System.Drawing.RectangleF RectangleFValue { get; }
Selector: sizeValue
Property: System.Drawing.SizeF SizeFValue { get; }
Selector: pointValue
Property: System.Drawing.PointF PointFValue { get; }
Selector: valueWithCMTime:
Method: NSValue FromCMTime (CMTime time);
Selector: CMTimeValue
Property: CMTime CMTimeValue { get; }
Selector: valueWithCMTimeMapping:
Method: NSValue FromCMTimeMapping (CMTimeMapping timeMapping);
Selector: CMTimeMappingValue
Property: CMTimeMapping CMTimeMappingValue { get; }
Selector: valueWithCMTimeRange:
Method: NSValue FromCMTimeRange (CMTimeRange timeRange);
Selector: CMTimeRangeValue
Property: CMTimeRange CMTimeRangeValue { get; }
Selector: CGAffineTransformValue
Property: MonoTouch.CoreGraphics.CGAffineTransform CGAffineTransformValue { get; }
Selector: UIEdgeInsetsValue
Property: MonoTouch.UIKit.UIEdgeInsets UIEdgeInsetsValue { get; }
Selector: valueWithCGAffineTransform:
Method: NSValue FromCGAffineTransform (MonoTouch.CoreGraphics.CGAffineTransform tran);
Selector: valueWithUIEdgeInsets:
Method: NSValue FromUIEdgeInsets (MonoTouch.UIKit.UIEdgeInsets insets);
Selector: valueWithCGRect:
Method: NSValue FromRectangleF (System.Drawing.RectangleF rect);
Selector: CGRectValue
Property: System.Drawing.RectangleF RectangleFValue { get; }
Selector: valueWithCGSize:
Method: NSValue FromSizeF (System.Drawing.SizeF size);
Selector: CGSizeValue
Property: System.Drawing.SizeF SizeFValue { get; }
Selector: CGPointValue
Property: System.Drawing.PointF PointFValue { get; }
Selector: valueWithCGPoint:
Method: NSValue FromPointF (System.Drawing.PointF point);
Selector: valueWithCATransform3D:
Method: NSValue FromCATransform3D (MonoTouch.CoreAnimation.CATransform3D transform);
Selector: CATransform3DValue
Property: MonoTouch.CoreAnimation.CATransform3D CATransform3DValue { get; }

Class NSNumber

Selector: charValue
Property: sbyte SByteValue { get; }
Selector: unsignedCharValue
Property: byte ByteValue { get; }
Selector: shortValue
Property: short Int16Value { get; }
Selector: unsignedShortValue
Property: ushort UInt16Value { get; }
Selector: intValue
Property: int Int32Value { get; }
Selector: unsignedIntValue
Property: uint UInt32Value { get; }
Selector: longValue
Method: //int LongValue ();
Selector: unsignedLongValue
Method: //uint UnsignedLongValue ();
Selector: longLongValue
Property: long Int64Value { get; }
Selector: unsignedLongLongValue
Property: ulong UInt64Value { get; }
Selector: floatValue
Property: float FloatValue { get; }
Selector: doubleValue
Property: double DoubleValue { get; }
Selector: decimalValue
Property: NSDecimal NSDecimalValue { get; }
Selector: boolValue
Property: bool BoolValue { get; }
Selector: integerValue
Property: int IntValue { get; }
Selector: unsignedIntegerValue
Property: uint UnsignedIntegerValue { get; }
Selector: stringValue
Property: string StringValue { get; }
Selector: compare:
Method: int Compare (NSNumber otherNumber);
Selector: isEqualToNumber:
Method: bool IsEqualToNumber (NSNumber number);
Selector: descriptionWithLocale:
Method: string DescriptionWithLocale (NSLocale locale);
Selector: initWithChar:
Method: IntPtr Constructor (sbyte value);
Selector: initWithUnsignedChar:
Method: IntPtr Constructor (byte value);
Selector: initWithShort:
Method: IntPtr Constructor (short value);
Selector: initWithUnsignedShort:
Method: IntPtr Constructor (ushort value);
Selector: initWithInt:
Method: IntPtr Constructor (int value);
Selector: initWithUnsignedInt:
Method: IntPtr Constructor (uint value);
Selector: initWithLong:
Method: //IntPtr Constructor (long value);
Selector: initWithUnsignedLong:
Method: //IntPtr Constructor (ulong value);
Selector: initWithLongLong:
Method: IntPtr Constructor (long value);
Selector: initWithUnsignedLongLong:
Method: IntPtr Constructor (ulong value);
Selector: initWithFloat:
Method: IntPtr Constructor (float value);
Selector: initWithDouble:
Method: IntPtr Constructor (double value);
Selector: initWithBool:
Method: IntPtr Constructor (bool value);
Selector: numberWithChar:
Method: NSNumber FromSByte (sbyte value);
Selector: numberWithUnsignedChar:
Method: NSNumber FromByte (byte value);
Selector: numberWithShort:
Method: NSNumber FromInt16 (short value);
Selector: numberWithUnsignedShort:
Method: NSNumber FromUInt16 (ushort value);
Selector: numberWithInt:
Method: NSNumber FromInt32 (int value);
Selector: numberWithUnsignedInt:
Method: NSNumber FromUInt32 (uint value);
Selector: numberWithLong:
Method: //NSNumber * numberWithLong: (long value);
Selector: numberWithUnsignedLong:
Method: //NSNumber * numberWithUnsignedLong: (unsigned long value);
Selector: numberWithLongLong:
Method: NSNumber FromInt64 (long value);
Selector: numberWithUnsignedLongLong:
Method: NSNumber FromUInt64 (ulong value);
Selector: numberWithFloat:
Method: NSNumber FromFloat (float value);
Selector: numberWithDouble:
Method: NSNumber FromDouble (double value);
Selector: numberWithBool:
Method: NSNumber FromBoolean (bool value);

Class NSNumberFormatter

Selector: stringFromNumber:
Method: string StringFromNumber (NSNumber number);
Selector: numberFromString:
Method: NSNumber NumberFromString (string text);
Selector: localizedStringFromNumber:numberStyle:
Method: string LocalizedStringFromNumbernumberStyle (NSNumber num, NSNumberFormatterStyle nstyle);
Selector: numberStyle
Property: NSNumberFormatterStyle NumberStyle { get; set; }
Selector: locale
Property: NSLocale Locale { get; set; }
Selector: generatesDecimalNumbers
Property: bool GeneratesDecimalNumbers { get; set; }
Selector: formatterBehavior
Property: NSNumberFormatterBehavior FormatterBehavior { get; set; }
Selector: defaultFormatterBehavior
Property: NSNumberFormatterBehavior DefaultFormatterBehavior { get; set; }
Selector: negativeFormat
Property: string NegativeFormat { get; set; }
Selector: textAttributesForNegativeValues
Property: NSDictionary TextAttributesForNegativeValues { get; set; }
Selector: positiveFormat
Property: string PositiveFormat { get; set; }
Selector: textAttributesForPositiveValues
Property: NSDictionary TextAttributesForPositiveValues { get; set; }
Selector: allowsFloats
Property: bool AllowsFloats { get; set; }
Selector: decimalSeparator
Property: string DecimalSeparator { get; set; }
Selector: alwaysShowsDecimalSeparator
Property: bool AlwaysShowsDecimalSeparator { get; set; }
Selector: currencyDecimalSeparator
Property: string CurrencyDecimalSeparator { get; set; }
Selector: usesGroupingSeparator
Property: bool UsesGroupingSeparator { get; set; }
Selector: groupingSeparator
Property: string GroupingSeparator { get; set; }
Selector: zeroSymbol
Property: string ZeroSymbol { get; set; }
Selector: textAttributesForZero
Property: NSDictionary TextAttributesForZero { get; set; }
Selector: nilSymbol
Property: string NilSymbol { get; set; }
Selector: textAttributesForNil
Property: NSDictionary TextAttributesForNil { get; set; }
Selector: notANumberSymbol
Property: string NotANumberSymbol { get; set; }
Selector: textAttributesForNotANumber
Property: NSDictionary TextAttributesForNotANumber { get; set; }
Selector: positiveInfinitySymbol
Property: string PositiveInfinitySymbol { get; set; }
Selector: textAttributesForPositiveInfinity
Property: NSDictionary TextAttributesForPositiveInfinity { get; set; }
Selector: negativeInfinitySymbol
Property: string NegativeInfinitySymbol { get; set; }
Selector: textAttributesForNegativeInfinity
Property: NSDictionary TextAttributesForNegativeInfinity { get; set; }
Selector: positivePrefix
Property: string PositivePrefix { get; set; }
Selector: positiveSuffix
Property: string PositiveSuffix { get; set; }
Selector: negativePrefix
Property: string NegativePrefix { get; set; }
Selector: negativeSuffix
Property: string NegativeSuffix { get; set; }
Selector: currencyCode
Property: string CurrencyCode { get; set; }
Selector: currencySymbol
Property: string CurrencySymbol { get; set; }
Selector: internationalCurrencySymbol
Property: string InternationalCurrencySymbol { get; set; }
Selector: percentSymbol
Property: string PercentSymbol { get; set; }
Selector: perMillSymbol
Property: string PerMillSymbol { get; set; }
Selector: minusSign
Property: string MinusSign { get; set; }
Selector: plusSign
Property: string PlusSign { get; set; }
Selector: exponentSymbol
Property: string ExponentSymbol { get; set; }
Selector: groupingSize
Property: uint GroupingSize { get; set; }
Selector: secondaryGroupingSize
Property: uint SecondaryGroupingSize { get; set; }
Selector: multiplier
Property: NSNumber Multiplier { get; set; }
Selector: formatWidth
Property: uint FormatWidth { get; set; }
Selector: paddingCharacter
Property: string PaddingCharacter { get; set; }
Selector: paddingPosition
Property: NSNumberFormatterPadPosition PaddingPosition { get; set; }
Selector: roundingMode
Property: NSNumberFormatterRoundingMode RoundingMode { get; set; }
Selector: roundingIncrement
Property: NSNumber RoundingIncrement { get; set; }
Selector: minimumIntegerDigits
Property: int MinimumIntegerDigits { get; set; }
Selector: maximumIntegerDigits
Property: int MaximumIntegerDigits { get; set; }
Selector: minimumFractionDigits
Property: int MinimumFractionDigits { get; set; }
Selector: maximumFractionDigits
Property: int MaximumFractionDigits { get; set; }
Selector: minimum
Property: NSNumber Minimum { get; set; }
Selector: maximum
Property: NSNumber Maximum { get; set; }
Selector: currencyGroupingSeparator
Property: string CurrencyGroupingSeparator { get; set; }
Selector: lenient
Property: bool Lenient { [Bind ("isLenient")]get; set; }
Selector: usesSignificantDigits
Property: bool UsesSignificantDigits { get; set; }
Selector: minimumSignificantDigits
Property: uint MinimumSignificantDigits { get; set; }
Selector: maximumSignificantDigits
Property: uint MaximumSignificantDigits { get; set; }
Selector: partialStringValidationEnabled
Property: bool PartialStringValidationEnabled { [Bind ("isPartialStringValidationEnabled")]get; set; }

Class NSDecimalNumber

Selector: initWithMantissa:exponent:isNegative:
Method: IntPtr Constructor (long mantissa, short exponent, bool isNegative);
Selector: initWithDecimal:
Method: IntPtr Constructor (NSDecimal dec);
Selector: initWithString:
Method: IntPtr Constructor (string numberValue);
Selector: initWithString:locale:
Method: IntPtr Constructor (string numberValue, NSObject locale);
Selector: descriptionWithLocale:
Method: string DescriptionWithLocale (NSLocale locale);
Selector: decimalValue
Property: NSDecimal NSDecimalValue { get; }
Selector: zero
Property: NSDecimalNumber Zero { get; }
Selector: one
Property: NSDecimalNumber One { get; }
Selector: minimumDecimalNumber
Property: NSDecimalNumber MinValue { get; }
Selector: maximumDecimalNumber
Property: NSDecimalNumber MaxValue { get; }
Selector: notANumber
Property: NSDecimalNumber NaN { get; }
Selector: decimalNumberByAdding:
Method: NSDecimalNumber Add (NSDecimalNumber d);
Selector: decimalNumberByAdding:withBehavior:
Method: NSDecimalNumber Add (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberBySubtracting:
Method: NSDecimalNumber Subtract (NSDecimalNumber d);
Selector: decimalNumberBySubtracting:withBehavior:
Method: NSDecimalNumber Subtract (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberByMultiplyingBy:
Method: NSDecimalNumber Multiply (NSDecimalNumber d);
Selector: decimalNumberByMultiplyingBy:withBehavior:
Method: NSDecimalNumber Multiply (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberByDividingBy:
Method: NSDecimalNumber Divide (NSDecimalNumber d);
Selector: decimalNumberByDividingBy:withBehavior:
Method: NSDecimalNumber Divide (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberByRaisingToPower:
Method: NSDecimalNumber RaiseTo (NSDecimalNumber d);
Selector: decimalNumberByRaisingToPower:withBehavior:
Method: NSDecimalNumber RaiseTo (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberByMultiplyingByPowerOf10:
Method: NSDecimalNumber MultiplyPowerOf10 (NSDecimalNumber d);
Selector: decimalNumberByMultiplyingByPowerOf10:withBehavior:
Method: NSDecimalNumber MultiplyPowerOf10 (NSDecimalNumber d, NSObject Behavior);
Selector: decimalNumberByRoundingAccordingToBehavior:
Method: NSDecimalNumber Rounding (NSObject behavior);
Selector: compare:
Method: int Compare (NSNumber other);
Selector: defaultBehavior
Property: NSObject DefaultBehavior { get; set; }
Selector: doubleValue
Property: double DoubleValue { get; }

Class NSThread

Selector: currentThread
Property: NSThread Current { get; }
Selector: isMultiThreaded
Property: bool IsMultiThreaded { get; }
Selector: sleepUntilDate:
Method: void SleepUntil (NSDate date);
Selector: sleepForTimeInterval:
Method: void SleepFor (double timeInterval);
Selector: exit
Method: void Exit ();
Selector: threadPriority
Property: double Priority { get; set; }
Selector: name
Property: string Name { get; set; }
Selector: stackSize
Property: uint StackSize { get; set; }
Selector: isMainThread
Property: bool IsMainThread { get; }
Selector: mainThread
Property: NSThread MainThread { get; }
Selector: initWithTarget:selector:object:
Method: IntPtr Constructor (NSObject target, Selector selector, NSObject argument);
Selector: isExecuting
Property: bool IsExecuting { get; }
Selector: isFinished
Property: bool IsFinished { get; }
Selector: isCancelled
Property: bool IsCancelled { get; }
Selector: cancel
Method: void Cancel ();
Selector: start
Method: void Start ();
Selector: main
Method: void Main ();

Class NSProcessInfo

Selector: processInfo
Property: NSProcessInfo ProcessInfo { get; }
Selector: arguments
Property: string [] Arguments { get; }
Selector: environment
Property: NSDictionary Environment { get; }
Selector: processIdentifier
Property: int ProcessIdentifier { get; }
Selector: globallyUniqueString
Property: string GloballyUniqueString { get; }
Selector: processName
Property: string ProcessName { get; set; }
Selector: hostName
Property: string HostName { get; }
Selector: operatingSystem
Property: int OperatingSystem { get; }
Selector: operatingSystemName
Property: string OperatingSystemName { get; }
Selector: operatingSystemVersionString
Property: string OperatingSystemVersionString { get; }
Selector: physicalMemory
Property: long PhysicalMemory { get; }
Selector: processorCount
Property: int ProcessorCount { get; }
Selector: activeProcessorCount
Property: int ActiveProcessorCount { get; }

Class NSPurgeableData

Class NSFileCoordinator

Selector: addFilePresenter:")][PostGet ("FilePresenters
Method: void AddFilePresenter (NSFilePresenter filePresenter);
Selector: removeFilePresenter:")][PostGet ("FilePresenters
Method: void RemoveFilePresenter (NSFilePresenter filePresenter);
Selector: filePresenters
Property: NSFilePresenter [] FilePresenters { get; }
Selector: initWithFilePresenter:
Method: IntPtr Constructor ([NullAllowed] NSFilePresenter filePresenterOrNil);
Selector: coordinateReadingItemAtURL:options:error:byAccessor:
Method: void CoordinateRead (NSUrl itemUrl, NSFileCoordinatorReadingOptions options, out NSError error, NSFileCoordinatorWorker worker);
Selector: coordinateWritingItemAtURL:options:error:byAccessor:
Method: void CoordinateWrite (NSUrl url, NSFileCoordinatorWritingOptions options, out NSError error, NSFileCoordinatorWorker worker);
Selector: coordinateReadingItemAtURL:options:writingItemAtURL:options:error:byAccessor:
Method: void CoordinateReadWrite (NSUrl readingURL, NSFileCoordinatorReadingOptions readingOptions, NSUrl writingURL, NSFileCoordinatorWritingOptions writingOptions, out NSError error, NSFileCoordinatorWorkerRW readWriteWorker);
Selector: prepareForReadingItemsAtURLs:options:writingItemsAtURLs:options:error:byAccessor:
Method: void CoordinateBatc (NSUrl [] readingURLs, NSFileCoordinatorReadingOptions readingOptions, NSUrl [] writingURLs, NSFileCoordinatorWritingOptions writingOptions, NSError error, NSAction batchHandler);
Selector: itemAtURL:didMoveToURL:
Method: void ItemMoved (NSUrl fromUrl, NSUrl toUrl);
Selector: cancel
Method: void Cancel ();

Class NSFileManager

Selector: defaultManager
Property: NSFileManager DefaultManager { get; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: setAttributes:ofItemAtPath:error:
Method: bool SetAttributes (NSDictionary attributes, string path, out NSError error);
Selector: createDirectoryAtPath:withIntermediateDirectories:attributes:error:
Method: bool CreateDirectory (string path, bool createIntermediates, NSDictionary attributes, out NSError error);
Selector: contentsOfDirectoryAtPath:error:
Method: string[] GetDirectoryContent (string path, out NSError error);
Selector: subpathsOfDirectoryAtPath:error:
Method: string[] GetDirectoryContentRecursive (string path, out NSError error);
Selector: attributesOfItemAtPath:error:
Method: NSDictionary _GetAttributes (string path, out NSError error);
Selector: attributesOfFileSystemForPath:error:
Method: NSDictionary _GetFileSystemAttributes (String path, out NSError error);
Selector: createSymbolicLinkAtPath:withDestinationPath:error:
Method: bool CreateSymbolicLink (string path, string destPath, out NSError error);
Selector: destinationOfSymbolicLinkAtPath:error:
Method: string GetSymbolicLinkDestination (string path, out NSError error);
Selector: copyItemAtPath:toPath:error:
Method: bool Copy (string srcPath, string dstPath, out NSError error);
Selector: moveItemAtPath:toPath:error:
Method: bool Move (string srcPath, string dstPath, out NSError error);
Selector: linkItemAtPath:toPath:error:
Method: bool Link (string srcPath, string dstPath, out NSError error);
Selector: removeItemAtPath:error:
Method: bool Remove (string path, out NSError error);
Selector: linkPath:toPath:handler:
Method: bool LinkPath (string src, string dest, IntPtr handler);
Selector: copyPath:toPath:handler:
Method: bool CopyPath (string src, string dest, IntPtr handler);
Selector: movePath:toPath:handler:
Method: bool MovePath (string src, string dest, IntPtr handler);
Selector: removeFileAtPath:handler:
Method: bool RemoveFileAtPath (string path, IntPtr handler);
Selector: currentDirectoryPath
Property: string CurrentDirectory { get; [Bind ("changeCurrentDirectoryPath:")] set; }
Selector: fileExistsAtPath:
Method: bool FileExists (string path);
Selector: fileExistsAtPath:isDirectory:
Method: bool FileExists (string path, bool isDirectory);
Selector: isReadableFileAtPath:
Method: bool IsReadableFile (string path);
Selector: isWritableFileAtPath:
Method: bool IsWritableFile (string path);
Selector: isExecutableFileAtPath:
Method: bool IsExecutableFile (string path);
Selector: isDeletableFileAtPath:
Method: bool IsDeletableFile (string path);
Selector: contentsEqualAtPath:andPath:
Method: bool ContentsEqual (string path1, string path2);
Selector: displayNameAtPath:
Method: string DisplayName (string path);
Selector: componentsToDisplayForPath:
Method: string[] ComponentsToDisplay (string path);
Selector: enumeratorAtPath:
Method: NSDirectoryEnumerator GetEnumerator (string path);
Selector: subpathsAtPath:
Method: string[] Subpaths (string path);
Selector: contentsAtPath:
Method: NSData Contents (string path);
Selector: createFileAtPath:contents:attributes:
Method: bool CreateFile (string path, NSData data, NSDictionary attr);
Selector: contentsOfDirectoryAtURL:includingPropertiesForKeys:options:error:
Method: NSUrl[] GetDirectoryContent (NSUrl url, NSArray properties, NSDirectoryEnumerationOptions options, out NSError error);
Selector: copyItemAtURL:toURL:error:
Method: bool Copy (NSUrl srcUrl, NSUrl dstUrl, out NSError error);
Selector: moveItemAtURL:toURL:error:
Method: bool Move (NSUrl srcUrl, NSUrl dstUrl, out NSError error);
Selector: linkItemAtURL:toURL:error:
Method: bool Link (NSUrl srcUrl, NSUrl dstUrl, out NSError error);
Selector: removeItemAtURL:error:
Method: bool Remove (NSUrl url, out NSError error);
Selector: enumeratorAtURL:includingPropertiesForKeys:options:errorHandler:
Method: NSDirectoryEnumerator GetEnumerator (NSUrl url, NSArray properties, NSDirectoryEnumerationOptions options, out NSError error);
Selector: URLForDirectory:inDomain:appropriateForURL:create:error:
Method: NSUrl GetUrl (NSSearchPathDirectory directory, NSSearchPathDomain domain, NSUrl url, bool shouldCreate, out NSError error);
Selector: URLsForDirectory:inDomains:
Method: NSUrl[] GetUrls (NSSearchPathDirectory directory, NSSearchPathDomain domains);
Selector: replaceItemAtURL:withItemAtURL:backupItemName:options:resultingItemURL:error:
Method: bool Replace (NSUrl originalItem, NSUrl newItem, string backupItemName, NSFileManagerItemReplacementOptions options, out NSUrl resultingURL, out NSError error);
Selector: mountedVolumeURLsIncludingResourceValuesForKeys:options:
Method: NSUrl[] GetMountedVolumes(NSArray properties, NSVolumeEnumerationOptions options);
Selector: fileSystemRepresentationWithPath:
Method: //const char FileSystemRepresentationWithPath (string path);
Selector: stringWithFileSystemRepresentation:length:
Method: //string StringWithFileSystemRepresentation (const char str, uint len);
Selector: createDirectoryAtURL:withIntermediateDirectories:attributes:error:
Method: bool CreateDirectory (NSUrl url, bool createIntermediates, NSDictionary attributes, out NSError error);
Selector: createSymbolicLinkAtURL:withDestinationURL:error:
Method: bool CreateSymbolicLink (NSUrl url, NSUrl destURL, out NSError error);
Selector: setUbiquitous:itemAtURL:destinationURL:error:
Method: bool SetUbiquitous (bool flag, NSUrl url, NSUrl destinationUrl, out NSError error);
Selector: isUbiquitousItemAtURL:
Method: bool IsUbiquitous (NSUrl url);
Selector: startDownloadingUbiquitousItemAtURL:error:
Method: bool StartDownloadingUbiquitous (NSUrl url, out NSError error);
Selector: evictUbiquitousItemAtURL:error:
Method: bool EvictUbiquitous (NSUrl url, out NSError error);
Selector: URLForUbiquityContainerIdentifier:
Method: NSUrl GetUrlForUbiquityContainer (string containerIdentifier);
Selector: URLForPublishingUbiquitousItemAtURL:expirationDate:error:
Method: NSUrl GetUrlForPublishingUbiquitousItem (NSUrl url, out NSDate expirationDate, out NSError error);

Class NSFileManagerDelegate

Selector: fileManager:shouldCopyItemAtPath:toPath:
Method: bool ShouldCopyItemAtPath(NSFileManager fm, NSString srcPath, NSString dstPath);
Selector: fileManager:shouldCopyItemAtURL:toURL:
Method: bool ShouldCopyItemAtUrl(NSFileManager fm, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldLinkItemAtURL:toURL:
Method: bool ShouldLinkItemAtUrl (NSFileManager fileManager, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldMoveItemAtURL:toURL:
Method: bool ShouldMoveItemAtUrl (NSFileManager fileManager, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldProceedAfterError:copyingItemAtURL:toURL:
Method: bool ShouldProceedAfterErrorCopyingItem (NSFileManager fileManager, NSError error, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldProceedAfterError:linkingItemAtURL:toURL:
Method: bool ShouldProceedAfterErrorLinkingItem (NSFileManager fileManager, NSError error, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldProceedAfterError:movingItemAtURL:toURL:
Method: bool ShouldProceedAfterErrorMovingItem (NSFileManager fileManager, NSError error, NSUrl srcUrl, NSUrl dstUrl);
Selector: fileManager:shouldRemoveItemAtURL:
Method: bool ShouldRemoveItemAtUrl (NSFileManager fileManager, NSUrl url);
Selector: fileManager:shouldProceedAfterError:removingItemAtURL:
Method: bool ShouldProceedAfterErrorRemovingItem (NSFileManager fileManager, NSError error, NSUrl url);
Selector: fileManager:shouldProceedAfterError:
Method: bool ShouldProceedAfterError (NSFileManager fm, NSDictionary errorInfo);
Selector: fileManager:willProcessPath:
Method: //void WillProcessPath (NSFileManager fm, string path);
Selector: fileManager:shouldCopyItemAtPath:toPath:
Method: bool ShouldCopyItemAtPath (NSFileManager fileManager, string srcPath, string dstPath);
Selector: fileManager:shouldProceedAfterError:copyingItemAtPath:toPath:
Method: bool ShouldProceedAfterErrorCopyingItem (NSFileManager fileManager, NSError error, string srcPath, string dstPath);
Selector: fileManager:shouldMoveItemAtPath:toPath:
Method: bool ShouldMoveItemAtPath (NSFileManager fileManager, string srcPath, string dstPath);
Selector: fileManager:shouldProceedAfterError:movingItemAtPath:toPath:
Method: bool ShouldProceedAfterErrorMovingItem (NSFileManager fileManager, NSError error, string srcPath, string dstPath);
Selector: fileManager:shouldLinkItemAtPath:toPath:
Method: bool ShouldLinkItemAtPath (NSFileManager fileManager, string srcPath, string dstPath);
Selector: fileManager:shouldProceedAfterError:linkingItemAtPath:toPath:
Method: bool ShouldProceedAfterErrorLinkingItem (NSFileManager fileManager, NSError error, string srcPath, string dstPath);
Selector: fileManager:shouldRemoveItemAtPath:
Method: bool ShouldRemoveItemAtPath (NSFileManager fileManager, string path);
Selector: fileManager:shouldProceedAfterError:removingItemAtPath:
Method: bool ShouldProceedAfterErrorRemovingItem (NSFileManager fileManager, NSError error, string path);

Class NSFilePresenter

Selector: NSURL*presentedItemURL
Property: NSUrl PresentedItemURL { get; }
Selector: NSOperationQueue*presentedItemOperationQueue
Property: NSOperationQueue PesentedItemOperationQueue { get; }
Selector: relinquishPresentedItemToReader:
Method: void RelinquishPresentedItem (NSAction readerAction);
Selector: relinquishPresentedItemToWriter:
Method: void RelinquishPresentedItem (NSAction writerAction);
Selector: savePresentedItemChangesWithCompletionHandler:
Method: void SavePresentedItemChanges (...);
Selector: accommodatePresentedItemDeletionWithCompletionHandler:
Method: void AccommodatePresentedItem (..);
Selector: presentedItemDidMoveToURL:
Method: void PresentedItemMoved (NSUrl newURL);
Selector: presentedItemDidChange
Method: void PresentedItemChanged ();
Selector: presentedItemDidGainVersion:
Method: void PresentedItemGainedVersion (NSFileVersion version);
Selector: presentedItemDidLoseVersion:
Method: void PresentedItemLostVersion (NSFileVersion version);
Selector: presentedItemDidResolveConflictVersion:
Method: void PresentedItemResolveConflictVersion (NSFileVersion version);
Selector: accommodatePresentedSubitemDeletionAtURL:completionHandler:NSError*errorOrNil))completionHandler
Method: void AccommodatePresentedSubitemDeletion (NSUrl url,
Selector: presentedSubitemDidAppearAtURL:
Method: void PresentedSubitemAppeared (NSUrl atUrl);
Selector: presentedSubitemAtURL:didMoveToURL:
Method: void PresentedSubitemMoved (NSUrl oldURL, NSUrl newURL);
Selector: presentedSubitemDidChangeAtURL:
Method: void PresentedSubitemChanged (NSUrl url);
Selector: presentedSubitemAtURL:didGainVersion:
Method: void PresentedSubitemGainedVersion (NSUrl url, NSFileVersion version);
Selector: presentedSubitemAtURL:didLoseVersion:
Method: void PresentedSubitemLostVersion (NSUrl url, NSFileVersion version);
Selector: presentedSubitemAtURL:didResolveConflictVersion:
Method: void PresentedSubitemResolvedConflictVersion (NSUrl url, NSFileVersion version);

Class NSFileVersion

Selector: URL
Property: NSUrl Url { get; }
Selector: localizedName
Property: string LocalizedName { get; }
Selector: localizedNameOfSavingComputer
Property: string LocalizedNameOfSavingComputer { get; }
Selector: modificationDate
Property: NSDate ModificationDate { get; }
Selector: persistentIdentifier
Property: NSObject PersistentIdentifier { get; }
Selector: conflict
Property: bool IsConflict { [Bind ("isConflict")] get; }
Selector: resolved
Property: bool Resolved { [Bind ("isResolved")] get; set; }
Selector: discardable
Property: bool Discardable { [Bind ("isDiscardable")] get; set; }
Selector: currentVersionOfItemAtURL:
Method: NSFileVersion GetCurrentVersion (NSUrl url);
Selector: otherVersionsOfItemAtURL:
Method: NSFileVersion [] GetOtherVersions (NSUrl url);
Selector: unresolvedConflictVersionsOfItemAtURL:
Method: NSFileVersion [] GetUnresolvedConflictVersions (NSUrl url);
Selector: versionOfItemAtURL:forPersistentIdentifier:
Method: NSFileVersion GetSpecificVersion (NSUrl url, NSObject persistentIdentifier);
Selector: addVersionOfItemAtURL:withContentsOfURL:options:error:
Method: NSFileVersion AddVersion (NSUrl url, NSUrl contentsURL, NSFileVersionAddingOptions options, out NSError outError);
Selector: temporaryDirectoryURLForNewVersionOfItemAtURL:
Method: NSUrl TemporaryDirectoryForItem (NSUrl url);
Selector: replaceItemAtURL:options:error:
Method: NSUrl ReplaceItem (NSUrl url, NSFileVersionReplacingOptions options, out NSError error);
Selector: removeAndReturnError:
Method: bool Remove (out NSError outError);
Selector: removeOtherVersionsOfItemAtURL:error:
Method: bool RemoveOtherVersions (NSUrl url, out NSError outError);

Class NSFileWrapper

Selector: initWithURL:options:error:
Method: IntPtr Constructor (NSUrl url, NSFileWrapperReadingOptions options, out NSError outError);
Selector: initDirectoryWithFileWrappers:
Method: IntPtr Constructor (NSDictionary childrenByPreferredName);
Selector: initRegularFileWithContents:
Method: IntPtr Constructor (NSData contents);
Selector: initSymbolicLinkWithDestinationURL:
Method: IntPtr Constructor (NSUrl urlToSymbolicLink);
Selector: initWithSerializedRepresentation:
Method: //IntPtr Constructor (NSData serializeRepresentation);
Selector: isDirectory
Property: bool IsDirectory { get; }
Selector: isRegularFile
Property: bool IsRegularFile { get; }
Selector: isSymbolicLink
Property: bool IsSymbolicLink { get; }
Selector: matchesContentsOfURL:
Method: bool MatchesContentsOfURL (NSUrl url);
Selector: readFromURL:options:error:
Method: bool Read (NSUrl url, NSFileWrapperReadingOptions options, out NSError outError);
Selector: writeToURL:options:originalContentsURL:error:
Method: bool Write (NSUrl url, NSFileWrapperWritingOptions options, NSUrl originalContentsURL, out NSError outError);
Selector: serializedRepresentation
Method: NSData GetSerializedRepresentation ();
Selector: addFileWrapper:
Method: string AddFileWrapper (NSFileWrapper child);
Selector: addRegularFileWithContents:preferredFilename:
Method: string AddRegularFile (NSData dataContents, string preferredFilename);
Selector: removeFileWrapper:
Method: void RemoveFileWrapper (NSFileWrapper child);
Selector: fileWrappers
Property: NSDictionary FileWrappers { get; }
Selector: keyForFileWrapper:
Method: string KeyForFileWrapper (NSFileWrapper child);
Selector: regularFileContents
Method: NSData GetRegularFileContents ();
Selector: symbolicLinkDestinationURL
Property: NSUrl SymbolicLinkDestinationURL { get; }
Selector: preferredFilename
Property: string PreferredFilename { get; set; }
Selector: filename
Property: string Filename { get; set; }
Selector: fileAttributes
Property: NSDictionary FileAttributes { get; set; }

Class NSDirectoryEnumerator

Selector: fileAttributes
Property: NSDictionary FileAttributes { get; }
Selector: directoryAttributes
Property: NSDictionary DirectoryAttributes { get; }
Selector: skipDescendents
Method: void SkipDescendents ();
Selector: level
Property: int Level { get; }
Selector: fileSize
Method: //unsigned long long FileSize ([Target] NSDictionary fileAttributes);
Selector: fileModificationDate
Method: NSDate FileModificationDate ([Target] NSDictionary fileAttributes);
Selector: fileType
Method: string FileType ([Target] NSDictionary fileAttributes);
Selector: filePosixPermissions
Method: uint FilePosixPermissions ([Target] NSDictionary fileAttributes);
Selector: fileOwnerAccountName
Method: string FileOwnerAccountName ([Target] NSDictionary fileAttributes);
Selector: fileGroupOwnerAccountName
Method: string FileGroupOwnerAccountName ([Target] NSDictionary fileAttributes);
Selector: fileSystemNumber
Method: int FileSystemNumber ([Target] NSDictionary fileAttributes);
Selector: fileSystemFileNumber
Method: uint FileSystemFileNumber ([Target] NSDictionary fileAttributes);
Selector: fileExtensionHidden
Method: bool FileExtensionHidden ([Target] NSDictionary fileAttributes);
Selector: fileHFSCreatorCode
Method: uint FileHfsCreatorCode ([Target] NSDictionary fileAttributes);
Selector: fileHFSTypeCode
Method: uint FileHfsTypeCode ([Target] NSDictionary fileAttributes);
Selector: fileIsImmutable
Method: bool FileIsImmutable ([Target] NSDictionary fileAttributes);
Selector: fileIsAppendOnly
Method: bool FileIsAppendOnly ([Target] NSDictionary fileAttributes);
Selector: fileCreationDate
Method: NSDate FileCreationDate ([Target] NSDictionary fileAttributes);
Selector: fileOwnerAccountID
Method: NSNumber FileOwnerAccountID ([Target] NSDictionary fileAttributes);
Selector: fileGroupOwnerAccountID
Method: NSNumber FileGroupOwnerAccountID ([Target] NSDictionary fileAttributes);

Class NSPredicate

Selector: predicateWithFormat:argumentArray:
Method: NSPredicate FromFormat (string predicateFormat, NSObject[] arguments);
Selector: predicateWithValue:
Method: NSPredicate FromValue (bool value);
Selector: predicateWithBlock:
Method: NSPredicate FromExpression (NSPredicateEvaluator evaluator);
Selector: predicateFormat
Property: string PredicateFormat { get; }
Selector: predicateWithSubstitutionVariables:
Method: NSPredicate PredicateWithSubstitutionVariables (NSDictionary substitutionVariables);
Selector: evaluateWithObject:
Method: bool EvaluateWithObject (NSObject obj);
Selector: evaluateWithObject:substitutionVariables:
Method: bool EvaluateWithObject (NSObject obj, NSDictionary substitutionVariables);

Class NSUrlDownload

Selector: canResumeDownloadDecodedWithEncodingMIMEType:
Method: bool CanResumeDownloadDecodedWithEncodingMimeType (string mimeType);
Selector: initWithRequest:delegate:
Method: IntPtr Constructor (NSUrlRequest request, NSObject delegate1);
Selector: initWithResumeData:delegate:path:
Method: IntPtr Constructor (NSData resumeData, NSObject delegate1, string path);
Selector: cancel
Method: void Cancel ();
Selector: setDestination:allowOverwrite:
Method: void SetDestination (string path, bool allowOverwrite);
Selector: request
Property: NSUrlRequest Request { get; }
Selector: resumeData
Property: NSData ResumeData { get; }
Selector: deletesFileUponFailure
Property: bool DeletesFileUponFailure { get; set; }

Class NSUrlDownloadDelegate

Selector: downloadDidBegin:
Method: void DownloadBegan (NSUrlDownload download);
Selector: download:willSendRequest:redirectResponse:
Method: NSUrlRequest WillSendRequest (NSUrlDownload download, NSUrlRequest request, NSUrlResponse redirectResponse);
Selector: download:didReceiveAuthenticationChallenge:
Method: void ReceivedAuthenticationChallenge (NSUrlDownload download, NSUrlAuthenticationChallenge challenge);
Selector: download:didCancelAuthenticationChallenge:
Method: void CanceledAuthenticationChallenge (NSUrlDownload download, NSUrlAuthenticationChallenge challenge);
Selector: download:didReceiveResponse:
Method: void ReceivedResponse (NSUrlDownload download, NSUrlResponse response);
Selector: download:willResumeWithResponse:fromByte:
Method: void Resume (NSUrlDownload download, NSUrlResponse response, long startingByte);
Selector: download:didReceiveDataOfLength:
Method: void ReceivedData (NSUrlDownload download, uint length);
Selector: download:shouldDecodeSourceDataOfMIMEType:
Method: bool DecodeSourceData (NSUrlDownload download, string encodingType);
Selector: download:decideDestinationWithSuggestedFilename:
Method: void DecideDestination (NSUrlDownload download, string suggestedFilename);
Selector: download:didCreateDestination:
Method: void CreatedDestination (NSUrlDownload download, string path);
Selector: downloadDidFinish:
Method: void Finished (NSUrlDownload download);
Selector: download:didFailWithError:
Method: void FailedWithError(NSUrlDownload download, NSError error);

Class NSUrlProtocolClient

Selector: UrlProtocol:wasRedirectedToRequest:redirectResponse:"), EventArgs ("NSUrlProtocolRedirect
Method: void Redirected (NSUrlProtocol protocol, NSUrlRequest redirectedToEequest, NSUrlResponse redirectResponse);
Selector: UrlProtocol:cachedResponseIsValid:"), EventArgs ("NSUrlProtocolCachedResponse
Method: void CachedResponseIsValid (NSUrlProtocol protocol, NSCachedUrlResponse cachedResponse);
Selector: UrlProtocol:didReceiveResponse:cacheStoragePolicy:"), EventArgs ("NSUrlProtocolResponse
Method: void ReceivedResponse (NSUrlProtocol protocol, NSUrlResponse response, NSUrlCacheStoragePolicy policy);
Selector: UrlProtocol:didLoadData:"), EventArgs ("NSUrlProtocolData
Method: void DataLoaded (NSUrlProtocol protocol, NSData data);
Selector: UrlProtocolDidFinishLoading:
Method: void FinishedLoading (NSUrlProtocol protocol);
Selector: UrlProtocol:didFailWithError:"), EventArgs ("NSUrlProtocolError
Method: void FailedWithError (NSUrlProtocol protocol, NSError error);
Selector: UrlProtocol:didReceiveAuthenticationChallenge:"), EventArgs ("NSUrlProtocolChallenge
Method: void ReceivedAuthenticationChallenge (NSUrlProtocol protocol, NSUrlAuthenticationChallenge challenge);
Selector: UrlProtocol:didCancelAuthenticationChallenge:"), EventArgs ("NSUrlProtocolChallenge
Method: void CancelledAuthenticationChallenge (NSUrlProtocol protocol, NSUrlAuthenticationChallenge challenge);

Class NSUrlProtocol

Selector: initWithRequest:cachedResponse:client:
Method: IntPtr Constructor (NSUrlRequest request, NSCachedUrlResponse cachedResponse, NSUrlProtocolClient client);
Selector: client
Property: NSObject WeakClient { get; set; }
Selector: request
Property: NSUrlRequest Request { get; }
Selector: cachedResponse
Property: NSCachedUrlResponse CachedResponse { get; }
Selector: canInitWithRequest:
Method: bool CanInitWithRequest (NSUrlRequest request);
Selector: canonicalRequestForRequest:
Method: NSUrlRequest GetCanonicalRequest (NSUrlRequest forRequest);
Selector: requestIsCacheEquivalent:toRequest:
Method: bool IsRequestCacheEquivalent (NSUrlRequest first, NSUrlRequest second);
Selector: startLoading
Method: void StartLoading ();
Selector: stopLoading
Method: void StopLoading ();
Selector: propertyForKey:inRequest:
Method: NSObject GetProperty (string key, NSUrlRequest inRequest);
Selector: setProperty:forKey:inRequest:
Method: void SetProperty ([NullAllowed] NSObject value, string key, NSMutableUrlRequest inRequest);
Selector: removePropertyForKey:inRequest:
Method: void RemoveProperty (string propertyKey, NSMutableUrlRequest request);
Selector: registerClass:
Method: bool RegisterClass (Class protocolClass);
Selector: unregisterClass:
Method: void UnregisterClass (Class protocolClass);

Namespace MonoTouch.CoreAnimation

Class CAMediaTiming

Selector: beginTime
Property: double CFTimeInterval { get; set; }
Selector: duration
Property: double Duration { get; set; }
Selector: speed
Property: float Speed { get; set; }
Selector: timeOffset
Property: double TimeOffset { get; set; }
Selector: repeatCount
Property: float RepeatCount { get; set; }
Selector: repeatDuration
Property: double RepeatDuration { get; set; }
Selector: autoreverses
Property: bool AutoReverses { get;set; }
Selector: fillMode
Property: string FillMode { get; set; }

Class CAConstraintLayoutManager

Selector: layoutManager
Property: CAConstraintLayoutManager LayoutManager { get; }

Class CAConstraint

Selector: attribute
Property: CAConstraintAttribute Attribute { get; }
Selector: sourceName
Property: string SourceName { get; }
Selector: sourceAttribute
Property: CAConstraintAttribute SourceAttribute { get; }
Selector: scale
Property: float Scale { get; }
Selector: constraintWithAttribute:relativeTo:attribute:scale:offset:
Method: CAConstraint Create (CAConstraintAttribute attribute, string relativeToSource, CAConstraintAttribute srcAttr, float scale, float offset);
Selector: constraintWithAttribute:relativeTo:attribute:offset:
Method: CAConstraint Create (CAConstraintAttribute attribute, string relativeToSource, CAConstraintAttribute srcAttr, float offset);
Selector: constraintWithAttribute:relativeTo:attribute:
Method: CAConstraint Create (CAConstraintAttribute attribute, string relativeToSource, CAConstraintAttribute srcAttribute);
Selector: initWithAttribute:relativeTo:attribute:scale:offset:
Method: IntPtr Constructor (CAConstraintAttribute attribute, string relativeToSource, CAConstraintAttribute srcAttr, float scale, float offset);

Class CADisplayLink

Selector: displayLinkWithTarget:selector:
Method: CADisplayLink Create (NSObject target, Selector sel);
Selector: addToRunLoop:forMode:
Method: void AddToRunLoop (NSRunLoop runloop, NSString mode);
Selector: removeFromRunLoop:forMode:
Method: void RemoveFromRunLoop (NSRunLoop runloop, NSString mode);
Selector: invalidate
Method: void Invalidate ();
Selector: timestamp
Property: double Timestamp { get; }
Selector: paused
Property: bool Paused { [Bind ("isPaused")] get; set; }
Selector: frameInterval
Property: int FrameInterval { get; set; }

Class CALayer

Selector: layer
Method: CALayer Create ();
Selector: presentationLayer
Property: CALayer PresentationLayer { get; }
Selector: modelLayer
Property: CALayer ModelLayer { get; }
Selector: defaultValueForKey:
Method: NSObject DefaultValue (string key);
Selector: needsDisplayForKey:
Method: bool NeedsDisplayForKey (string key);
Selector: bounds
Property: RectangleF Bounds { get; set; }
Selector: zPosition
Property: float ZPosition { get; set; }
Selector: anchorPoint
Property: PointF AnchorPoint { get; set; }
Selector: anchorPointZ
Property: float AnchorPointZ { get; set; }
Selector: position
Property: PointF Position { get; set; }
Selector: transform
Property: CATransform3D Transform { get; set; }
Selector: affineTransform
Property: CGAffineTransform AffineTransform { get; set; }
Selector: frame
Property: RectangleF Frame { get; set; }
Selector: hidden
Property: bool Hidden { [Bind ("isHidden")] get; set; }
Selector: doubleSided
Property: bool DoubleSided { [Bind ("isDoubleSided")] get; set; }
Selector: geometryFlipped
Property: bool GeometryFlipped { [Bind ("isGeometryFlipped")] get; set; }
Selector: contentsAreFlipped
Property: bool ContentsAreFlipped { get; }
Selector: superlayer
Property: CALayer SuperLayer { get; }
Selector: removeFromSuperlayer
Method: void RemoveFromSuperLayer ();
Selector: sublayers
Property: CALayer [] Sublayers { get; set; }
Selector: addSublayer:")][PostGet ("Sublayers
Method: void AddSublayer (CALayer layer);
Selector: insertSublayer:atIndex:")][PostGet ("Sublayers
Method: void InsertSublayer (CALayer layer, int index);
Selector: insertSublayer:below:")][PostGet ("Sublayers
Method: void InsertSublayerBelow (CALayer layer, CALayer sibling);
Selector: insertSublayer:above:")][PostGet ("Sublayers
Method: void InsertSublayerAbove (CALayer layer, CALayer sibling);
Selector: replaceSublayer:with:")][PostGet ("Sublayers
Method: void ReplaceSublayer (CALayer layer, CALayer with);
Selector: sublayerTransform
Property: CATransform3D SublayerTransform { get; set; }
Selector: mask
Property: CALayer Mask { get; set; }
Selector: masksToBounds
Property: bool MasksToBounds { get; set; }
Selector: convertPoint:fromLayer:
Method: PointF ConvertPointFromLayer (PointF point, CALayer layer);
Selector: convertPoint:toLayer:
Method: PointF ConvertPointToLayer (PointF point, CALayer layer);
Selector: convertRect:fromLayer:
Method: RectangleF ConvertRectfromLayer (RectangleF rect, CALayer layer);
Selector: convertRect:toLayer:
Method: RectangleF ConvertRectToLayer (RectangleF rect, CALayer layer);
Selector: convertTime:fromLayer:
Method: double ConvertTimeFromLayer (double rect, [NullAllowed] CALayer layer);
Selector: convertTime:toLayer:
Method: double ConvertTimeToLayer (double t, CALayer layer);
Selector: hitTest:
Method: CALayer HitTest (PointF p);
Selector: containsPoint:
Method: bool Contains (PointF p);
Selector: contents
Property: CGImage Contents { get; set; }
Selector: layoutManager
Property: NSObject LayoutManager { get; set; }
Selector: contentsScale
Property: float ContentsScale { get; set; }
Selector: contentsRect
Property: RectangleF ContentsRect { get; set; }
Selector: contentsGravity
Property: string ContentsGravity { get; set; }
Selector: contentsCenter
Property: RectangleF ContentsCenter { get; set; }
Selector: minificationFilter
Property: string MinificationFilter { get; set; }
Selector: magnificationFilter
Property: string MagnificationFilter { get; set; }
Selector: opaque
Property: bool Opaque { [Bind ("isOpaque")] get; set; }
Selector: display
Method: void Display ();
Selector: needsDisplay
Property: bool NeedsDisplay { get; }
Selector: setNeedsDisplay
Method: void SetNeedsDisplay ();
Selector: setNeedsDisplayInRect:
Method: void SetNeedsDisplayInRect (RectangleF r);
Selector: displayIfNeeded
Method: void DisplayIfNeeded ();
Selector: needsDisplayOnBoundsChange
Property: bool NeedsDisplayOnBoundsChange { get; set; }
Selector: drawInContext:
Method: void DrawInContext (CGContext ctx);
Selector: renderInContext:
Method: void RenderInContext (CGContext ctx);
Selector: backgroundColor
Property: CGColor BackgroundColor { get; set; }
Selector: cornerRadius
Property: float CornerRadius { get; set; }
Selector: borderWidth
Property: float BorderWidth { get; set; }
Selector: borderColor
Property: CGColor BorderColor { get; set; }
Selector: opacity
Property: float Opacity { get; set; }
Selector: edgeAntialiasingMask
Property: CAEdgeAntialiasingMask EdgeAntialiasingMask { get; set; }
Selector: preferredFrameSize
Method: SizeF PreferredFrameSize ();
Selector: setNeedsLayout
Method: void SetNeedsLayout ();
Selector: needsLayout
Method: bool NeedsLayout ();
Selector: layoutIfNeeded
Method: void LayoutIfNeeded ();
Selector: layoutSublayers
Method: void LayoutSublayers ();
Selector: defaultActionForKey:
Method: CAAction DefaultActionForKey (string eventKey);
Selector: actionForKey:
Method: CAAction ActionForKey (string eventKey);
Selector: actions
Property: CAAction [] Actions { get; set; }
Selector: addAnimation:forKey:
Method: void AddAnimation (CAAnimation animation, [NullAllowed] string key);
Selector: removeAllAnimations
Method: void RemoveAllAnimations ();
Selector: removeAnimationForKey:
Method: void RemoveAnimation (string key);
Selector: animationKeys
Property: string [] AnimationKeys { get; }
Selector: animationForKey:
Method: CAAnimation AnimationForKey (string key);
Selector: name
Property: string Name { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: beginTime
Property: double BeginTime { get; set; }
Selector: duration
Property: double Duration { get; set; }
Selector: speed
Property: float Speed { get; set; }
Selector: timeOffset
Property: double TimeOffset { get; set; }
Selector: repeatCount
Property: float RepeatCount { get; set; }
Selector: repeatDuration
Property: double RepeatDuration { get; set; }
Selector: autoreverses
Property: bool AutoReverses { get;set; }
Selector: fillMode
Property: string FillMode { get; set; }
Selector: shadowColor
Property: CGColor ShadowColor { get; set; }
Selector: shadowOffset
Property: SizeF ShadowOffset { get; set; }
Selector: shadowOpacity
Property: float ShadowOpacity { get; set; }
Selector: shadowRadius
Property: float ShadowRadius { get; set; }
Selector: visibleRect
Property: RectangleF VisibleRect { get; }
Selector: scrollPoint:
Method: void ScrollPoint (PointF p);
Selector: scrollRectToVisible:
Method: void ScrollRectToVisible (RectangleF r);
Selector: autoresizingMask
Property: CAAutoresizingMask AutoresizinMask { get; set; }
Selector: resizeSublayersWithOldSize
Method: void ResizeSublayers (SizeF oldSize);
Selector: resizeWithOldSuperlayerSize:
Method: void Resize (SizeF oldSuperlayerSize);
Selector: constraints
Property: CAConstraint[] Constraints { get; set; }
Selector: addConstraint:
Method: void AddConstraint (CAConstraint c);
Selector: filter
Property: CIFilter [] Filters { get; set; }
Selector: shouldRasterize
Property: bool ShouldRasterize { get; set; }
Selector: shadowPath
Property: CGPath ShadowPath { get; set; }
Selector: rasterizationScale
Property: float RasterizationScale { get; set; }

Class CATiledLayer

Selector: layer
Method: CALayer Create ();
Selector: fadeDuration
Property: double FadeDuration { get; }
Selector: levelsOfDetail
Property: int LevelsOfDetail { get; set; }
Selector: levelsOfDetailBias
Property: int LevelsOfDetailBias { get; set; }
Selector: tileSize
Property: SizeF TileSize { get; set; }

Class CAReplicatorLayer

Selector: layer
Method: CALayer Create ();
Selector: instanceCount
Property: int InstanceCount { get; set; }
Selector: instanceDelay
Property: double InstanceDelay { get; set; }
Selector: instanceTransform
Property: CATransform3D InstanceTransform { get; set; }
Selector: preservesDepth
Property: bool PreservesDepth { get; set; }
Selector: instanceColor
Property: CGColor InstanceColor { get; set; }
Selector: instanceRedOffset
Property: float InstanceRedOffset { get; set; }
Selector: instanceGreenOffset
Property: float InstanceGreenOffset { get; set; }
Selector: instanceBlueOffset
Property: float InstanceBlueOffset { get; set; }
Selector: instanceAlphaOffset
Property: float InstanceAlphaOffset { get; set; }

Class CAScrollLayer

Selector: layer
Method: CALayer Create ();
Selector: scrollMode
Property: NSString ScrollMode { get; set; }
Selector: scrollToPoint:
Method: void ScrollToPoint (PointF p);
Selector: scrollToRect:
Method: void ScrollToRect (RectangleF r);

Class CAShapeLayer

Selector: layer
Method: CALayer Create ();
Selector: path
Property: CGPath Path { get; set; }
Selector: fillColor
Property: CGColor FillColor { get; set; }
Selector: fillRule
Property: NSString FillRule { get; set; }
Selector: lineCap
Property: NSString LineCap { get; set; }
Selector: lineDashPattern
Property: NSNumber [] LineDashPattern { get; set; }
Selector: lineDashPhase
Property: float LineDashPhase { get; set; }
Selector: lineJoin
Property: NSString LineJoin { get; set; }
Selector: lineWidth
Property: float LineWidth { get; set; }
Selector: miterLimit
Property: float MiterLimit { get; set; }
Selector: strokeColor
Property: CGColor StrokeColor { get; set; }
Selector: strokeStart
Property: float StrokeStart { get; set; }
Selector: strokeEnd
Property: float StrokeEnd { get; set; }

Class CATransformLayer

Selector: layer
Method: CALayer Create ();
Selector: hitTest:
Method: CALayer HitTest (PointF thePoint);

Class CATextLayer

Selector: layer
Method: CALayer Create ();
Selector: string
Property: string String { get; set; }
Selector: fontSize
Property: float FontSize { get; set; }
Selector: font
Property: IntPtr _Font { get; set; }
Selector: foregroundColor
Property: CGColor ForegroundColor { get; set; }
Selector: wrapped
Property: bool Wrapped { [Bind ("isWrapped")] get; set; }
Selector: truncationMode
Property: string TruncationMode { get; set; }
Selector: alignmentMode
Property: string AlignmentMode { get; set; }

Class CALayerDelegate

Selector: displayLayer:
Method: void DisplayLayer (CALayer layer);
Selector: drawLayer:inContext:"), EventArgs ("CALayerDrawEventArgs
Method: void DrawLayer (CALayer layer, CGContext context);
Selector: layoutSublayersOfLayer:
Method: void LayoutSublayersOfLayer (CALayer layer);
Selector: actionForLayer:forKey:"), EventArgs ("CALayerDelegateAction
Method: CAAction ActionForLAyer (CALayer layer, string eventKey);

Class CAEAGLLayer

Selector: layer
Method: CALayer Create ();
Selector: drawableProperties
Property: NSDictionary DrawableProperties { get; set; }

Class CAAction

Selector: runActionForKey:object:arguments:
Method: void RunAction (string eventKey, NSObject obj, NSDictionary arguments);

Class CAAnimation

Selector: animation
Method: CAAnimation CreateAnimation ();
Selector: defaultValueForKey:
Method: NSObject DefaultValue (string key);
Selector: timingFunction
Property: CAMediaTimingFunction TimingFunction { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: removedOnCompletion
Property: bool RemovedOnCompletion { [Bind ("isRemovedOnCompletion")] get; set; }
Selector: willChangeValueForKey:
Method: void WillChangeValueForKey (string key);
Selector: didChangeValueForKey:
Method: void DidChangeValueForKey (string key);
Selector: shouldArchiveValueForKey:
Method: [Since (4,0)]
Selector: beginTime
Property: double BeginTime { get; set; }
Selector: duration
Property: double Duration { get; set; }
Selector: speed
Property: float Speed { get; set; }
Selector: timeOffset
Property: double TimeOffset { get; set; }
Selector: repeatCount
Property: float RepeatCount { get; set; }
Selector: repeatDuration
Property: double RepeatDuration { get; set; }
Selector: autoreverses
Property: bool AutoReverses { get;set; }
Selector: fillMode
Property: string FillMode { get; set; }

Class CAAnimationDelegate

Selector: animationDidStart:
Method: void AnimationStarted (CAAnimation anim);
Selector: animationDidStop:finished:"), EventArgs ("CAAnimationState
Method: void AnimationStopped (CAAnimation anim, bool finished);

Class CAPropertyAnimation

Selector: animationWithKeyPath:
Method: CAPropertyAnimation FromKeyPath (string path);
Selector: keyPath
Property: string KeyPath { get; set; }
Selector: additive
Property: bool Additive { [Bind ("isAdditive")] get; set; }
Selector: cumulative
Property: bool Cumulative { [Bind ("isCumulative")] get; set; }
Selector: valueFunction
Property: CAValueFunction ValueFunction { get; set; }

Class CABasicAnimation

Selector: animationWithKeyPath:
Method: CABasicAnimation FromKeyPath (string path);
Selector: fromValue
Property: NSObject From { get; set; }
Selector: toValue
Property: NSObject To { get; set; }
Selector: byValue
Property: NSObject By { get; set; }

Class CAKeyFrameAnimation

Selector: animationWithKeyPath:
Method: CAPropertyAnimation FromKeyPath (string path);
Selector: values
Property: NSObject [] Values { get; set; }
Selector: path
Property: IntPtr _Path { get; set; }
Selector: keyTimes
Property: NSNumber [] KeyTimes { get; set; }
Selector: timingFunctions
Property: CAMediaTimingFunction [] TimingFunctions { get; set; }
Selector: calculationMode
Property: string CalculationMode { get; set; }
Selector: rotationMode
Property: string RotationMode { get; set; }

Class CATransition

Selector: animation
Method: CATransition CreateAnimation ();
Selector: type
Property: string Type { get; set; }
Selector: subtype
Property: string Subtype { get; set; }
Selector: startProgress
Property: float StartProgress { get; set; }
Selector: endProgress
Property: float EndProgress { get; set; }
Selector: filter
Property: NSObject filter { get; set; }

Class CATransaction

Selector: begin
Method: void Begin ();
Selector: commit
Method: void Commit ();
Selector: flush
Method: void Flush ();
Selector: lock
Method: void Lock ();
Selector: unlock
Method: void Unlock ();
Selector: animationDuration
Property: double AnimationDuration { get; set; }
Selector: animationTimingFunction
Property: CAMediaTimingFunction AnimationTimingFunction { get; set; }
Selector: disableActions
Property: bool DisableActions { get; set; }
Selector: valueForKey:
Method: NSObject ValueForKey (NSString key);
Selector: setValue:forKey:
Method: void SetValueForKey (NSObject anObject, NSString key);
Selector: completionBlock
Property: NSAction CompletionBlock { get; set; }

Class CAAnimationGroup

Selector: animations
Property: CAAnimation [] Animations { get; set; }
Selector: animation
Method: CAAnimationGroup CreateAnimation ();

Class CAGradientLayer

Selector: layer
Method: CALayer Create ();
Selector: colors
Property: IntPtr _Colors { get; set; }
Selector: locations
Property: NSNumber [] Locations { get; set; }
Selector: startPoint
Property: PointF StartPoint { get; set; }
Selector: endPoint
Property: PointF EndPoint { get; set; }
Selector: type
Property: string Type { get; set; }

Class CAMediaTimingFunction

Selector: functionWithName:
Method: CAMediaTimingFunction FromName (string name);
Selector: functionWithControlPoints::::
Method: CAMediaTimingFunction FromControlPoints (float c1x, float c1y, float c2x, float c2y);
Selector: initWithControlPoints::::
Method: IntPtr Constructor (float c1x, float c1y, float c2x, float c2y);
Selector: getControlPointAtIndex:values:
Method: //void getControlPointAtIndex:values: (size_t idx, float[2] ptr);

Class CAValueFunction

Selector: functionWithName:
Method: CAValueFunction FromName (string name);
Selector: name
Property: string Name { get; }

Class CAOpenGLLayer

Selector: layer
Method: CALayer Create ();
Selector: asynchronous
Property: bool Asynchronous { [Bind ("isAsynchronous")]get; set; }
Selector: canDrawInCGLContext:pixelFormat:forLayerTime:displayTime:
Method: bool CanDrawInCGLContext (CGLContext glContext, CGLPixelFormat pixelFormat, double timeInterval, CVTimeStamp timeStamp);
Selector: drawInCGLContext:pixelFormat:forLayerTime:displayTime:
Method: void DrawInCGLContext (CGLContext glContext, CGLPixelFormat pixelFormat, double timeInterval, CVTimeStamp timeStamp);
Selector: copyCGLPixelFormatForDisplayMask:
Method: CGLPixelFormat CopyCGLPixelFormatForDisplayMask (UInt32 mask);
Selector: releaseCGLPixelFormat:
Method: void Release (CGLPixelFormat pixelFormat);
Selector: copyCGLContextForPixelFormat:
Method: CGLContext CopyContext (CGLPixelFormat pixelFormat);
Selector: releaseCGLContext:
Method: void Release (CGLContext glContext);

Class CAEmitterCell

Selector: name
Property: string Name { get; set; }
Selector: enabled
Property: bool Enabled { [Bind ("isEnabled")] get; set; }
Selector: birthRate
Property: float BirthRate { get; set; }
Selector: lifetime
Property: float LifeTime { get; set; }
Selector: lifetimeRange
Property: float LifetimeRange { get; set; }
Selector: emissionLatitude
Property: float EmissionLatitude { get; set; }
Selector: emissionLongitude
Property: float EmissionLongitude { get; set; }
Selector: emissionRange
Property: float EmissionRange { get; set; }
Selector: velocity
Property: float Velocity { get; set; }
Selector: velocityRange
Property: float VelocityRange { get; set; }
Selector: xAcceleration
Property: float AccelerationX { get; set; }
Selector: yAcceleration
Property: float AccelerationY { get; set; }
Selector: zAcceleration
Property: float AccelerationZ { get; set; }
Selector: scale
Property: float Scale { get; set; }
Selector: scaleRange
Property: float ScaleRange { get; set; }
Selector: scaleSpeed
Property: float ScaleSpeed { get; set; }
Selector: spin
Property: float Spin { get; set; }
Selector: spinRange
Property: float SpinRange { get; set; }
Selector: color
Property: CGColor Color { get; set; }
Selector: redSpeed
Property: float RedSpeed { get; set; }
Selector: greenSpeed
Property: float GreenSpeed { get; set; }
Selector: BlueSpeed
Property: float BlueSpeed { get; set; }
Selector: AlphaSpeed
Property: float AlphaSpeed { get; set; }
Selector: contents
Property: NSObject WeakContents { get; set; }
Selector: contents
Property: CGImage Contents { get; set; }
Selector: contentsRect
Property: RectangleF ContentsRect { get; set; }
Selector: minificationFilter
Property: string MinificationFilter { get; set; }
Selector: magnificationFilter
Property: string MagnificationFilter { get; set; }
Selector: minificationFilterBias
Property: float MinificationFilterBias { get; set; }
Selector: emitterCells
Property: CAEmitterCell[] Cells { get; set; }
Selector: style
Property: NSDictionary Style { get; set; }
Selector: emitterCell
Method: CAEmitterCell EmitterCell ();
Selector: defaultValueForKey:
Method: NSObject DefaultValueForKey (string key);
Selector: shouldArchiveValueForKey:
Method: bool ShouldArchiveValueForKey (string key);
Selector: redRange
Property: float RedRange { get; set; }
Selector: greenRange
Property: float GreenRange { get; set; }
Selector: blueRange
Property: float BlueRange { get; set; }
Selector: alphaRange
Property: float AlphaRange { get; set; }

Class CAEmitterLayer

Selector: layer
Method: CALayer Create ();
Selector: emitterCells
Property: CAEmitterCell[] Cells { get; set; }
Selector: birthRate
Property: float BirthRate { get; set; }
Selector: lifetime
Property: float LifeTime { get; set; }
Selector: emitterPosition
Property: PointF Position { get; set; }
Selector: emitterZPosition
Property: float ZPosition { get; set; }
Selector: emitterSize
Property: SizeF Size { get; set; }
Selector: emitterDepth
Property: float Depth { get; set; }
Selector: emitterShape
Property: string Shape { get; set; }
Selector: emitterMode
Property: string Mode { get; set; }
Selector: renderMode
Property: string RenderMode { get; set; }
Selector: preservesDepth
Property: bool PreservesDepth { get; set; }
Selector: velocity
Property: float Velocity { get; set; }
Selector: scale
Property: float Scale { get; set; }
Selector: spin
Property: float Spin { get; set; }
Selector: seed
Property: int Seed { get; set; }

Class NSAtomicStore

Selector: initWithPersistentStoreCoordinator:configurationName:URL:options:
Method: IntPtr Constructor (NSPersistentStoreCoordinator coordinator, string configurationName, NSUrl url, NSDictionary options);
Selector: load:
Method: bool Load (out NSError error);
Selector: save:
Method: bool Save (out NSError error);
Selector: newCacheNodeForManagedObject:
Method: NSAtomicStoreCacheNode NewCacheNodeForManagedObject (NSManagedObject managedObject);
Selector: updateCacheNode:fromManagedObject:
Method: void UpdateCacheNode (NSAtomicStoreCacheNode node, NSManagedObject managedObject);
Selector: cacheNodes
Property: NSSet CacheNodes { get; }
Selector: addCacheNodes:
Method: void AddCacheNodes (NSSet cacheNodes);
Selector: willRemoveCacheNodes:
Method: void WillRemoveCacheNodes (NSSet cacheNodes);
Selector: cacheNodeForObjectID:
Method: NSAtomicStoreCacheNode CacheNodeForObjectID (NSManagedObjectID objectID);
Selector: objectIDForEntity:referenceObject:
Method: NSManagedObjectID ObjectIDForEntity (NSEntityDescription entity, NSObject data);
Selector: newReferenceObjectForManagedObject:
Method: NSAtomicStore NewReferenceObjectForManagedObject (NSManagedObject managedObject);
Selector: referenceObjectForObjectID:
Method: NSAtomicStore ReferenceObjectForObjectID (NSManagedObjectID objectID);

Class NSAtomicStoreCacheNode

Selector: initWithObjectID:
Method: IntPtr Constructor (NSManagedObjectID moid);
Selector: objectID
Property: NSManagedObjectID ObjectID { get; }
Selector: propertyCache
Property: NSDictionary PropertyCache { get; set; }
Selector: valueForKey:
Method: NSAtomicStoreCacheNode ValueForKey (string key);
Selector: setValue:forKey:
Method: void SetValue (NSObject value, string key);

Class NSAttributeDescription

Selector: attributeType
Property: NSAttributeType AttributeType { get; set; }
Selector: attributeValueClassName
Property: string AttributeValueClassName { get; set; }
Selector: defaultValue
Property: NSAttributeDescription DefaultValue { get; }
Selector: setDefaultValue:
Method: void SetDefaultValue (NSObject value);
Selector: versionHash
Property: NSData VersionHash { get; }
Selector: valueTransformerName
Property: string ValueTransformerName { get; set; }
Selector: allowsExternalBinaryDataStorage
Property: bool AllowsExternalBinaryDataStorage { get; set; }

Class NSEntityDescription

Selector: entityForName:inManagedObjectContext:
Method: NSEntityDescription EntityForName (string entityName, NSManagedObjectContext context);
Selector: insertNewObjectForEntityForName:inManagedObjectContext:
Method: NSObject InsertNewObjectForEntityForName (string entityName, NSManagedObjectContext context);
Selector: managedObjectModel
Property: NSManagedObjectModel ManagedObjectModel { get; }
Selector: managedObjectClassName
Property: string ManagedObjectClassName { get; set; }
Selector: name
Property: string Name { get; set; }
Selector: isAbstract
Property: bool Abstract { [Bind("isAbstract")] get; set; }
Selector: subentitiesByName
Property: NSDictionary SubentitiesByName { get; }
Selector: subentities
Property: NSEntityDescription[] Subentities { get; set; }
Selector: superentity
Property: NSEntityDescription Superentity { get; }
Selector: propertiesByName
Property: NSDictionary PropertiesByName { get; }
Selector: properties
Property: NSPropertyDescription[] Properties { get; set; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }
Selector: attributesByName
Property: NSDictionary AttributesByName { get; }
Selector: relationshipsByName
Property: NSDictionary RelationshipsByName { get; }
Selector: relationshipsWithDestinationEntity:
Method: NSRelationshipDescription[] RelationshipsWithDestinationEntity (NSEntityDescription entity);
Selector: isKindOfEntity:
Method: bool IsKindOfEntity (NSEntityDescription entity);
Selector: versionHash
Property: NSData VersionHash { get; }
Selector: versionHashModifier
Property: string VersionHashModifier { get; set; }
Selector: compoundIndexes
Property: NSPropertyDescription [] CompoundIndexes { get; set; }

Class NSEntityMapping

Selector: name
Property: string Name { get; set; }
Selector: mappingType
Property: NSEntityMappingType MappingType { get; set; }
Selector: sourceEntityName
Property: string SourceEntityName { get; set; }
Selector: sourceEntityVersionHash
Property: NSData SourceEntityVersionHash { get; set; }
Selector: destinationEntityName
Property: string DestinationEntityName { get; set; }
Selector: destinationEntityVersionHash
Property: NSData DestinationEntityVersionHash { get; set; }
Selector: attributeMappings
Property: NSPropertyMapping[] AttributeMappings { get; set; }
Selector: relationshipMappings
Property: NSPropertyMapping[] RelationshipMappings { get; set; }
Selector: sourceExpression
Property: NSExpression SourceExpression { get; set; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }
Selector: entityMigrationPolicyClassName
Property: string EntityMigrationPolicyClassName { get; set; }

Class NSEntityMigrationPolicy

Selector: beginEntityMapping:manager:error:
Method: bool BeginEntityMapping (NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: createDestinationInstancesForSourceInstance:entityMapping:manager:error:
Method: bool CreateDestinationInstancesForSourceInstance (NSManagedObject sInstance, NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: endInstanceCreationForEntityMapping:manager:error:
Method: bool EndInstanceCreationForEntityMapping (NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: createRelationshipsForDestinationInstance:entityMapping:manager:error:
Method: bool CreateRelationshipsForDestinationInstance (NSManagedObject dInstance, NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: endRelationshipCreationForEntityMapping:manager:error:
Method: bool EndRelationshipCreationForEntityMapping (NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: performCustomValidationForEntityMapping:manager:error:
Method: bool PerformCustomValidationForEntityMapping (NSEntityMapping mapping, NSMigrationManager manager, out NSError error);
Selector: endEntityMapping:manager:error:
Method: bool EndEntityMapping (NSEntityMapping mapping, NSMigrationManager manager, out NSError error);

Class NSFetchedPropertyDescription

Selector: fetchRequest
Property: NSFetchRequest FetchRequest { get; set; }

Class NSFetchRequest

Selector: entity
Property: NSEntityDescription Entity { get; set; }
Selector: predicate
Property: NSPredicate Predicate { get; set; }
Selector: sortDescriptors
Property: NSSortDescriptor[] SortDescriptors { get; set; }
Selector: fetchLimit
Property: uint FetchLimit { get; set; }
Selector: affectedStores
Property: NSPersistentStore[] AffectedStores { get; set; }
Selector: resultType
Property: NSFetchRequestResultType ResultType { get; set; }
Selector: includesSubentities
Property: bool IncludesSubentities { get; set; }
Selector: includesPropertyValues
Property: bool IncludesPropertyValues { get; set; }
Selector: returnsObjectsAsFaults
Property: bool ReturnsObjectsAsFaults { get; set; }
Selector: relationshipKeyPathsForPrefetching
Property: string[] RelationshipKeyPathsForPrefetching { get; set; }
Selector: fetchRequestWithEntityName:
Method: NSFetchRequest FromEntityName (string entityName);
Selector: initWithEntityName:
Method: IntPtr Constructor (string entityName);
Selector: entityName
Property: string EntityName { get; }
Selector: fetchBatchSize
Property: int FetchBatchSize { get; set; }
Selector: shouldRefreshRefetchedObjects
Property: bool ShouldRefreshRefetchedObjects { get; set; }
Selector: havingPredicate
Property: NSPredicate HavingPredicate { get; set; }
Selector: propertiesToGroupBy
Property: NSPropertyDescription [] PropertiesToGroupBy { get; set; }

Class NSIncrementalStore

Selector: loadMetadata:
Method: bool LoadMetadata (out NSError error);
Selector: executeRequest:withContext:error:
Method: NSObject ExecuteRequest (NSPersistentStoreRequest request, NSManagedObjectContext context, out NSError error);
Selector: newValuesForObjectWithID:withContext:error:
Method: NSIncrementalStoreNode NewValues (NSManagedObjectID forObjectId, NSManagedObjectContext context, out NSError error);
Selector: newValueForRelationship:forObjectWithID:withContext:error:
Method: NSObject NewValue (NSRelationshipDescription forRelationship, NSManagedObjectID forObjectI, NSManagedObjectContext context, out NSError error);
Selector: identifierForNewStoreAtURL:
Method: NSObject IdentifierForNewStoreAtURL (NSUrl storeURL);
Selector: obtainPermanentIDsForObjects:error:
Method: NSObject [] ObtainPermanentIds (NSObject [] array, out NSError error);
Selector: managedObjectContextDidRegisterObjectsWithIDs:
Method: void ManagedObjectContextDidRegisterObjectsWithIds (NSObject [] objectIds);
Selector: managedObjectContextDidUnregisterObjectsWithIDs:
Method: void ManagedObjectContextDidUnregisterObjectsWithIds (NSObject [] objectIds);
Selector: newObjectIDForEntity:referenceObject:
Method: NSManagedObjectID NewObjectIdFor (NSEntityDescription forEntity, NSObject referenceObject);
Selector: referenceObjectForObjectID:
Method: NSObject ReferenceObjectForObject (NSManagedObjectID objectId);

Class NSIncrementalStoreNode

Selector: initWithObjectID:withValues:version:
Method: IntPtr Constructor (NSManagedObjectID objectId, NSDictionary values, ulong version);
Selector: updateWithValues:version:
Method: void Update (NSDictionary values, ulong version);
Selector: objectID
Property: NSManagedObjectID ObjectId { get; }
Selector: version
Property: long Version { get; }
Selector: valueForPropertyDescription:
Method: NSObject ValueForPropertyDescription (NSPropertyDescription prop);

Class NSManagedObject

Selector: initWithEntity:insertIntoManagedObjectContext:
Method: IntPtr Constructor (NSEntityDescription entity, NSManagedObjectContext context);
Selector: managedObjectContext
Property: NSManagedObjectContext ManagedObjectContext { get; }
Selector: entity
Property: NSEntityDescription Entity { get; }
Selector: objectID
Property: NSManagedObjectID ObjectID { get; }
Selector: isInserted
Property: bool IsInserted { get; }
Selector: isUpdated
Property: bool IsUpdated { get; }
Selector: isDeleted
Property: bool IsDeleted { get; }
Selector: isFault
Property: bool IsFault { get; }
Selector: hasFaultForRelationshipNamed:
Method: bool HasFaultForRelationshipNamed (string key);
Selector: willAccessValueForKey:
Method: void WillAccessValueForKey (string key);
Selector: didAccessValueForKey:
Method: void DidAccessValueForKey (string key);
Selector: willChangeValueForKey:
Method: void WillChangeValueForKey (string key);
Selector: didChangeValueForKey:
Method: void DidChangeValueForKey (string key);
Selector: willChangeValueForKey:withSetMutation:usingObjects:
Method: void WillChangeValueForKey (string inKey, NSKeyValueSetMutationKind inMutationKind, NSSet inObjects);
Selector: didChangeValueForKey:withSetMutation:usingObjects:
Method: void DidChangeValueForKey (string inKey, NSKeyValueSetMutationKind inMutationKind, NSSet inObjects);
Selector: observationInfo
Property: IntPtr ObservationInfo { get; set; }
Selector: awakeFromFetch
Method: void AwakeFromFetch ();
Selector: awakeFromInsert
Method: void AwakeFromInsert ();
Selector: willSave
Method: void WillSave ();
Selector: didSave
Method: void DidSave ();
Selector: willTurnIntoFault
Method: void WillTurnIntoFault ();
Selector: didTurnIntoFault
Method: void DidTurnIntoFault ();
Selector: valueForKey:
Method: IntPtr ValueForKey (string key);
Selector: setValue:forKey:
Method: void SetValue (IntPtr value, string key);
Selector: primitiveValueForKey:
Method: IntPtr PrimitiveValueForKey (string key);
Selector: setPrimitiveValue:forKey:
Method: void SetPrimitiveValue (IntPtr value, string key);
Selector: committedValuesForKeys:
Method: NSDictionary CommittedValuesForKeys (string[] keys);
Selector: changedValues
Property: NSDictionary ChangedValues { get; }
Selector: validateValue:forKey:error:
Method: bool ValidateValue (NSObject value, string key, out NSError error);
Selector: validateForDelete:
Method: bool ValidateForDelete (out NSError error);
Selector: validateForInsert:
Method: bool ValidateForInsert (out NSError error);
Selector: validateForUpdate:
Method: bool ValidateForUpdate (out NSError error);
Selector: hasChanges
Property: bool HasChanges { get; }
Selector: changedValuesForCurrentEvent
Property: NSDictionary ChangedValuesForCurrentEvent { get; }

Class NSManagedObjectContext

Selector: persistentStoreCoordinator
Property: NSPersistentStoreCoordinator PersistentStoreCoordinator { get; set; }
Selector: undoManager
Property: NSUndoManager UndoManager { get; set; }
Selector: hasChanges
Property: bool HasChanges { get; }
Selector: objectRegisteredForID:
Method: NSManagedObject ObjectRegisteredForID (NSManagedObjectID objectID);
Selector: objectWithID:
Method: NSManagedObject ObjectWithID (NSManagedObjectID objectID);
Selector: executeFetchRequest:error:
Method: NSObject[] ExecuteFetchRequest (NSFetchRequest request, out NSError error);
Selector: countForFetchRequest:error:
Method: uint CountForFetchRequest (NSFetchRequest request, out NSError error);
Selector: insertObject:
Method: void InsertObject (NSManagedObject object1);
Selector: deleteObject:
Method: void DeleteObject (NSManagedObject object1);
Selector: refreshObject:mergeChanges:
Method: void RefreshObject (NSManagedObject object1, bool flag);
Selector: detectConflictsForObject:
Method: void DetectConflictsForObject (NSManagedObject object1);
Selector: observeValueForKeyPath:ofObject:change:context:
Method: void ObserveValueForKeyPath (string keyPath, IntPtr object1, NSDictionary change, IntPtr context);
Selector: processPendingChanges
Method: void ProcessPendingChanges ();
Selector: assignObject:toPersistentStore:
Method: void AssignObject (IntPtr object1, NSPersistentStore store);
Selector: insertedObjects
Property: NSSet InsertedObjects { get; }
Selector: updatedObjects
Property: NSSet UpdatedObjects { get; }
Selector: deletedObjects
Property: NSSet DeletedObjects { get; }
Selector: registeredObjects
Property: NSSet RegisteredObjects { get; }
Selector: undo
Method: void Undo ();
Selector: redo
Method: void Redo ();
Selector: reset
Method: void Reset ();
Selector: rollback
Method: void Rollback ();
Selector: save:
Method: bool Save (out NSError error);
Selector: lock
Method: void Lock ();
Selector: unlock
Method: void Unlock ();
Selector: tryLock
Property: bool TryLock { get; }
Selector: propagatesDeletesAtEndOfEvent
Property: bool PropagatesDeletesAtEndOfEvent { get; set; }
Selector: retainsRegisteredObjects
Property: bool RetainsRegisteredObjects { get; set; }
Selector: stalenessInterval
Property: double StalenessInterval { get; set; }
Selector: mergePolicy
Property: IntPtr MergePolicy { get; set; }
Selector: obtainPermanentIDsForObjects:error:
Method: bool ObtainPermanentIDsForObjects (NSManagedObject[] objects, out NSError error);
Selector: mergeChangesFromContextDidSaveNotification:
Method: void MergeChangesFromContextDidSaveNotification (NSNotification notification);
Selector: initWithConcurrencyType:
Method: IntPtr Constructor (NSManagedObjectContextConcurrencyType ct);
Selector: performBlock:
Method: void Perform (NSAction action);
Selector: performBlockAndWait:
Method: void PerformAndWait (NSAction action);
Selector: userInfo
Property: NSMutableDictionary UserInfo { get; }
Selector: concurrencyType
Property: NSManagedObjectContextConcurrencyType ConcurrencyType { get; }
Selector: parentContext
Property: NSManagedObjectContext ParentContext { get; set; }

Class NSManagedObjectID

Selector: entity
Property: NSEntityDescription Entity { get; }
Selector: persistentStore
Property: NSPersistentStore PersistentStore { get; }
Selector: isTemporaryID
Property: bool IsTemporaryID { get; }
Selector: URIRepresentation
Property: NSUrl URIRepresentation { get; }

Class NSManagedObjectModel

Selector: mergedModelFromBundles:
Method: NSManagedObjectModel MergedModelFromBundles (NSBundle[] bundles);
Selector: modelByMergingModels:
Method: NSManagedObjectModel ModelByMergingModels (NSManagedObjectModel[] models);
Selector: init
Property: IntPtr Init { get; }
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl url);
Selector: entitiesByName
Property: NSDictionary EntitiesByName { get; }
Selector: entities
Property: NSEntityDescription[] Entities { get; set; }
Selector: configurations
Property: string[] Configurations { get; }
Selector: entitiesForConfiguration:
Method: string[] EntitiesForConfiguration (string configuration);
Selector: setEntities:forConfiguration:
Method: void SetEntities (NSEntityDescription[] entities, string configuration);
Selector: setFetchRequestTemplate:forName:
Method: void SetFetchRequestTemplate (NSFetchRequest fetchRequestTemplate, string name);
Selector: fetchRequestTemplateForName:
Method: NSFetchRequest FetchRequestTemplateForName (string name);
Selector: fetchRequestFromTemplateWithName:substitutionVariables:
Method: NSFetchRequest FetchRequestFromTemplateWithName (string name, NSDictionary variables);
Selector: localizationDictionary
Property: NSDictionary LocalizationDictionary { get; set; }
Selector: mergedModelFromBundles:forStoreMetadata:
Method: NSManagedObjectModel MergedModelFromBundles (NSBundle[] bundles, NSDictionary metadata);
Selector: modelByMergingModels:forStoreMetadata:
Method: NSManagedObjectModel ModelByMergingModels (NSManagedObjectModel[] models, NSDictionary metadata);
Selector: fetchRequestTemplatesByName
Property: NSDictionary FetchRequestTemplatesByName { get; }
Selector: versionIdentifiers
Property: NSSet VersionIdentifiers { get; set; }
Selector: isConfiguration:compatibleWithStoreMetadata:
Method: bool IsConfiguration (string configuration, NSDictionary metadata);
Selector: entityVersionHashesByName
Property: NSDictionary EntityVersionHashesByName { get; }

Class NSMappingModel

Selector: mappingModelFromBundles:forSourceModel:destinationModel:
Method: NSMappingModel MappingModelFromBundles (NSBundle[] bundles, NSManagedObjectModel sourceModel, NSManagedObjectModel destinationModel);
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl url);
Selector: entityMappings
Property: NSEntityMapping[] EntityMappings { get; set; }
Selector: entityMappingsByName
Property: NSDictionary EntityMappingsByName { get; }

Class NSMergeConflict

Selector: sourceObject
Property: NSManagedObject SourceObject { get; }
Selector: objectSnapshot
Property: NSDictionary ObjectSnapshot { get; }
Selector: cachedSnapshot
Property: NSDictionary CachedSnapshot { get; }
Selector: persistedSnapshot
Property: NSDictionary PersistedSnapshot { get; }
Selector: newVersionNumber
Property: uint NewVersionNumber { get; }
Selector: oldVersionNumber
Property: uint OldVersionNumber { get; }
Selector: initWithSource:newVersion:oldVersion:cachedSnapshot:persistedSnapshot:
Method: IntPtr Constructor (NSManagedObject srcObject, uint newvers, uint oldvers, NSDictionary cachesnap, NSDictionary persnap);

Class NSMergePolicy

Selector: mergeType
Property: NSMergePolicyType MergeType { get; }
Selector: initWithMergeType:
Method: IntPtr Constructor (NSMergePolicyType ty);
Selector: resolveConflicts:error:
Method: bool ResolveConflictserror (NSMergeConflict [] list, out NSError error);

Class NSMigrationManager

Selector: initWithSourceModel:destinationModel:
Method: IntPtr Constructor (NSManagedObjectModel sourceModel, NSManagedObjectModel destinationModel);
Selector: migrateStoreFromURL:type:options:withMappingModel:toDestinationURL:destinationType:destinationOptions:error:
Method: bool MigrateStoreFromUrl (NSUrl sourceURL, string sStoreType, NSDictionary sOptions, NSMappingModel mappings, NSUrl dURL, string dStoreType, NSDictionary dOptions, out NSError error);
Selector: reset
Method: void Reset ();
Selector: mappingModel
Property: NSMappingModel MappingModel { get; }
Selector: sourceModel
Property: NSManagedObjectModel SourceModel { get; }
Selector: destinationModel
Property: NSManagedObjectModel DestinationModel { get; }
Selector: sourceContext
Property: NSManagedObjectContext SourceContext { get; }
Selector: destinationContext
Property: NSManagedObjectContext DestinationContext { get; }
Selector: sourceEntityForEntityMapping:
Method: NSEntityDescription SourceEntityForEntityMapping (NSEntityMapping mEntity);
Selector: destinationEntityForEntityMapping:
Method: NSEntityDescription DestinationEntityForEntityMapping (NSEntityMapping mEntity);
Selector: associateSourceInstance:withDestinationInstance:forEntityMapping:
Method: void AssociateSourceInstance (NSManagedObject sourceInstance, NSManagedObject destinationInstance, NSEntityMapping entityMapping);
Selector: destinationInstancesForEntityMappingNamed:sourceInstances:
Method: NSManagedObject[] DestinationInstancesForEntityMappingNamed (string mappingName, NSManagedObject[] sourceInstances);
Selector: sourceInstancesForEntityMappingNamed:destinationInstances:
Method: NSManagedObject[] SourceInstancesForEntityMappingNamed (string mappingName, NSManagedObject[] destinationInstances);
Selector: currentEntityMapping
Property: NSEntityMapping CurrentEntityMapping { get; }
Selector: migrationProgress
Property: float MigrationProgress { get; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }
Selector: cancelMigrationWithError:
Method: void CancelMigrationWithError (NSError error);
Selector: usesStoreSpecificMigrationManager
Property: bool UsesStoreSpecificMigrationManager { get; set; }

Class NSPersistentStore

Selector: metadataForPersistentStoreWithURL:error:
Method: NSDictionary MetadataForPersistentStoreWithUrl (NSUrl url, out NSError error);
Selector: setMetadata:forPersistentStoreWithURL:error:
Method: bool SetMetadata (NSDictionary metadata, NSUrl url, out NSError error);
Selector: initWithPersistentStoreCoordinator:configurationName:URL:options:
Method: IntPtr Constructor (NSPersistentStoreCoordinator root, string name, NSUrl url, NSDictionary options);
Selector: persistentStoreCoordinator
Property: NSPersistentStoreCoordinator PersistentStoreCoordinator { get; }
Selector: configurationName
Property: string ConfigurationName { get; }
Selector: options
Property: NSDictionary Options { get; }
Selector: URL
Property: NSUrl Url { get; set; }
Selector: identifier
Property: string Identifier { get; set; }
Selector: type
Property: string Type { get; }
Selector: isReadOnly
Property: bool ReadOnly { get; [Bind("setReadOnly:")] set; }
Selector: metadata
Property: NSDictionary Metadata { get; set; }
Selector: didAddToPersistentStoreCoordinator:
Method: void DidAddToPersistentStoreCoordinator (NSPersistentStoreCoordinator coordinator);
Selector: willRemoveFromPersistentStoreCoordinator:
Method: void WillRemoveFromPersistentStoreCoordinator (NSPersistentStoreCoordinator coordinator);

Class NSPersistentStoreCoordinator

Selector: registeredStoreTypes
Property: NSDictionary RegisteredStoreTypes { get; }
Selector: registerStoreClass:forStoreType:
Method: void RegisterStoreClass (Class storeClass, NSString storeType);
Selector: metadataForPersistentStoreOfType:URL:error:
Method: NSDictionary MetadataForPersistentStoreOfType (NSString storeType, NSUrl url, out NSError error);
Selector: setMetadata:forPersistentStoreOfType:URL:error:
Method: bool SetMetadata (NSDictionary metadata, NSString storeType, NSUrl url, out NSError error);
Selector: setMetadata:forPersistentStore:
Method: void SetMetadata (NSDictionary metadata, NSPersistentStore store);
Selector: metadataForPersistentStore:
Method: NSDictionary MetadataForPersistentStore (NSPersistentStore store);
Selector: initWithManagedObjectModel:
Method: IntPtr Constructor (NSManagedObjectModel model);
Selector: managedObjectModel
Property: NSManagedObjectModel ManagedObjectModel { get; }
Selector: persistentStores
Property: NSPersistentStore[] PersistentStores { get; }
Selector: persistentStoreForURL:
Method: NSPersistentStore PersistentStoreForUrl (NSUrl URL);
Selector: URLForPersistentStore:
Method: NSUrl UrlForPersistentStore (NSPersistentStore store);
Selector: setURL:forPersistentStore:
Method: bool SetUrl (NSUrl url, NSPersistentStore store);
Selector: addPersistentStoreWithType:configuration:URL:options:error:
Method: NSPersistentStore AddPersistentStoreWithType (NSString storeType, string configuration, NSUrl storeURL, NSDictionary options, out NSError error);
Selector: removePersistentStore:error:
Method: bool RemovePersistentStore (NSPersistentStore store, out NSError error);
Selector: migratePersistentStore:toURL:options:withType:error:
Method: NSPersistentStore MigratePersistentStore (NSPersistentStore store, NSUrl URL, NSDictionary options, NSString storeType, out NSError error);
Selector: managedObjectIDForURIRepresentation:
Method: NSManagedObjectID ManagedObjectIDForURIRepresentation (NSUrl url);
Selector: lock
Method: void Lock ();
Selector: unlock
Method: void Unlock ();
Selector: tryLock
Property: bool TryLock { get; }
Selector: metadataForPersistentStoreWithURL:error:
Method: NSDictionary MetadataForPersistentStoreWithUrl (NSUrl url, out NSError error);
Selector: executeRequest:withContext:error:
Method: NSObject ExecuteRequestwithContexterror (NSPersistentStoreRequest request, NSManagedObjectContext context, out NSError error);

Class NSPersistentStoreRequest

Selector: requestType
Property: NSPersistentStoreRequestType RequestType { get; }
Selector: affectedStores
Property: NSPersistentStore [] AffectedStores { get; set; }

Class NSPropertyDescription

Selector: entity
Property: NSEntityDescription Entity { get; }
Selector: name
Property: string Name { get; set; }
Selector: isOptional
Property: bool Optional { get; [Bind("setOptional:")] set; }
Selector: isTransient
Property: bool Transient { get; [Bind("setTransient:")] set; }
Selector: validationPredicates
Property: NSPredicate[] ValidationPredicates { get; }
Selector: validationWarnings
Property: string[] ValidationWarnings { get; }
Selector: setValidationPredicates:withValidationWarnings:
Method: void SetValidationPredicates (NSPredicate[] validationPredicates, string[] validationWarnings);
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }
Selector: isIndexed
Property: bool Indexed { get; [Bind("setIndexed:")] set; }
Selector: versionHash
Property: NSData VersionHash { get; }
Selector: versionHashModifier
Property: string VersionHashModifier { get; set; }
Selector: indexedBySpotlight
Property: bool IndexedBySpotlight { [Bind ("isIndexedBySpotlight")]get; set; }
Selector: storedInExternalRecord
Property: bool StoredInExternalRecord { [Bind ("isStoredInExternalRecord")]get; set; }

Class NSPropertyMapping

Selector: name
Property: string Name { get; set; }
Selector: valueExpression
Property: NSExpression ValueExpression { get; set; }
Selector: userInfo
Property: NSDictionary UserInfo { get; set; }

Class NSRelationshipDescription

Selector: destinationEntity
Property: NSEntityDescription DestinationEntity { get; set; }
Selector: inverseRelationship
Property: NSRelationshipDescription InverseRelationship { get; set; }
Selector: maxCount
Property: uint MaxCount { get; set; }
Selector: minCount
Property: uint MinCount { get; set; }
Selector: deleteRule
Property: NSDeleteRule DeleteRule { get; set; }
Selector: isToMany
Property: bool IsToMany { get; }
Selector: versionHash
Property: NSData VersionHash { get; }
Selector: ordered
Property: bool Ordered { [Bind ("isOrdered")]get; set; }

Class NSSaveChangesRequest

Selector: initWithInsertedObjects:updatedObjects:deletedObjects:lockedObjects:
Method: IntPtr Constructor (NSSet insertedObjects, NSSet updatedObjects, NSSet deletedObjects, NSSet lockedObjects);
Selector: insertedObjects
Property: NSSet InsertedObjects { get; }
Selector: updatedObjects
Property: NSSet UpdatedObjects { get; }
Selector: deletedObjects
Property: NSSet DeletedObjects { get; }
Selector: lockedObjects
Property: NSSet LockedObjects { get; }

Namespace MonoTouch.CoreImage

Class CIColor

Selector: colorWithCGColor:
Method: CIColor FromCGColor (CGColor c);
Selector: colorWithRed:green:blue:alpha:
Method: CIColor FromRgba (float r, float g, float b, float a);
Selector: colorWithRed:green:blue:
Method: CIColor FromRgb (float r, float g, float b);
Selector: colorWithString:
Method: CIColor FromString (string representation);
Selector: initWithCGColor:
Method: IntPtr Constructor (CGColor c);
Selector: numberOfComponents
Property: int NumberOfComponents { get; }
Selector: components
Method: //const CGFloat Components ();
Selector: alpha
Property: float Alpha { get; }
Selector: colorSpace
Property: CGColorSpace ColorSpace { get; }
Selector: red
Property: float Red { get; }
Selector: green
Property: float Green { get; }
Selector: blue
Property: float Blue { get; }
Selector: stringRepresentation
Method: string StringRepresentation ();
Selector: initWithColor:
Method: IntPtr Constructor (UIColor color);

Class CIContext

Selector: contextWithCGLContext:pixelFormat:colorSpace:options:
Method: //CIContext ContextWithCGLContextpixelFormatcolorSpaceoptions (CGLContextObj ctx, CGLPixelFormatObj pf, CGColorSpaceRef cs, NSDictionary dict, );
Selector: contextWithCGContext:options:
Method: CIContext FromContext (CGContext ctx, [NullAllowed] NSDictionary options);
Selector: contextWithEAGLContext:
Method: CIContext FromContext (EAGLContext eaglContext);
Selector: contextWithOptions:
Method: CIContext FromOptions ([NullAllowed] NSDictionary dictionary);
Selector: render:toCVPixelBuffer:
Method: void Render (CIImage image, CVPixelBuffer buffer);
Selector: render:toCVPixelBuffer:bounds:colorSpace:
Method: void Render (CIImage image, CVPixelBuffer buffer, RectangleF rectangle, CGColorSpace cs);
Selector: inputImageMaximumSize
Property: SizeF InputImageMaximumSize { get; }
Selector: outputImageMaximumSize
Property: SizeF OutputImageMaximumSize { get; }
Selector: drawImage:atPoint:fromRect:
Method: void DrawImage (CIImage image, PointF atPoint, RectangleF fromRect);
Selector: drawImage:inRect:fromRect:
Method: void DrawImage (CIImage image, RectangleF inRectangle, RectangleF fromRectangle);
Selector: createCGImage:fromRect:
Method: CGImage CreateCGImage (CIImage image, RectangleF fromRectangle);
Selector: createCGImage:fromRect:format:colorSpace:
Method: CGImage CreateCGImage (CIImage image, RectangleF fromRect, int ciImageFormat, CGColorSpace colorSpace);
Selector: createCGLayerWithSize:info:
Method: CGLayer CreateCGLayer (SizeF size, [NullAllowed] NSDictionary info);
Selector: render:toBitmap:rowBytes:bounds:format:colorSpace:
Method: void RenderToBitmap (CIImage image, IntPtr bitmapPtr, int bytesPerRow, RectangleF bounds, int bitmapFormat, CGColorSpace colorSpace);
Selector: render:toIOSurface:bounds:colorSpace:
Method: //void RendertoIOSurfaceboundscolorSpace (CIImage im, IOSurfaceRef surface, RectangleF r, CGColorSpaceRef cs, );
Selector: reclaimResources
Method: void ReclaimResources ();
Selector: clearCaches
Method: void ClearCaches ();

Class CIFilter

Selector: inputKeys
Property: string [] InputKeys { get; }
Selector: outputKeys
Property: string [] OutputKeys { get; }
Selector: setDefaults
Method: void SetDefaults ();
Selector: attributes
Property: NSDictionary Attributes { get; }
Selector: name
Property: string Name { get; set;}
Selector: filterWithName:
Method: CIFilter FromName (string name);
Selector: filterNamesInCategory:
Method: string [] FilterNamesInCategory (string category);
Selector: filterNamesInCategories:
Method: string [] _FilterNamesInCategories (string [] categories);
Selector: apply:arguments:options:
Method: CIImage Apply (CIKernel k, NSArray args, NSDictionary options);
Selector: registerFilterName:constructor:classAttributes:
Method: void RegisterFilterName (string name, NSObject constructorObject, NSDictionary classAttributes);
Selector: localizedNameForFilterName:
Method: string FilterLocalizedName (string filterName);
Selector: localizedNameForCategory:
Method: string CategoryLocalizedName (string category);
Selector: localizedDescriptionForFilterName:
Method: string FilterLocalizedDescription (string filterName);
Selector: localizedReferenceDocumentationForFilterName:
Method: NSUrl FilterLocalizedReferenceDocumentation (string filterName);
Selector: outputImage
Property: CIImage OutputImage { get; }
Selector: setValue:forKey:
Method: void SetValueForKey ([NullAllowed] NSObject value, NSString key);
Selector: valueForKey:
Method: NSObject ValueForKey (NSString key);

Class CIFilterOutputKey

Class CIFilterInputKey

Class CIFilterAttributes

Class CIFilterCategory

Class CIUIParameterSet

Class CIFilterApply

Class CIFilterGenerator

Selector: filterGenerator
Method: CIFilterGenerator Create ();
Selector: filterGeneratorWithContentsOfURL:
Method: CIFilterGenerator FromUrl (NSUrl aURL);
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl aURL);
Selector: connectObject:withKey:toObject:withKey:
Method: void ConnectObject (NSObject sourceObject, string withSourceKey, NSObject targetObject, string targetKey);
Selector: disconnectObject:withKey:toObject:withKey:
Method: void DisconnectObject (NSObject sourceObject, string sourceKey, NSObject targetObject, string targetKey);
Selector: exportKey:fromObject:withName:
Method: void ExportKey (string key, NSObject targetObject, string exportedKeyName);
Selector: removeExportedKey:
Method: void RemoveExportedKey (string exportedKeyName);
Selector: exportedKeys
Property: NSDictionary ExportedKeys { get; }
Selector: setAttributes:forExportedKey:
Method: void SetAttributesforExportedKey (NSDictionary attributes, NSString exportedKey);
Selector: filter
Method: CIFilter CreateFilter ();
Selector: registerFilterName:
Method: void RegisterFilterName (string name);
Selector: writeToURL:atomically:
Method: bool Save (NSUrl toUrl, bool atomically);
Selector: classAttributes
Property: NSDictionary ClassAttributes { get; set; }
Selector: kCIFilterGeneratorExportedKey", "+CoreImage
Property: NSString ExportedKey { get; }
Selector: kCIFilterGeneratorExportedKeyTargetObject", "+CoreImage
Property: NSString ExportedKeyTargetObject { get; }
Selector: kCIFilterGeneratorExportedKeyName", "+CoreImage
Property: NSString ExportedKeyName { get; }

Class CIFilterShape

Selector: shapeWithRect:
Method: CIFilterShape FromRect (RectangleF rect);
Selector: initWithRect:
Method: IntPtr Constructor (RectangleF rect);
Selector: transformBy:interior:
Method: CIFilterShape Transform (CGAffineTransform transformation, bool interiorFlag);
Selector: insetByX:Y:
Method: CIFilterShape Inset (int dx, int dy);
Selector: unionWith:
Method: CIFilterShape Union (CIFilterShape other);
Selector: unionWithRect:
Method: CIFilterShape Union (RectangleF rectangle);
Selector: intersectWith:
Method: CIFilterShape Intersect (CIFilterShape other);
Selector: intersectWithRect:
Method: CIFilterShape IntersectWithRect (Rectangle rectangle);

Class CIImage

Selector: imageWithCGImage:
Method: CIImage FromCGImage (CGImage image);
Selector: imageWithCGImage:options:
Method: CIImage FromCGImage (CGImage image, NSDictionary d);
Selector: imageWithCGLayer:
Method: CIImage FromLayer (CGLayer layer);
Selector: imageWithCGLayer:options:
Method: CIImage FromLayer (CGLayer layer, NSDictionary options);
Selector: imageWithBitmapData:bytesPerRow:size:format:colorSpace:
Method: CIImage FromData (NSData bitmapData, int bpr, SizeF size, int ciImageFormat, CGColorSpace colorspace);
Selector: imageWithTexture:size:flipped:colorSpace:
Method: CIImage ImageWithTexturesizeflippedcolorSpace (int glTextureName, SizeF size, bool flag, CGColorSpace colorspace);
Selector: imageWithContentsOfURL:
Method: CIImage FromUrl (NSUrl url);
Selector: imageWithContentsOfURL:options:
Method: CIImage FromUrl (NSUrl url, NSDictionary d);
Selector: imageWithData:
Method: CIImage FromData (NSData data);
Selector: imageWithData:options:
Method: CIImage FromData (NSData data, NSDictionary d);
Selector: imageWithCVImageBuffer:
Method: CIImage FromImageBuffer (CVImageBuffer imageBuffer);
Selector: imageWithCVImageBuffer:options:
Method: CIImage FromImageBuffer (CVImageBuffer imageBuffer, NSDictionary dict);
Selector: imageWithCVPixelBuffer:
Method: CIImage FromImageBuffer (CVPixelBuffer buffer);
Selector: imageWithCVPixelBuffer:options:
Method: CIImage FromImageBuffer (CVPixelBuffer buffer, NSDictionary dict);
Selector: imageWithIOSurface:
Method: //CIImage ImageWithIOSurface (IOSurfaceRef surface, );
Selector: imageWithIOSurface:options:
Method: //CIImage ImageWithIOSurfaceoptions (IOSurfaceRef surface, NSDictionary d, );
Selector: imageWithColor:
Method: CIImage ImageWithColor (CIColor color);
Selector: emptyImage
Property: CIImage EmptyImage { get; }
Selector: initWithCGImage:
Method: IntPtr Constructor (CGImage image);
Selector: initWithCGImage:options:
Method: IntPtr Constructor (CGImage image, NSDictionary d);
Selector: initWithCGLayer:
Method: IntPtr Constructor (CGLayer layer);
Selector: initWithCGLayer:options:
Method: NSObject IntPtr (CGLayer layer, NSDictionary d);
Selector: initWithData:
Method: IntPtr Constructor (NSData data);
Selector: initWithData:options:
Method: IntPtr Constructor (NSData data, NSDictionary d);
Selector: initWithBitmapData:bytesPerRow:size:format:colorSpace:
Method: IntPtr Constructor (NSData d, int bpr, SizeF size, int f, CGColorSpace c);
Selector: initWithTexture:size:flipped:colorSpace:
Method: IntPtr Constructor (int glTextureName, SizeF size, bool flag, CGColorSpace cs);
Selector: initWithContentsOfURL:
Method: IntPtr Constructor (NSUrl url);
Selector: initWithContentsOfURL:options:
Method: IntPtr Constructor (NSUrl url, NSDictionary d);
Selector: initWithIOSurface:
Method: //NSObject InitWithIOSurface (IOSurfaceRef surface, );
Selector: initWithIOSurface:options:
Method: //NSObject InitWithIOSurfaceoptions (IOSurfaceRef surface, NSDictionary d, );
Selector: initWithCVImageBuffer:
Method: IntPtr Constructor (CVImageBuffer imageBuffer);
Selector: initWithCVImageBuffer:options:
Method: IntPtr Constructor (CVImageBuffer imageBuffer, NSDictionary dict);
Selector: initWithColor:
Method: IntPtr Constructor (CIColor color);
Selector: imageByApplyingTransform:
Method: CIImage ImageByApplyingTransform (CGAffineTransform matrix);
Selector: imageByCroppingToRect:
Method: CIImage ImageByCroppingToRect (RectangleF r);
Selector: extent
Property: RectangleF Extent { get; }
Selector: definition
Method: //CIFilterShape Definition ();
Selector: url
Property: NSUrl Url { get; }
Selector: colorSpace
Property: CGColorSpace ColorSpace { get; }
Selector: initWithImage:
Method: IntPtr Constructor (UIImage image);
Selector: initWithImage:options
Method: IntPtr Constructor (UIImage image, NSDictionary options);
Selector: autoAdjustmentFilters
Method: NSArray _GetAutoAdjustmentFilters ();
Selector: autoAdjustmentFiltersWithOptions:
Method: NSArray _GetAutoAdjustmentFilters (NSDictionary opts);

Class CIImageAccumulator

Selector: imageAccumulatorWithExtent:format:
Method: CIImageAccumulator FromRectangle (RectangleF rect, int ciImageFormat);
Selector: initWithExtent:format:
Method: IntPtr Constructor (RectangleF rectangle, int ciImageFormat);
Selector: extent
Property: RectangleF Extent { get; }
Selector: format
Property: int CIImageFormat { get; }
Selector: setImage:dirtyRect:
Method: void SetImageDirty (CIImage image, RectangleF dirtyRect);
Selector: clear
Method: void Clear ();
Selector: image
Property: CIImage Image { get; set; }

Class CIKernel

Selector: kernelsWithString:
Method: CIKernel [] FromProgram (string coreImageShaderProgram);
Selector: name
Property: string Name { get; }
Selector: setROISelector:
Method: void SetRegionOfInterestSelector (Selector aMethod);

Class CIPlugIn

Selector: loadAllPlugIns
Method: void LoadAllPlugIns ();
Selector: loadNonExecutablePlugIns
Method: void LoadNonExecutablePlugIns ();
Selector: loadPlugIn:allowNonExecutable:
Method: void LoadPlugIn (NSUrl pluginUrl, bool allowNonExecutable);

Class CISampler

Selector: samplerWithImage:
Method: CISampler FromImage (CIImage sourceImage);
Selector: samplerWithImage:options:
Method: CISampler FromImage (CIImage sourceImag, NSDictionary options);
Selector: initWithImage:
Method: IntPtr Constructor (CIImage sourceImage);
Selector: initWithImage:options:
Method: NSObject Constructor (CIImage image, NSDictionary options);
Selector: definition
Property: CIFilterShape Definition { get; }
Selector: extent
Property: RectangleF Extent { get; }

Class CIVector

Selector: vectorWithValues:count:
Method: CIVector _FromValues (IntPtr values, int count);
Selector: vectorWithX:
Method: CIVector Create (float x);
Selector: vectorWithX:Y:
Method: CIVector Create (float x, float y);
Selector: vectorWithX:Y:Z:
Method: CIVector Create (float x, float y, float z);
Selector: vectorWithX:Y:Z:W:
Method: CIVector Create (float x, float y, float z, float w);
Selector: vectorWithCGPoint:
Method: CIVector Create (PointF point);
Selector: vectorWithCGRect:
Method: CIVector Create (RectangleF point);
Selector: vectorWithCGAffineTransform:
Method: CIVector Create (CGAffineTransform affineTransform);
Selector: vectorWithString:
Method: CIVector FromString (string representation);
Selector: initWithValues:count:
Method: IntPtr Constructor (IntPtr values, int count);
Selector: initWithX:
Method: IntPtr Constructor(float x);
Selector: initWithX:Y:
Method: IntPtr Constructor (float x, float y);
Selector: initWithX:Y:Z:
Method: IntPtr Constructor (float x, float y, float z);
Selector: initWithX:Y:Z:W:
Method: IntPtr Constructor (float x, float y, float z, float w);
Selector: initWithString:
Method: IntPtr Constructor (string representation);
Selector: valueAtIndex:
Method: float ValueAtIndex (int index);
Selector: count
Property: int Count { get; }
Selector: X
Property: float X { get; }
Selector: Y
Property: float Y { get; }
Selector: Z
Property: float Z { get; }
Selector: W
Property: float W { get; }
Selector: CGPointValue
Property: PointF Point { get; }
Selector: CGRectValue
Property: RectangleF Rectangle { get; }
Selector: CGAffineTransformValue
Property: CGAffineTransform AffineTransform { get; }
Selector: stringRepresentation
Method: string StringRepresentation ();

Class CIDetector

Selector: detectorOfType:context:options:
Method: CIDetector FromType (NSString detectorType, CIContext context, [NullAllowed] NSDictionary options);
Selector: featuresInImage:
Method: CIFeature [] FeaturesInImage (CIImage image);
Selector: featuresInImage:options:
Method: CIFeature [] FeaturesInImage (CIImage image, NSDictionary options);

Class CIFeature

Selector: type
Property: NSString Type { get; }
Selector: bounds
Property: RectangleF Bounds { get; }

Class CIFaceFeature

Selector: hasLeftEyePosition
Property: bool HasLeftEyePosition { get; }
Selector: leftEyePosition
Property: PointF LeftEyePosition { get; }
Selector: hasRightEyePosition
Property: bool HasRightEyePosition { get; }
Selector: rightEyePosition
Property: PointF RightEyePosition { get; }
Selector: hasMouthPosition
Property: bool HasMouthPosition { get; }
Selector: mouthPosition
Property: PointF MouthPosition { get; }

Namespace MonoTouch.CoreLocation

Class CLHeading

Selector: magneticHeading
Property: double MagneticHeading { get; }
Selector: trueHeading
Property: double TrueHeading { get; }
Selector: headingAccuracy
Property: double HeadingAccuracy { get; }
Selector: x
Property: double X { get; }
Selector: y
Property: double Y { get; }
Selector: z
Property: double Z { get; }
Selector: timestamp
Property: NSDate Timestamp { get; }
Selector: description
Method: string Description ();

Class CLLocation

Selector: coordinate
Property: CLLocationCoordinate2D Coordinate { get; }
Selector: altitude
Property: double Altitude { get; }
Selector: horizontalAccuracy
Property: double HorizontalAccuracy { get; }
Selector: verticalAccuracy
Property: double VerticalAccuracy { get; }
Selector: course
Property: double Course { get; }
Selector: speed
Property: double Speed { get; }
Selector: timestamp
Property: NSDate Timestamp { get; }
Selector: initWithLatitude:longitude:
Method: IntPtr Constructor (double latitude, double longitude);
Selector: initWithCoordinate:altitude:horizontalAccuracy:verticalAccuracy:timestamp:
Method: IntPtr Constructor (CLLocationCoordinate2D coordinate, double altitude, double hAccuracy, double vAccuracy, NSDate timestamp);
Selector: description
Method: string Description ();
Selector: getDistanceFrom:
Method: double Distancefrom (CLLocation location);
Selector: distanceFromLocation:
Method: double DistanceFrom (CLLocation location);
Selector: initWithCoordinate:altitude:horizontalAccuracy:verticalAccuracy:course:speed:timestamp:
Method: IntPtr Constructor (CLLocationCoordinate2D coordinate, double altitude, double hAccuracy, double vAccuracy, double course, double speed, NSDate timestamp);

Class CLLocationManager

Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: locationServicesEnabled
Property: bool _LocationServicesEnabledInstance { get; }
Selector: distanceFilter
Property: double DistanceFilter { get; set; }
Selector: desiredAccuracy
Property: double DesiredAccuracy { get; set; }
Selector: location
Property: CLLocation Location { get; }
Selector: startUpdatingLocation
Method: void StartUpdatingLocation ();
Selector: stopUpdatingLocation
Method: void StopUpdatingLocation ();
Selector: locationServicesEnabled
Property: bool _LocationServicesEnabledStatic { get; }
Selector: headingFilter
Property: double HeadingFilter { get; set; }
Selector: headingAvailable
Property: bool _HeadingAvailableInstance { get; }
Selector: startUpdatingHeading
Method: void StartUpdatingHeading ();
Selector: stopUpdatingHeading
Method: void StopUpdatingHeading ();
Selector: dismissHeadingCalibrationDisplay
Method: void DismissHeadingCalibrationDisplay ();
Selector: purpose
Property: string Purpose { get; set; }
Selector: headingAvailable
Property: bool _HeadingAvailableStatic { get; }
Selector: significantLocationChangeMonitoringAvailable
Property: bool SignificantLocationChangeMonitoringAvailable { get; }
Selector: regionMonitoringAvailable
Property: bool RegionMonitoringAvailable { get; }
Selector: regionMonitoringEnabled
Property: bool RegionMonitoringEnabled { get; }
Selector: headingOrientation
Property: CLDeviceOrientation HeadingOrientation { get; set; }
Selector: heading
Method: [Since (4,0)]
Selector: maximumRegionMonitoringDistance
Method: [Since (4,0)]
Selector: monitoredRegions
Method: [Since (4,0)]
Selector: startMonitoringSignificantLocationChanges
Method: void StartMonitoringSignificantLocationChanges ();
Selector: stopMonitoringSignificantLocationChanges
Method: void StopMonitoringSignificantLocationChanges ();
Selector: startMonitoringForRegion:desiredAccuracy:
Method: void StartMonitoring (CLRegion region, double desiredAccuracy);
Selector: stopMonitoringForRegion:
Method: void StopMonitoring (CLRegion region);
Selector: authorizationStatus
Property: CLAuthorizationStatus Status { get; }
Selector: startMonitoringForRegion:
Method: void StartMonitoring (CLRegion region);

Class CLLocationManagerDelegate

Selector: locationManager:didUpdateToLocation:fromLocation:"), EventArgs ("CLLocationUpdated
Method: void UpdatedLocation (CLLocationManager manager, CLLocation newLocation, CLLocation oldLocation);
Selector: locationManager:didUpdateHeading:"), EventArgs ("CLHeadingUpdated
Method: void UpdatedHeading (CLLocationManager manager, CLHeading newHeading);
Selector: locationManagerShouldDisplayHeadingCalibration:"), DelegateName ("CLLocationManagerEventArgs
Method: bool ShouldDisplayHeadingCalibration (CLLocationManager manager);
Selector: locationManager:didFailWithError:"), EventArgs ("NSError
Method: void Failed (CLLocationManager manager, NSError error);
Selector: locationManager:didEnterRegion:"), EventArgs ("CLRegion
Method: void RegionEntered (CLLocationManager manager, CLRegion region);
Selector: locationManager:didExitRegion:"), EventArgs ("CLRegion
Method: void RegionLeft (CLLocationManager manager, CLRegion region);
Selector: locationManager:monitoringDidFailForRegion:withError:"), EventArgs ("CLRegionError
Method: void MonitoringFailed (CLLocationManager manager, CLRegion region, NSError error);
Selector: locationManager:didStartMonitoringForRegion:
Method: void DidStartMonitoringForRegion (CLRegion region);
Selector: locationManager:didChangeAuthorizationStatus:"), EventArgs ("CLAuthroziationChanged
Method: void AuthorizationChanged (CLLocationManager manager, CLAuthorizationStatus status);

Class CLRegion

Selector: center
Property: CLLocationCoordinate2D Center { get; }
Selector: radius
Property: double Radius { get; }
Selector: identifier
Property: string Identifier { get; }
Selector: initCircularRegionWithCenter:radius:identifier:
Method: IntPtr Constructor (CLLocationCoordinate2D center, double radius, string identifier);
Selector: containsCoordinate:
Method: bool Contains (CLLocationCoordinate2D coordinate);

Class CLPlacemark

Selector: addressDictionary
Property: NSDictionary AddressDictionary { get; }
Selector: administrativeArea
Property: string AdministrativeArea { get; }
Selector: subAdministrativeArea
Property: string SubAdministrativeArea { get; }
Selector: subLocality
Property: string SubLocality { get; }
Selector: locality
Property: string Locality { get; }
Selector: country
Property: string Country { get; }
Selector: postalCode
Property: string PostalCode { get; }
Selector: thoroughfare
Property: string Thoroughfare { get; }
Selector: subThoroughfare
Property: string SubThoroughfare { get; }
Selector: ISOcountryCode
Property: string IsoCountryCode { get; }
Selector: areasOfInterest
Property: string [] AreasOfInterest { get; }
Selector: initWithPlacemark:
Method: IntPtr Constructor (CLPlacemark placemark);
Selector: inlandWater
Property: string InlandWater { get; }
Selector: location
Property: CLLocation Location { get; }
Selector: name
Property: string Name { get; }
Selector: ocean
Property: string Ocean { get; }
Selector: region
Property: CLRegion Region { get; }

Class CLGeocoder

Selector: isGeocoding
Property: bool Geocoding { get; }
Selector: reverseGeocodeLocation:completionHandler:
Method: void ReverseGeocodeLocation (CLLocation location, CLGeocodeCompletionHandler completionHandler);
Selector: geocodeAddressDictionary:completionHandler:
Method: void GeocodeAddress (NSDictionary addressDictionary, CLGeocodeCompletionHandler completionHandler);
Selector: geocodeAddressString:completionHandler:
Method: void GeocodeAddress (string addressString, CLGeocodeCompletionHandler completionHandler);
Selector: geocodeAddressString:inRegion:completionHandler:
Method: void GeocodeAddress (string addressString, CLRegion region, CLGeocodeCompletionHandler completionHandler);
Selector: cancelGeocode
Method: void CancelGeocode ();

Namespace MonoTouch.QuickLook

Class QLPreviewController

Selector: dataSource
Property: NSObject WeakDataSource { get; set; }
Selector: delegate
Property: NSObject WeakDelegate { get; set; }
Selector: currentPreviewItemIndex
Property: int CurrentPreviewItemIndex { get; set; }
Selector: currentPreviewItem
Property: QLPreviewItem CurrentPreviewItem { get; }
Selector: canPreviewItem:
Method: bool CanPreviewItem (QLPreviewItem item);
Selector: reloadData
Method: void ReloadData ();
Selector: refreshCurrentPreviewItem
Method: void RefreshCurrentPreviewItem ();

Class QLPreviewControllerDataSource

Selector: numberOfPreviewItemsInPreviewController:
Method: int PreviewItemCount (QLPreviewController controller);
Selector: previewController:previewItemAtIndex:
Method: QLPreviewItem GetPreviewItem (QLPreviewController controller, int index);

Class QLPreviewControllerDelegate

Selector: previewControllerWillDismiss:
Method: void WillDismiss (QLPreviewController controller);
Selector: previewControllerDidDismiss:
Method: void DidDismiss (QLPreviewController controller);
Selector: previewController:shouldOpenURL:forPreviewItem:"), DelegateName ("QLOpenUrl
Method: bool ShouldOpenUrl (QLPreviewController controller, NSUrl url, QLPreviewItem item);

Class QLPreviewItem

Selector: previewItemURL
Property: NSUrl ItemUrl { get; }
Selector: previewItemTitle
Property: string ItemTitle { get; }