     queue: DispatchQueue? = nil,
     responseSerializer: Serializer
   )
-    -> Single<Serializer.SerializedObject>
+    -> Observable<Serializer.SerializedObject>
   {
     return responseSerialized(queue: queue, responseSerializer: responseSerializer)
-      .flatMap { response -> Single<Serializer.SerializedObject> in
-        switch response.result {
-        case .success(let r):   return .just(r)
-        case .failure(let e):   return .error(e)
+      .map {
+        guard let value = $0.value else {
+          throw RxAlamofireUnknownError
         }
+        return value
       }
   }
 }

    queue: DispatchQueue? = nil,
    responseSerializer: Serializer
  )
    -> Single<DownloadResponse<Serializer.SerializedObject>>
  {
    return Single.create { cb in
      let request = self.base.response(
        queue: queue,
        responseSerializer: responseSerializer
      ) {
        cb(.success($0))
      }
        
      return Disposables.create(with: request.cancel)
    }
  }


extension Reactive where Base: DownloadRequest {
    
  public func response() -> Observable<DefaultDownloadResponse> {
    return Observable.create { observer in
      let request = self.base.response { response in
        if let error = response.error {
          observer.onError(error)
        } else {
          observer.onNext(response)
          observer.onCompleted()
        }
      }
      return Disposables.create(with: request.cancel)
    }
