         }
     }
     
-    case valEquals(key: String, val: AQTValue)
-//    case typeEquals(key: String, type: AQTType)
-    case valNotEquals(key: String, val: AQTValue)
-//    case typeNotEquals(key: String, type: AQTType)
-    
-    case greaterThan(key: String, val: AQTValue)
-    case greaterThanOrEqual(key: String, val: AQTValue)
-    case smallerThan(key: String, val: AQTValue)
-    case smallerThanOrEqual(key: String, val: AQTValue)
-    
+    /// Whether the type in `key` is equal to the AQTType https://docs.mongodb.com/manual/reference/operator/query/type/#op._S_type
+    case typeof(key: String, type: AQTType)
+    
+    /// Does the `Value` within the `key` match this `Value`
+    case valEquals(key: String, val: ValueProtocol)
+    
+    /// The `Value` within the `key` does not match this `Value`
+    case valNotEquals(key: String, val: ValueProtocol)
+    
+    /// Whether the `Value` within the `key` is greater than this `Value`
+    case greaterThan(key: String, val: ValueProtocol)
+    
+    /// Whether the `Value` within the `key` is greater than or equal to this `Value`
+    case greaterThanOrEqual(key: String, val: ValueProtocol)
+    
+    /// Whether the `Value` within the `key` is smaller than this `Value`
+    case smallerThan(key: String, val: ValueProtocol)
+    
+    /// Whether the `Value` within the `key` is smaller than or equal to this `Value`
+    case smallerThanOrEqual(key: String, val: ValueProtocol)
+    
+    /// Whether all `AQT` Conditions are correct
     case and([AQT])
+    
+    /// Whether any of these `AQT` conditions is correct
     case or([AQT])
+    
+    /// Whether none of these `AQT` conditions are correct
     case not(AQT)
+    
+    /// Whether nothing needs to be matched. Is always true and just a placeholder
     case nothing
 }
 
+/// The protocol all queries need to comply to
 public protocol QueryProtocol {
+    /// They need to return a `Document` that will be used for matching
     var data: Document { get }
 }
 
+/// A `Query` that consists of an `AQT` statement
 public struct Query: QueryProtocol {
+    /// The `Document` that can be sent to the MongoDB Server as a query/filter
     public var data: Document {
         return aqt.document
     }
     
+    /// The `AQT` statement that's used as a query/filter
     public var aqt: AQT
     
+    /// Initializes a `Query` with an `AQT` filter
     public init(aqt: AQT) {
         self.aqt = aqt
     }
 }
 
+/// Makes a raw `Document` usable as `Query`
 extension Document: QueryProtocol {
+    /// Makes a raw `Document` usable as `Query`
     public var data: Document {
         return self
     }
 }
 
 extension Document {
+    /// Filters the operators so that it's cleaner to compare Documents
+    /// 
+    /// TODO: Make this not necessary any more by improving the `on` event listener
     private func filterOperators() -> Document {
         var doc: Document = [:]
         

import BSON

// MARK: Equations
/// Equals
public func ==(key: String, pred: ValueConvertible) -> Query {
    return Query(aqt: .valEquals(key: key, val: ~pred))

        return doc
    }
    
    /// Checks if a `Document` matches the given `Query`
    /// 
    /// - parameter query: The `Query` to match this `Document` against
    ///
    /// - returns: Whether this `Document` matches the `Query`
    public func matches(query: Query) -> Bool {
        let doc = self.filterOperators()
        
        switch query.aqt {
        case .typeof(let key, let type):
            return doc[key].typeNumber == type.rawValue
        case .valEquals(let key, let val):
            return doc[key] == val.val
        case .valNotEquals(let key, let val):
