         
         let endPoint: String = warp.generateEndpoint(.users(id: nil))
         
-        let request = Warp.API.get(endPoint, parameters: queryBuilder.query(queryConstraints).param, headers: warp.HEADER())
+        let request = Warp.API.get(endPoint, parameters: self.queryBuilder.dictionary, headers: warp.HEADER())
         
         _ = request.warpResponse { (warpResult) in
             switch warpResult {

// MARK: - Query Functions
public extension Warp.Query {
    public func limit(_ value: Int) -> Warp.Query<Class> {
        self.queryBuilder.param["limit"] = value
        return self
    }
    
    public func skip(_ value: Int) -> Warp.Query<Class> {
        self.queryBuilder.param["skip"] = value
        return self
    }
    
    public func include(_ values: String...) -> Warp.Query<Class> {
        self.queryBuilder.param["include"] = String(describing: values) as Any?
        return self
    }
    
    public func sort(_ values: WarpSort...) -> Warp.Query<Class> {
        var string: String = ""
        values.enumerated().forEach { (i, value) in
            string = string + "{\"\(value.key)\": \(value.order.rawValue)}"
            if values.count > 1 && i != values.count - 1 {
                string = string + ", "
            }
        }
        self.queryBuilder.param["sort"] = "[\(string)]"
        return self
    }
    
    public func equalTo(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(equalTo: value, key: key))
        return self
    }
    
    public func notEqualTo(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(notEqualTo: value, key: key))
        return self
    }
    
    public func lessThan(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(lessThan: value, key: key))
        return self
    }
    
    public func lessThanOrEqualTo(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(lessThanOrEqualTo: value, key: key))
        return self
    }
    
    public func greaterThanOrEqualTo(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(greaterThanOrEqualTo: value, key: key))
        return self
    }
    
    public func greaterThan(_ value: Any, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(greaterThan: value, key: key))
        return self
    }
    
    public func existsKey(_ key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(existsKey: key))
        return self
    }
    
    public func notExistsKey(_ key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(notExistsKey: key))
        return self
    }
    
    public func containedIn(_ values: Any..., forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(containedIn: values, key: key))
        return self
    }
    
    public func notContainedIn(_ values:[Any], forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(notContainedIn: values, key: key))
        return self
    }
    
    public func startsWith(_ value: String, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(startsWith: value, key: key))
        return self
    }
    
    public func endsWith(_ value: String, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(endsWith: value, key: key))
        return self
    }
    
    public func contains(_ value: String, forKey key: String) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(contains: value, key: key))
        return self
    }
    
    public func contains(_ value: String, keys: String...) -> Warp.Query<Class> {
        self.queryConstraints.append(WarpQueryConstraint(contains: value, keys: keys))
        return self
    }
}

        
        let endPoint: String = warp.generateEndpoint(.classes(className: self.className, id: objectId))
        
        let request = Warp.API.get(endPoint, parameters: self.queryBuilder.dictionary, headers: warp.HEADER())
        
        _ = request.warpResponse { (warpResult) in
            switch warpResult {
