             }
         }
     }
+    
+    /**
+     This is equivalent to rx_observe(), except the observer is immediately canceled after the initial data is returned.
+     
+     @param eventType The type of event to listen for.
+    */
+    func rx_observeSingleEventOfType(eventType: FIRDataEventType) -> Observable<FIRDataSnapshot> {
+        return Observable.create { observer in
+            self.observeSingleEventOfType(eventType, withBlock: { (snapshot) in
+                observer.onNext(snapshot)
+                observer.onCompleted()
+            })
+            
+            return NopDisposable.instance
+        }
+    }
+    
+    /**
+     This is equivalent to rx_observeWithSiblingKey(), except the observer is immediately 
+     canceled after the initial data is returned.
+     
+     @param eventType The type of event to listen for.
+    */
+    func rx_observeSingleEventOfTypeWithSiblingKey(eventType: FIRDataEventType) -> Observable<(FIRDataSnapshot, String?)> {
+        return Observable.create { observer in
+            self.observeSingleEventOfType(eventType, andPreviousSiblingKeyWithBlock: { (snapshot, string) in
+                observer.onNext((snapshot, string))
+                observer.onCompleted()
+            })
+            return NopDisposable.instance
+        }
+    }
 }
 
 extension FIRDatabaseReference {
+    /**
+     Update changes the values at the specified paths in the dictionary without 
+     overwriting other keys at this location
+     
+     @param values A dictionary of keys to change and their new values
+    */
     func rx_updateChildValues(values: [String : AnyObject]) -> Observable<FIRDatabaseReference> {
         return Observable.create { observer in
             self.updateChildValues(values, withCompletionBlock: { (error, databaseReference) in

        }
    }
    
    func rx_setValue(value: AnyObject!, priority: AnyObject? = nil) -> Observable<FIRDatabaseReference> {
        return Observable.create { observer in
            self.setValue(value, andPriority: priority, withCompletionBlock: { (error, databaseReference) in

            return NopDisposable.instance
        }
    }
    /**
     Performs an optimistic-concurrency transactional update to the data at this location. Your block will be called with a FIRMutableData
     instance that contains the current data at this location. Your block should update this data to the value you
     wish to write to this location, and then return an instance of FIRTransactionResult with the new data.
     
     If, when the operation reaches the server, it turns out that this client had stale data, your block will be run again with the latest data from the server.
     
     When your block is run, you may decide to aport the traansaction by return FIRTransactionResult.abort()
     
     @param block This block receives the current data at this location and must return an instance of FIRTransactionResult
    */
    func rx_runTransactionBlock(block: ((FIRMutableData!) -> FIRTransactionResult)!) -> Observable<(isCommitted: Bool, snapshot: FIRDataSnapshot?)> {
        return Observable.create { observer in
            self.runTransactionBlock(block, andCompletionBlock: { (error, isCommitted, snapshot) in
