 public extension Alamofire.Request
 {
     /**
-     Adds a handler that attempts to parse the result of the request into type **T** using **parsingHandler**
-     
-     - parameter completionHandler:A closure that is invoked when the request is finished and *parsingHandler* has been executed
-     - parameter parsingHandler:A closure takes the JSON data as input and outputs the parsed data of type **T**
-     
-     - returns: The request
-     */
-    
-    public func response<T>(completionHandler: (ApiResult<T>) -> Void, parsingHandler: (( data: AnyObject? ) -> T?)?) -> Self {
-        return validate().responseJSON(completionHandler: { (response) -> Void in
-            Parser.parse(response: response, completionHandler: completionHandler, parsingHandler: parsingHandler)
-        })
-    }
-    
-    /**
      Adds a handler that attempts to parse the result of the request into a **Serializable**
      
      - parameter completionHandler:A closure that is invoked when the request is finished

     - returns: The request
     */
    
    public func responseSerializable<T:Serializable>(completionHandler: ApiResult<[T]> -> Void, unwrapper:Parser.Unwrapper = Parser.defaultUnwrapper) -> Self {
        return validate().responseJSON(completionHandler: { (response) -> Void in
            Parser.parse(response: response, completionHandler: completionHandler, unwrapper: unwrapper)
        })
    }
    
    /**
     Adds a handler that ignores the response data of the request, invoking the completion handler with 
     a ApiResult without associated success data.
     
     - parameter completionHandler:A closure that is invoked when the request is finished
     
     - returns: The request
     */
    
    public func response(completionHandler: ApiResult<Void> -> Void) -> Self {
        return validate().responseVoid(completionHandler)
    }
    
    private func responseVoid(completionHandler: ApiResult<Void> -> Void) -> Self {
        return validate().response(completionHandler: { (request, response, data, error) -> Void in
            
            if error == nil {
                completionHandler(ApiResult.Success(data: ()))
            } else {
                
                let error = error ?? NSError(domain: "Serializable.Parser", code: -1, userInfo: nil)
                
                let rawResponse:String
                if let data = data {
                    rawResponse = NSString(data: data, encoding: NSUTF8StringEncoding) as? String ?? ""
                } else {
                    rawResponse = "-"
                }
                
                completionHandler(ApiResult.Error(error:Parser.Error.init(error: error, response: response, rawResponse: rawResponse, request: request))
                )
            }
        })
    }
}


public struct Parser {
    public static let APICallSucceededNotification = "APICallSucceededNotification"
}

public extension Parser {
    
    /**
     Parse any generic object using the parsing handler.
     */
    
    internal static func serializer<T>(parsingHandler parsingHandler: (( data: AnyObject? ) -> T?)?) -> ResponseSerializer<T, NSError> {
        return ResponseSerializer<T, NSError> { (request, response, data, error) -> Result<T, NSError> in
            
            let JSONResponseSerializer = Request.JSONResponseSerializer(options: .AllowFragments)
            let result = JSONResponseSerializer.serializeResponse(request, response, data, error)
            
            switch result {
            case let .Success(value):
                if let parsedObject: T = parsingHandler?( data: value ) {
                    NSNotificationCenter.defaultCenter().postNotificationName(APICallSucceededNotification, object: nil)
                    return .Success(parsedObject)
                } else {
                    return .Failure(NSError(domain: "Serializable.Parser", code: 2048, userInfo: [ NSLocalizedDescriptionKey : "Parsing block failed!"]))
                }
                
            case let .Failure(error):
                return .Failure(error)
            }
        }
    }
    
    typealias Unwrapper = ((sourceDictionary: NSDictionary, expectedType:Any) -> AnyObject?)
    
    /**
     The default unwrapper. First checks for field with name of model, then a "data" field, then lastly passing the source dictionary straight through.
     */
    
    public static let defaultUnwrapper:Unwrapper = { (sourceDictionary, type) in
