 /**
  *  The delegate callbacks which allow the host app to receive all possible results from the component using a generic decodable type.
  */
-public protocol HPPSwiftManagerDelegate: class {
+public protocol GenericHPPManagerDelegate: class {
     
     associatedtype PaymentServiceResponse: Decodable
-    func HPPSwiftManagerCompletedWithResult(_ result: PaymentServiceResponse)
-    func HPPSwiftManagerFailedWithError(_ error: Error?)
-    func HPPSwiftManagerCancelled()
+    func HPPManagerCompletedWithResult(_ result: PaymentServiceResponse)
+    func HPPManagerFailedWithError(_ error: Error?)
+    func HPPManagerCancelled()
     
 }
 
 /**
  *  A type-erased implementer of the `HPPSwiftManagerDelegate` protocol
  */
-fileprivate class AnyHPPSwiftManagerDelegate<T: Decodable>: HPPSwiftManagerDelegate {
+fileprivate class AnyGenericHPPManagerDelegate<T: Decodable>: GenericHPPManagerDelegate {
     
     private let completed: (T) -> Void
     private let failed: (Error?) -> Void
     private let cancelled: () -> Void
     
-    init<D: HPPSwiftManagerDelegate>(_ delegate: D) where D.PaymentServiceResponse == T {
-        self.completed = { [weak delegate] in delegate?.HPPSwiftManagerCompletedWithResult($0) }
-        self.failed = { [weak delegate] in delegate?.HPPSwiftManagerFailedWithError($0) }
-        self.cancelled = { [weak delegate] in delegate?.HPPSwiftManagerCancelled() }
-    }
-    
-    public func HPPSwiftManagerCompletedWithResult(_ result: T) {
+    init<D: GenericHPPManagerDelegate>(_ delegate: D) where D.PaymentServiceResponse == T {
+        self.completed = { [weak delegate] in delegate?.HPPManagerCompletedWithResult($0) }
+        self.failed = { [weak delegate] in delegate?.HPPManagerFailedWithError($0) }
+        self.cancelled = { [weak delegate] in delegate?.HPPManagerCancelled() }
+    }
+    
+    public func HPPManagerCompletedWithResult(_ result: T) {
         self.completed(result)
     }
     
-    public func HPPSwiftManagerFailedWithError(_ error: Error?) {
+    public func HPPManagerFailedWithError(_ error: Error?) {
         self.failed(error)
     }
     
-    public func HPPSwiftManagerCancelled() {
+    public func HPPManagerCancelled() {
         self.cancelled()
     }
     

            else {
                // error
                self.delegate?.HPPManagerFailedWithError?(error as NSError?)
                self.swiftPrivateDelegate?.HPPSwiftManagerFailedWithError(error)
                self.hppViewController.dismiss(animated: true, completion: nil)
                return
            }
            
            // success
            self.delegate?.HPPManagerCompletedWithResult?(decodedResponse as! Dictionary <String, String>)
            self.swiftPrivateDelegate?.HPPSwiftManagerCompletedWithResult(decodedResponse)
        })
        dataTask.resume()


                // error
                UIApplication.shared.isNetworkActivityIndicatorVisible = false
                self.delegate?.HPPManagerFailedWithError!(error as NSError)
                self.genericDelegate?.HPPManagerFailedWithError(error)
                self.hppViewController.dismiss(animated: true, completion: nil)
            }
        })
