             
             return emptyValue
         }
-        
-       /* do {
-            return try decoder.decode(T.self, from: data)
-        } catch {
-            throw AFError.responseSerializationFailed(reason: .decodingFailed(error: error))
-        } */
-        
+    
         let JSONObject = processResponse(request: request, response: response, data: data, keyPath: keyPath)
         
         if let JSONObject = JSONObject,

    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> [T] {
        guard error == nil else { throw error! }
        
        /* return DataResponseSerializer { request, response, data, error in
         if let error = checkResponseForError(request: request, response: response, data: data, error: error){
         return .failure(error)
         }
         
         let JSONObject = processResponse(request: request, response: response, data: data, keyPath: keyPath)
         
         if let JSONObject = JSONObject,
         let parsedObject = (try? Mapper<T>(context: context, shouldIncludeNilValues: false).map(JSONObject: JSONObject)){
         return .success(parsedObject)
         }
         
         let failureReason = "ObjectMapper failed to serialize response."
         let error = newError(.dataSerializationFailed, failureReason: failureReason)
         return .failure(error)
         } */
        
        
        guard let data = data, !data.isEmpty else {
            guard emptyResponseAllowed(forRequest: request, response: response) else {
                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
            }
            
            // TODO - Response JSON Decodable Array
            guard let emptyValue = Empty.value as? [T] else {
                throw AFError.responseSerializationFailed(reason: .invalidEmptyResponse(type: "\(T.self)"))
            }
            
            return emptyValue
        }
        
        /* do {
         return try decoder.decode(T.self, from: data)
         } catch {
         throw AFError.responseSerializationFailed(reason: .decodingFailed(error: error))
         } */
        
        
        if let JSONObject = processResponse(request: request, response: response, data: data, keyPath: keyPath){
            

    public static func ObjectMapperArraySerializer<T: BaseMappable>(_ keyPath: String?, context: MapContext? = nil) -> MappableArrayResponseSerializer<T> {
        
        return MappableArrayResponseSerializer(keyPath, context: context)
    }
    
    /// ImmutableMappable Array Serializer
    public static func ObjectMapperImmutableArraySerializer<T: ImmutableMappable>(_ keyPath: String?, context: MapContext? = nil) -> ImmutableMappableArrayResponseSerializer<T> {
        return ImmutableMappableArrayResponseSerializer(keyPath, context: context)
    }
    
    /**
