 
 //MARK: - NOParsing stuff
 
-public extension Request
+public extension Alamofire.Request
 {
     
-    public func JSONParse<T>(completionHandler: (ApiResult<T>) -> Void, parsingHandler: (( data: AnyObject? ) -> T?)?) -> Self {
+    public func respnseSerializable<T>(completionHandler: (ApiResult<T>) -> Void, parsingHandler: (( data: AnyObject? ) -> T?)?) -> Self {
         return validate().responseJSON(completionHandler: { (response) -> Void in
-            Harbor.nodesParse(response: response, completionHandler: completionHandler, parsingHandler: parsingHandler)
+            Parser.parse(response: response, completionHandler: completionHandler, parsingHandler: parsingHandler)
         })
     }
     
-    public func JSONParse<T:Serializable>(completionHandler: ApiResult<T> -> Void) -> Self {
+    public func respnseSerializable<T:Serializable>(completionHandler: ApiResult<T> -> Void) -> Self {
         return validate().responseJSON(completionHandler: { (response) -> Void in
-            Harbor.nodesParse(response: response, completionHandler: completionHandler)
+            Parser.parse(response: response, completionHandler: completionHandler)
         })
     }
     
-    public func JSONParse<T:Serializable>(completionHandler: ApiResult<[T]> -> Void) -> Self {
+    public func respnseSerializable<T:Serializable>(completionHandler: ApiResult<[T]> -> Void) -> Self {
         return validate().responseJSON(completionHandler: { (response) -> Void in
-            Harbor.nodesParse(response: response, completionHandler: completionHandler)
+            Parser.parse(response: response, completionHandler: completionHandler)
         })
     }
     
-    public func JSONParse(completionHandler: ApiResult<Void> -> Void) -> Self {
-        return validate().voidParse(completionHandler)
+    public func respnseSerializable(completionHandler: ApiResult<Void> -> Void) -> Self {
+        return validate().responseVoid(completionHandler)
     }
     
-    internal func voidParse(completionHandler: ApiResult<Void> -> Void) -> Self {
+    public func responseVoid(completionHandler: ApiResult<Void> -> Void) -> Self {
         return validate().response(completionHandler: { (request, response, data, error) -> Void in
             
             if error == nil {

                rawResponse = nil
            }
            let unwrappedError = error as NSError ?? NSError(domain: "Harbor", code: 2048, userInfo: [ NSLocalizedDescriptionKey : "Nodes parsing block failed!"])
            return Harbor.Error.init(error: unwrappedError, response: self.response, rawResponse: rawResponse, request: self.request)
        default:
            return Harbor.Error.init(error: nil, response: nil, rawResponse: nil, request: nil)
        }
    }
}

public extension Harbor {
    
    public static func nodesParse<T,S>(response response:Response<S, NSError>, completionHandler: (ApiResult<T>) -> Void, parsingHandler: (( data: AnyObject? ) -> T?)?) {
        switch response.result {
        case let Result.Success(value):
            if let parsedObject: T = parsingHandler?( data: value as? AnyObject ) {
                NSNotificationCenter.defaultCenter().postNotificationName(APICallSucceededNotification, object: nil)
                completionHandler(ApiResult.Success(data: parsedObject));
            } else {
                completionHandler(ApiResult.Error(error:response.harborError()))
            }
            
        case Result.Failure:
            completionHandler(ApiResult.Error(error:response.harborError()))
            break;
        }
    }
    
    public static func nodesParse<T:Serializable,S>(response response:Response<S, NSError>, completionHandler: ApiResult<T> -> Void) {
        nodesParse(response:response, completionHandler: completionHandler, parsingHandler: {
            ( data: AnyObject? ) -> T? in
            
            if let sourceDictionary = data as? [String : AnyObject] {

    }
}

/* Unfortunately, this has to be in global scope since Swift currently (v2.2) does not support nested generic types */
public enum ApiResult<T> {
    case Success(data:T)
    case Error(error:Parser.Error)
}

public extension Alamofire.Response {
    func serializableParserError() -> Parser.Error {
        switch self.result {
        case .Failure(let error):
            var rawResponse:AnyObject?
