Bug: [FEATURE] [DEUTSCHEBANK] Integrate SEPA Payments



### Feature Description

Integrate SEPA Payments for connector Deutsche Bank

### Possible Implementation

https://testmerch.directpos.de/rest-api/apidoc/v2.1/index.html#chap_sdd

### Have you spent some time checking if this feature request has been raised before?

- [X] I checked and didn't find a similar issue

### Have you read the Contributing Guidelines?

- [X] I have read the [Contributing Guidelines](https://github.com/juspay/hyperswitch/blob/main/docs/CONTRIBUTING.md)

### Are you willing to submit a PR?

Yes, I am willing to submit a PR!
diff --git a/api-reference-v2/openapi_spec.json b/api-reference-v2/openapi_spec.json
index bda5fab29c0..acff517e107 100644
--- a/api-reference-v2/openapi_spec.json
+++ b/api-reference-v2/openapi_spec.json
@@ -4979,6 +4979,7 @@
           "cryptopay",
           "cybersource",
           "datatrans",
+          "deutschebank",
           "dlocal",
           "ebanx",
           "fiserv",
@@ -17213,6 +17214,7 @@
           "cryptopay",
           "cybersource",
           "datatrans",
+          "deutschebank",
           "dlocal",
           "ebanx",
           "fiserv",
diff --git a/config/config.example.toml b/config/config.example.toml
index 4c543fbdec3..7059626f8cf 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -201,7 +201,7 @@ coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
@@ -411,6 +411,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi = { payment_method = "card" }
 payme = { payment_method = "card" }
+deutschebank = { payment_method = "bank_debit" }
 
 [dummy_connector]
 enabled = true                                  # Whether dummy connector is enabled or not
diff --git a/config/deployments/integration_test.toml b/config/deployments/integration_test.toml
index 4f109fc612c..90d29a6992d 100644
--- a/config/deployments/integration_test.toml
+++ b/config/deployments/integration_test.toml
@@ -43,7 +43,7 @@ coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
@@ -346,6 +346,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi.payment_method = "card"
 payme.payment_method = "card"
+deutschebank = { payment_method = "bank_debit" }
 
 #tokenization configuration which describe token lifetime and payment method for specific connector
 [tokenization]
diff --git a/config/deployments/production.toml b/config/deployments/production.toml
index 9c387aa10af..0443d191542 100644
--- a/config/deployments/production.toml
+++ b/config/deployments/production.toml
@@ -48,7 +48,7 @@ cryptopay.base_url = "https://business.cryptopay.me/"
 cybersource.base_url = "https://api.cybersource.com/"
 datatrans.base_url = "https://api.datatrans.com/"
 dlocal.base_url = "https://sandbox.dlocal.com/"
-deutschebank.base_url = "https://merch.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://merch.directpos.de/rest-api"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
 fiserv.base_url = "https://cert.api.fiservapps.com/"
@@ -359,6 +359,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi.payment_method = "card"
 payme.payment_method = "card"
+deutschebank = { payment_method = "bank_debit" }
 
 #tokenization configuration which describe token lifetime and payment method for specific connector
 [tokenization]
diff --git a/config/deployments/sandbox.toml b/config/deployments/sandbox.toml
index 706bcb6e1b9..8c679241729 100644
--- a/config/deployments/sandbox.toml
+++ b/config/deployments/sandbox.toml
@@ -48,7 +48,7 @@ cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
 dlocal.base_url = "https://sandbox.dlocal.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
 fiserv.base_url = "https://cert.api.fiservapps.com/"
@@ -363,6 +363,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi.payment_method = "card"
 payme.payment_method = "card"
+deutschebank = { payment_method = "bank_debit" }
 
 #tokenization configuration which describe token lifetime and payment method for specific connector
 [tokenization]
diff --git a/config/development.toml b/config/development.toml
index 0b6c1c76909..1c6a4a827f3 100644
--- a/config/development.toml
+++ b/config/development.toml
@@ -210,7 +210,7 @@ coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
@@ -538,6 +538,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi = { payment_method = "card" }
 payme = { payment_method = "card" }
+deutschebank = { payment_method = "bank_debit" }
 
 [connector_customer]
 connector_list = "gocardless,stax,stripe"
diff --git a/config/docker_compose.toml b/config/docker_compose.toml
index bc1be36f82c..704acdfee14 100644
--- a/config/docker_compose.toml
+++ b/config/docker_compose.toml
@@ -130,7 +130,7 @@ coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
@@ -317,6 +317,7 @@ bankofamerica = { payment_method = "card" }
 cybersource = { payment_method = "card" }
 nmi = { payment_method = "card" }
 payme = { payment_method = "card" }
+deutschebank = { payment_method = "bank_debit" }
 
 [dummy_connector]
 enabled = true
diff --git a/crates/api_models/src/enums.rs b/crates/api_models/src/enums.rs
index 2826608b639..64af2349f7c 100644
--- a/crates/api_models/src/enums.rs
+++ b/crates/api_models/src/enums.rs
@@ -94,7 +94,7 @@ pub enum Connector {
     Cryptopay,
     Cybersource,
     Datatrans,
-    // Deutschebank,
+    Deutschebank,
     Dlocal,
     Ebanx,
     Fiserv,
@@ -187,6 +187,7 @@ impl Connector {
         matches!(
             (self, payment_method),
             (Self::Airwallex, _)
+                | (Self::Deutschebank, _)
                 | (Self::Globalpay, _)
                 | (Self::Paypal, _)
                 | (Self::Payu, _)
@@ -231,7 +232,7 @@ impl Connector {
             | Self::Cashtocode
             | Self::Coinbase
             | Self::Cryptopay
-			// | Self::Deutschebank
+			| Self::Deutschebank
             | Self::Dlocal
             | Self::Ebanx
             | Self::Fiserv
diff --git a/crates/common_enums/src/enums.rs b/crates/common_enums/src/enums.rs
index b6500d79b84..10c9dae2cc1 100644
--- a/crates/common_enums/src/enums.rs
+++ b/crates/common_enums/src/enums.rs
@@ -208,7 +208,7 @@ pub enum RoutableConnectors {
     Cryptopay,
     Cybersource,
     Datatrans,
-    // Deutschebank,
+    Deutschebank,
     Dlocal,
     Ebanx,
     Fiserv,
diff --git a/crates/connector_configs/src/connector.rs b/crates/connector_configs/src/connector.rs
index fb4d92581ed..3ead246702c 100644
--- a/crates/connector_configs/src/connector.rs
+++ b/crates/connector_configs/src/connector.rs
@@ -171,6 +171,7 @@ pub struct ConnectorConfig {
     pub opennode: Option<ConnectorTomlConfig>,
     pub bambora: Option<ConnectorTomlConfig>,
     pub datatrans: Option<ConnectorTomlConfig>,
+    pub deutschebank: Option<ConnectorTomlConfig>,
     pub dlocal: Option<ConnectorTomlConfig>,
     pub ebanx_payout: Option<ConnectorTomlConfig>,
     pub fiserv: Option<ConnectorTomlConfig>,
@@ -322,6 +323,7 @@ impl ConnectorConfig {
             Connector::Opennode => Ok(connector_data.opennode),
             Connector::Bambora => Ok(connector_data.bambora),
             Connector::Datatrans => Ok(connector_data.datatrans),
+            Connector::Deutschebank => Ok(connector_data.deutschebank),
             Connector::Dlocal => Ok(connector_data.dlocal),
             Connector::Ebanx => Ok(connector_data.ebanx_payout),
             Connector::Fiserv => Ok(connector_data.fiserv),
diff --git a/crates/connector_configs/toml/development.toml b/crates/connector_configs/toml/development.toml
index ef2cf56f31b..41bcb52704a 100644
--- a/crates/connector_configs/toml/development.toml
+++ b/crates/connector_configs/toml/development.toml
@@ -1353,6 +1353,14 @@ api_key="Key"
 key1="Merchant ID"
 api_secret="Shared Secret"
 
+[deutschebank]
+[[deutschebank.bank_debit]]
+  payment_method_type = "sepa"
+[deutschebank.connector_auth.SignatureKey]
+api_key="Client ID"
+key1="Merchant ID"
+api_secret="Client Key"
+
 [dlocal]
 [[dlocal.credit]]
   payment_method_type = "Mastercard"
diff --git a/crates/connector_configs/toml/production.toml b/crates/connector_configs/toml/production.toml
index c7e55ca7a79..8d6d2d3a5c6 100644
--- a/crates/connector_configs/toml/production.toml
+++ b/crates/connector_configs/toml/production.toml
@@ -1125,6 +1125,14 @@ placeholder="Enter Acquirer Country Code"
 required=false
 type="Text"
 
+[deutschebank]
+[[deutschebank.bank_debit]]
+  payment_method_type = "sepa"
+[deutschebank.connector_auth.SignatureKey]
+api_key="Client ID"
+key1="Merchant ID"
+api_secret="Client Key"
+
 [dlocal]
 [[dlocal.credit]]
   payment_method_type = "Mastercard"
diff --git a/crates/connector_configs/toml/sandbox.toml b/crates/connector_configs/toml/sandbox.toml
index 9d44f76970f..165682b7501 100644
--- a/crates/connector_configs/toml/sandbox.toml
+++ b/crates/connector_configs/toml/sandbox.toml
@@ -1352,6 +1352,14 @@ api_key="Key"
 key1="Merchant ID"
 api_secret="Shared Secret"
 
+[deutschebank]
+[[deutschebank.bank_debit]]
+  payment_method_type = "sepa"
+[deutschebank.connector_auth.SignatureKey]
+api_key="Client ID"
+key1="Merchant ID"
+api_secret="Client Key"
+
 [dlocal]
 [[dlocal.credit]]
   payment_method_type = "Mastercard"
diff --git a/crates/hyperswitch_connectors/src/connectors/deutschebank.rs b/crates/hyperswitch_connectors/src/connectors/deutschebank.rs
index 3d7e55c3a90..30e67babe89 100644
--- a/crates/hyperswitch_connectors/src/connectors/deutschebank.rs
+++ b/crates/hyperswitch_connectors/src/connectors/deutschebank.rs
@@ -1,27 +1,36 @@
 pub mod transformers;
 
+use std::time::SystemTime;
+
+use actix_web::http::header::Date;
+use base64::Engine;
+use common_enums::enums;
 use common_utils::{
     errors::CustomResult,
     ext_traits::BytesExt,
     request::{Method, Request, RequestBuilder, RequestContent},
-    types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
+    types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
 };
 use error_stack::{report, ResultExt};
 use hyperswitch_domain_models::{
     router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
     router_flow_types::{
         access_token_auth::AccessTokenAuth,
-        payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
+        payments::{
+            Authorize, Capture, CompleteAuthorize, PSync, PaymentMethodToken, Session,
+            SetupMandate, Void,
+        },
         refunds::{Execute, RSync},
     },
     router_request_types::{
-        AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
-        PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
-        RefundsData, SetupMandateRequestData,
+        AccessTokenRequestData, CompleteAuthorizeData, PaymentMethodTokenizationData,
+        PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData,
+        PaymentsSyncData, RefundsData, SetupMandateRequestData,
     },
     router_response_types::{PaymentsResponseData, RefundsResponseData},
     types::{
-        PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
+        PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
+        PaymentsCompleteAuthorizeRouterData, PaymentsSyncRouterData, RefreshTokenRouterData,
         RefundSyncRouterData, RefundsRouterData,
     },
 };
@@ -33,20 +42,26 @@ use hyperswitch_interfaces::{
     types::{self, Response},
     webhooks,
 };
-use masking::{ExposeInterface, Mask};
+use masking::{ExposeInterface, Mask, Secret};
+use rand::distributions::{Alphanumeric, DistString};
+use ring::hmac;
 use transformers as deutschebank;
 
-use crate::{constants::headers, types::ResponseRouterData, utils};
+use crate::{
+    constants::headers,
+    types::ResponseRouterData,
+    utils::{self, PaymentsCompleteAuthorizeRequestData, RefundsRequestData},
+};
 
 #[derive(Clone)]
 pub struct Deutschebank {
-    amount_converter: &'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
+    amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
 }
 
 impl Deutschebank {
     pub fn new() -> &'static Self {
         &Self {
-            amount_converter: &StringMinorUnitForConnector,
+            amount_converter: &MinorUnitForConnector,
         }
     }
 }
@@ -56,6 +71,7 @@ impl api::PaymentSession for Deutschebank {}
 impl api::ConnectorAccessToken for Deutschebank {}
 impl api::MandateSetup for Deutschebank {}
 impl api::PaymentAuthorize for Deutschebank {}
+impl api::PaymentsCompleteAuthorize for Deutschebank {}
 impl api::PaymentSync for Deutschebank {}
 impl api::PaymentCapture for Deutschebank {}
 impl api::PaymentVoid for Deutschebank {}
@@ -79,10 +95,20 @@ where
         req: &RouterData<Flow, Request, Response>,
         _connectors: &Connectors,
     ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
-        let mut header = vec![(
-            headers::CONTENT_TYPE.to_string(),
-            self.get_content_type().to_string().into(),
-        )];
+        let access_token = req
+            .access_token
+            .clone()
+            .ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
+        let mut header = vec![
+            (
+                headers::CONTENT_TYPE.to_string(),
+                self.get_content_type().to_string().into(),
+            ),
+            (
+                headers::AUTHORIZATION.to_string(),
+                format!("Bearer {}", access_token.token.expose()).into_masked(),
+            ),
+        ];
         let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
         header.append(&mut api_key);
         Ok(header)
@@ -96,9 +122,6 @@ impl ConnectorCommon for Deutschebank {
 
     fn get_currency_unit(&self) -> api::CurrencyUnit {
         api::CurrencyUnit::Base
-        //    TODO! Check connector documentation, on which unit they are processing the currency.
-        //    If the connector accepts amount in lower unit ( i.e cents for USD) then return api::CurrencyUnit::Minor,
-        //    if connector accepts amount in base unit (i.e dollars for USD) then return api::CurrencyUnit::Base
     }
 
     fn common_get_content_type(&self) -> &'static str {
@@ -116,8 +139,8 @@ impl ConnectorCommon for Deutschebank {
         let auth = deutschebank::DeutschebankAuthType::try_from(auth_type)
             .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
         Ok(vec![(
-            headers::AUTHORIZATION.to_string(),
-            auth.api_key.expose().into_masked(),
+            headers::MERCHANT_ID.to_string(),
+            auth.merchant_id.expose().into_masked(),
         )])
     }
 
@@ -136,9 +159,9 @@ impl ConnectorCommon for Deutschebank {
 
         Ok(ErrorResponse {
             status_code: res.status_code,
-            code: response.code,
-            message: response.message,
-            reason: response.reason,
+            code: response.rc,
+            message: response.message.clone(),
+            reason: Some(response.message),
             attempt_status: None,
             connector_transaction_id: None,
         })
@@ -146,20 +169,124 @@ impl ConnectorCommon for Deutschebank {
 }
 
 impl ConnectorValidation for Deutschebank {
-    //TODO: implement functions when support enabled
+    fn validate_capture_method(
+        &self,
+        capture_method: Option<enums::CaptureMethod>,
+        _pmt: Option<enums::PaymentMethodType>,
+    ) -> CustomResult<(), errors::ConnectorError> {
+        let capture_method = capture_method.unwrap_or_default();
+        match capture_method {
+            enums::CaptureMethod::Automatic | enums::CaptureMethod::Manual => Ok(()),
+            enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => Err(
+                utils::construct_not_implemented_error_report(capture_method, self.id()),
+            ),
+        }
+    }
 }
 
 impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Deutschebank {
     //TODO: implement sessions flow
 }
 
-impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Deutschebank {}
-
 impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
     for Deutschebank
 {
 }
 
+impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Deutschebank {
+    fn get_url(
+        &self,
+        _req: &RefreshTokenRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        Ok(format!("{}/security/v1/token", self.base_url(connectors)))
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        "application/x-www-form-urlencoded"
+    }
+
+    fn build_request(
+        &self,
+        req: &RefreshTokenRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, errors::ConnectorError> {
+        let auth = deutschebank::DeutschebankAuthType::try_from(&req.connector_auth_type)?;
+        let client_id = auth.client_id.expose();
+        let date = Date(SystemTime::now().into()).to_string();
+        let random_string = Alphanumeric.sample_string(&mut rand::thread_rng(), 50);
+
+        let string_to_sign = client_id.clone() + &date + &random_string;
+        let key = hmac::Key::new(hmac::HMAC_SHA256, auth.client_key.expose().as_bytes());
+        let client_secret = format!(
+            "V1:{}",
+            common_utils::consts::BASE64_ENGINE
+                .encode(hmac::sign(&key, string_to_sign.as_bytes()).as_ref())
+        );
+
+        let headers = vec![
+            (
+                headers::X_RANDOM_VALUE.to_string(),
+                random_string.into_masked(),
+            ),
+            (headers::X_REQUEST_DATE.to_string(), date.into_masked()),
+            (
+                headers::CONTENT_TYPE.to_string(),
+                types::RefreshTokenType::get_content_type(self)
+                    .to_string()
+                    .into(),
+            ),
+        ];
+
+        let connector_req = deutschebank::DeutschebankAccessTokenRequest {
+            client_id: Secret::from(client_id),
+            client_secret: Secret::from(client_secret),
+            grant_type: "client_credentials".to_string(),
+            scope: "ftx".to_string(),
+        };
+        let body = RequestContent::FormUrlEncoded(Box::new(connector_req));
+
+        let req = Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .headers(headers)
+                .url(&types::RefreshTokenType::get_url(self, req, connectors)?)
+                .set_body(body)
+                .build(),
+        );
+        Ok(req)
+    }
+
+    fn handle_response(
+        &self,
+        data: &RefreshTokenRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<RefreshTokenRouterData, errors::ConnectorError> {
+        let response: deutschebank::DeutschebankAccessTokenResponse = res
+            .response
+            .parse_struct("Paypal PaypalAuthUpdateResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
 impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Deutschebank {
     fn get_headers(
         &self,
@@ -176,9 +303,12 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
     fn get_url(
         &self,
         _req: &PaymentsAuthorizeRouterData,
-        _connectors: &Connectors,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        Ok(format!(
+            "{}/services/v2.1/managedmandate",
+            self.base_url(connectors)
+        ))
     }
 
     fn get_request_body(
@@ -226,7 +356,7 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
-        let response: deutschebank::DeutschebankPaymentsResponse = res
+        let response: deutschebank::DeutschebankMandatePostResponse = res
             .response
             .parse_struct("Deutschebank PaymentsAuthorizeResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -248,6 +378,105 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
     }
 }
 
+impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
+    for Deutschebank
+{
+    fn get_headers(
+        &self,
+        req: &PaymentsCompleteAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &PaymentsCompleteAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let event_id = req.connector_request_reference_id.clone();
+        let tx_action = if req.request.is_auto_capture()? {
+            "authorization"
+        } else {
+            "preauthorization"
+        };
+        Ok(format!(
+            "{}/services/v2.1/payment/event/{event_id}/directdebit/{tx_action}",
+            self.base_url(connectors)
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &PaymentsCompleteAuthorizeRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        let amount = utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount,
+            req.request.currency,
+        )?;
+
+        let connector_router_data = deutschebank::DeutschebankRouterData::from((amount, req));
+        let connector_req =
+            deutschebank::DeutschebankDirectDebitRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
+    }
+
+    fn build_request(
+        &self,
+        req: &PaymentsCompleteAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, errors::ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&types::PaymentsCompleteAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(types::PaymentsCompleteAuthorizeType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PaymentsCompleteAuthorizeRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
+        let response: deutschebank::DeutschebankPaymentsResponse = res
+            .response
+            .parse_struct("Deutschebank PaymentsCompleteAuthorizeResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
 impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Deutschebank {
     fn get_headers(
         &self,
@@ -263,10 +492,18 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Deu
 
     fn get_url(
         &self,
-        _req: &PaymentsSyncRouterData,
-        _connectors: &Connectors,
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let tx_id = req
+            .request
+            .connector_transaction_id
+            .get_connector_transaction_id()
+            .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
+        Ok(format!(
+            "{}/services/v2.1/payment/tx/{tx_id}",
+            self.base_url(connectors)
+        ))
     }
 
     fn build_request(
@@ -292,7 +529,7 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Deu
     ) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
         let response: deutschebank::DeutschebankPaymentsResponse = res
             .response
-            .parse_struct("deutschebank PaymentsSyncResponse")
+            .parse_struct("DeutschebankPaymentsSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -327,18 +564,32 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
 
     fn get_url(
         &self,
-        _req: &PaymentsCaptureRouterData,
-        _connectors: &Connectors,
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let event_id = req.connector_request_reference_id.clone();
+        let tx_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/services/v2.1/payment/event/{event_id}/tx/{tx_id}/capture",
+            self.base_url(connectors)
+        ))
     }
 
     fn get_request_body(
         &self,
-        _req: &PaymentsCaptureRouterData,
+        req: &PaymentsCaptureRouterData,
         _connectors: &Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
+        let amount = utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount_to_capture,
+            req.request.currency,
+        )?;
+
+        let connector_router_data = deutschebank::DeutschebankRouterData::from((amount, req));
+        let connector_req =
+            deutschebank::DeutschebankCaptureRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -389,7 +640,86 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
     }
 }
 
-impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Deutschebank {}
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Deutschebank {
+    fn get_headers(
+        &self,
+        req: &PaymentsCancelRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &PaymentsCancelRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let event_id = req.connector_request_reference_id.clone();
+        let tx_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/services/v2.1/payment/event/{event_id}/tx/{tx_id}/reversal",
+            self.base_url(connectors)
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &PaymentsCancelRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        let connector_req = deutschebank::DeutschebankReversalRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
+    }
+
+    fn build_request(
+        &self,
+        req: &PaymentsCancelRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, errors::ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
+                .set_body(types::PaymentsVoidType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PaymentsCancelRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
+        let response: deutschebank::DeutschebankPaymentsResponse = res
+            .response
+            .parse_struct("Deutschebank PaymentsCancelResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
 
 impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Deutschebank {
     fn get_headers(
@@ -406,10 +736,15 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Deutsch
 
     fn get_url(
         &self,
-        _req: &RefundsRouterData<Execute>,
-        _connectors: &Connectors,
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let event_id = req.attempt_id.clone();
+        let tx_id = req.request.connector_transaction_id.clone();
+        Ok(format!(
+            "{}/services/v2.1/payment/event/{event_id}/tx/{tx_id}/refund",
+            self.base_url(connectors)
+        ))
     }
 
     fn get_request_body(
@@ -455,9 +790,9 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Deutsch
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
-        let response: deutschebank::RefundResponse = res
+        let response: deutschebank::DeutschebankPaymentsResponse = res
             .response
-            .parse_struct("deutschebank RefundResponse")
+            .parse_struct("DeutschebankPaymentsResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -492,10 +827,14 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Deutscheb
 
     fn get_url(
         &self,
-        _req: &RefundSyncRouterData,
-        _connectors: &Connectors,
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let tx_id = req.request.get_connector_refund_id()?;
+        Ok(format!(
+            "{}/services/v2.1/payment/tx/{tx_id}",
+            self.base_url(connectors)
+        ))
     }
 
     fn build_request(
@@ -522,9 +861,9 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Deutscheb
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
-        let response: deutschebank::RefundResponse = res
+        let response: deutschebank::DeutschebankPaymentsResponse = res
             .response
-            .parse_struct("deutschebank RefundSyncResponse")
+            .parse_struct("DeutschebankPaymentsResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
diff --git a/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs b/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
index aca2bd497b6..dc146dc38d4 100644
--- a/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
@@ -1,31 +1,43 @@
+use std::collections::HashMap;
+
 use common_enums::enums;
-use common_utils::types::StringMinorUnit;
+use common_utils::{pii::Email, types::MinorUnit};
 use hyperswitch_domain_models::{
-    payment_method_data::PaymentMethodData,
-    router_data::{ConnectorAuthType, RouterData},
-    router_flow_types::refunds::{Execute, RSync},
-    router_request_types::ResponseId,
-    router_response_types::{PaymentsResponseData, RefundsResponseData},
-    types::{PaymentsAuthorizeRouterData, RefundsRouterData},
+    payment_method_data::{BankDebitData, PaymentMethodData},
+    router_data::{AccessToken, ConnectorAuthType, RouterData},
+    router_flow_types::{
+        payments::{Authorize, Capture, CompleteAuthorize, PSync},
+        refunds::{Execute, RSync},
+    },
+    router_request_types::{
+        CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
+        ResponseId,
+    },
+    router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
+    types::{
+        PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
+        PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
+    },
 };
 use hyperswitch_interfaces::errors;
-use masking::Secret;
+use masking::{PeekInterface, Secret};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    types::{RefundsResponseRouterData, ResponseRouterData},
-    utils::PaymentsAuthorizeRequestData,
+    types::{PaymentsCancelResponseRouterData, RefundsResponseRouterData, ResponseRouterData},
+    utils::{
+        AddressDetailsData, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
+        RefundsRequestData, RouterData as OtherRouterData,
+    },
 };
 
-//TODO: Fill the struct with respective fields
 pub struct DeutschebankRouterData<T> {
-    pub amount: StringMinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
+    pub amount: MinorUnit,
     pub router_data: T,
 }
 
-impl<T> From<(StringMinorUnit, T)> for DeutschebankRouterData<T> {
-    fn from((amount, item): (StringMinorUnit, T)) -> Self {
-        //Todo :  use utils to convert the amount to the type of amount that a connector accepts
+impl<T> From<(MinorUnit, T)> for DeutschebankRouterData<T> {
+    fn from((amount, item): (MinorUnit, T)) -> Self {
         Self {
             amount,
             router_data: item,
@@ -33,20 +45,80 @@ impl<T> From<(StringMinorUnit, T)> for DeutschebankRouterData<T> {
     }
 }
 
-//TODO: Fill the struct with respective fields
+pub struct DeutschebankAuthType {
+    pub(super) client_id: Secret<String>,
+    pub(super) merchant_id: Secret<String>,
+    pub(super) client_key: Secret<String>,
+}
+
+impl TryFrom<&ConnectorAuthType> for DeutschebankAuthType {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
+        match auth_type {
+            ConnectorAuthType::SignatureKey {
+                api_key,
+                key1,
+                api_secret,
+            } => Ok(Self {
+                client_id: api_key.to_owned(),
+                merchant_id: key1.to_owned(),
+                client_key: api_secret.to_owned(),
+            }),
+            _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
+        }
+    }
+}
+
 #[derive(Default, Debug, Serialize, PartialEq)]
-pub struct DeutschebankPaymentsRequest {
-    amount: StringMinorUnit,
-    card: DeutschebankCard,
+pub struct DeutschebankAccessTokenRequest {
+    pub grant_type: String,
+    pub client_id: Secret<String>,
+    pub client_secret: Secret<String>,
+    pub scope: String,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct DeutschebankCard {
-    number: cards::CardNumber,
-    expiry_month: Secret<String>,
-    expiry_year: Secret<String>,
-    cvc: Secret<String>,
-    complete: bool,
+#[derive(Default, Debug, Clone, Deserialize, PartialEq, Serialize)]
+pub struct DeutschebankAccessTokenResponse {
+    pub access_token: Secret<String>,
+    pub expires_in: i64,
+    pub expires_on: i64,
+    pub scope: String,
+    pub token_type: String,
+}
+
+impl<F, T> TryFrom<ResponseRouterData<F, DeutschebankAccessTokenResponse, T, AccessToken>>
+    for RouterData<F, T, AccessToken>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<F, DeutschebankAccessTokenResponse, T, AccessToken>,
+    ) -> Result<Self, Self::Error> {
+        Ok(Self {
+            response: Ok(AccessToken {
+                token: item.response.access_token,
+                expires: item.response.expires_in,
+            }),
+            ..item.data
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum DeutschebankSEPAApproval {
+    Click,
+    Email,
+    Sms,
+    Dynamic,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankPaymentsRequest {
+    approval_by: DeutschebankSEPAApproval,
+    email_address: Email,
+    iban: Secret<String>,
+    first_name: Secret<String>,
+    last_name: Secret<String>,
 }
 
 impl TryFrom<&DeutschebankRouterData<&PaymentsAuthorizeRouterData>>
@@ -56,81 +128,315 @@ impl TryFrom<&DeutschebankRouterData<&PaymentsAuthorizeRouterData>>
     fn try_from(
         item: &DeutschebankRouterData<&PaymentsAuthorizeRouterData>,
     ) -> Result<Self, Self::Error> {
+        let billing_address = item.router_data.get_billing_address()?;
         match item.router_data.request.payment_method_data.clone() {
-            PaymentMethodData::Card(req_card) => {
-                let card = DeutschebankCard {
-                    number: req_card.card_number,
-                    expiry_month: req_card.card_exp_month,
-                    expiry_year: req_card.card_exp_year,
-                    cvc: req_card.card_cvc,
-                    complete: item.router_data.request.is_auto_capture()?,
-                };
-                Ok(Self {
-                    amount: item.amount.clone(),
-                    card,
-                })
-            }
+            PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit { iban, .. }) => Ok(Self {
+                approval_by: DeutschebankSEPAApproval::Click,
+                email_address: item.router_data.request.get_email()?,
+                iban,
+                first_name: billing_address.get_first_name()?.clone(),
+                last_name: billing_address.get_last_name()?.clone(),
+            }),
             _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-// Auth Struct
-pub struct DeutschebankAuthType {
-    pub(super) api_key: Secret<String>,
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum DeutschebankSEPAMandateStatus {
+    Created,
+    PendingApproval,
+    PendingSecondaryApproval,
+    PendingReview,
+    PendingSubmission,
+    Submitted,
+    Active,
+    Failed,
+    Discarded,
+    Expired,
+    Replaced,
 }
 
-impl TryFrom<&ConnectorAuthType> for DeutschebankAuthType {
+impl From<DeutschebankSEPAMandateStatus> for common_enums::AttemptStatus {
+    fn from(item: DeutschebankSEPAMandateStatus) -> Self {
+        match item {
+            DeutschebankSEPAMandateStatus::Active
+            | DeutschebankSEPAMandateStatus::Created
+            | DeutschebankSEPAMandateStatus::PendingApproval
+            | DeutschebankSEPAMandateStatus::PendingSecondaryApproval
+            | DeutschebankSEPAMandateStatus::PendingReview
+            | DeutschebankSEPAMandateStatus::PendingSubmission
+            | DeutschebankSEPAMandateStatus::Submitted => Self::AuthenticationPending,
+            DeutschebankSEPAMandateStatus::Failed
+            | DeutschebankSEPAMandateStatus::Discarded
+            | DeutschebankSEPAMandateStatus::Expired
+            | DeutschebankSEPAMandateStatus::Replaced => Self::Failure,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DeutschebankMandatePostResponse {
+    rc: String,
+    message: String,
+    mandate_id: Option<String>,
+    reference: Option<String>,
+    approval_date: Option<String>,
+    language: Option<String>,
+    approval_by: Option<DeutschebankSEPAApproval>,
+    state: Option<DeutschebankSEPAMandateStatus>,
+}
+
+impl
+    TryFrom<
+        ResponseRouterData<
+            Authorize,
+            DeutschebankMandatePostResponse,
+            PaymentsAuthorizeData,
+            PaymentsResponseData,
+        >,
+    > for RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
+{
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
-        match auth_type {
-            ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
-                api_key: api_key.to_owned(),
+    fn try_from(
+        item: ResponseRouterData<
+            Authorize,
+            DeutschebankMandatePostResponse,
+            PaymentsAuthorizeData,
+            PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        let signed_on = match item.response.approval_date {
+            Some(date) => date.chars().take(10).collect(),
+            None => time::OffsetDateTime::now_utc().date().to_string(),
+        };
+        match item.response.reference {
+            Some(reference) => Ok(Self {
+                status: if item.response.rc == "0" {
+                    match item.response.state {
+                        Some(state) => common_enums::AttemptStatus::from(state),
+                        None => common_enums::AttemptStatus::Failure,
+                    }
+                } else {
+                    common_enums::AttemptStatus::Failure
+                },
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::NoResponseId,
+                    redirection_data: Some(RedirectForm::Form {
+                        endpoint: item.data.request.get_complete_authorize_url()?,
+                        method: common_utils::request::Method::Get,
+                        form_fields: HashMap::from([
+                            ("reference".to_string(), reference),
+                            ("signed_on".to_string(), signed_on),
+                        ]),
+                    }),
+                    mandate_reference: None,
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            }),
+            None => Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                ..item.data
             }),
-            _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
         }
     }
 }
-// PaymentsResponse
-//TODO: Append the remaining status flags
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "lowercase")]
-pub enum DeutschebankPaymentStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+pub struct DeutschebankAmount {
+    amount: MinorUnit,
+    currency: api_models::enums::Currency,
 }
 
-impl From<DeutschebankPaymentStatus> for common_enums::AttemptStatus {
-    fn from(item: DeutschebankPaymentStatus) -> Self {
-        match item {
-            DeutschebankPaymentStatus::Succeeded => Self::Charged,
-            DeutschebankPaymentStatus::Failed => Self::Failure,
-            DeutschebankPaymentStatus::Processing => Self::Authorizing,
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankMeansOfPayment {
+    bank_account: DeutschebankBankAccount,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankBankAccount {
+    account_holder: Secret<String>,
+    iban: Secret<String>,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankMandate {
+    reference: Secret<String>,
+    signed_on: Secret<String>,
+}
+
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankDirectDebitRequest {
+    amount_total: DeutschebankAmount,
+    means_of_payment: DeutschebankMeansOfPayment,
+    mandate: DeutschebankMandate,
+}
+
+impl TryFrom<&DeutschebankRouterData<&PaymentsCompleteAuthorizeRouterData>>
+    for DeutschebankDirectDebitRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &DeutschebankRouterData<&PaymentsCompleteAuthorizeRouterData>,
+    ) -> Result<Self, Self::Error> {
+        let account_holder = item.router_data.get_billing_address()?.get_full_name()?;
+        let redirect_response = item.router_data.request.redirect_response.clone().ok_or(
+            errors::ConnectorError::MissingRequiredField {
+                field_name: "redirect_response",
+            },
+        )?;
+        let queries_params = redirect_response
+            .params
+            .map(|param| {
+                let mut queries = HashMap::<String, String>::new();
+                let values = param.peek().split('&').collect::<Vec<&str>>();
+                for value in values {
+                    let pair = value.split('=').collect::<Vec<&str>>();
+                    queries.insert(
+                        pair.first()
+                            .ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
+                            .to_string(),
+                        pair.get(1)
+                            .ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
+                            .to_string(),
+                    );
+                }
+                Ok::<_, errors::ConnectorError>(queries)
+            })
+            .transpose()?
+            .ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
+        let reference = Secret::from(
+            queries_params
+                .get("reference")
+                .ok_or(errors::ConnectorError::MissingRequiredField {
+                    field_name: "reference",
+                })?
+                .to_owned(),
+        );
+        let signed_on = Secret::from(
+            queries_params
+                .get("signed_on")
+                .ok_or(errors::ConnectorError::MissingRequiredField {
+                    field_name: "signed_on",
+                })?
+                .to_owned(),
+        );
+
+        match item.router_data.request.payment_method_data.clone() {
+            Some(PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit { iban, .. })) => {
+                Ok(Self {
+                    amount_total: DeutschebankAmount {
+                        amount: item.amount,
+                        currency: item.router_data.request.currency,
+                    },
+                    means_of_payment: DeutschebankMeansOfPayment {
+                        bank_account: DeutschebankBankAccount {
+                            account_holder,
+                            iban,
+                        },
+                    },
+                    mandate: {
+                        DeutschebankMandate {
+                            reference,
+                            signed_on,
+                        }
+                    },
+                })
+            }
+            _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum DeutschebankTXAction {
+    Authorization,
+    Capture,
+    Credit,
+    Preauthorization,
+    Refund,
+    Reversal,
+    RiskCheck,
+    #[serde(rename = "verify-mop")]
+    VerifyMop,
+    Payment,
+    AccountInformation,
+}
+
+#[derive(Debug, Deserialize, Serialize, PartialEq)]
+pub struct BankAccount {
+    account_holder: Option<Secret<String>>,
+    bank_name: Option<Secret<String>>,
+    bic: Option<Secret<String>>,
+    iban: Option<Secret<String>>,
+}
+
+#[derive(Debug, Deserialize, Serialize, PartialEq)]
+pub struct TransactionBankAccountInfo {
+    bank_account: Option<BankAccount>,
+}
+
+#[derive(Debug, Deserialize, Serialize, PartialEq)]
+pub struct DeutschebankTransactionInfo {
+    back_state: Option<String>,
+    ip_address: Option<Secret<String>>,
+    #[serde(rename = "type")]
+    pm_type: Option<String>,
+    transaction_bankaccount_info: Option<TransactionBankAccountInfo>,
+}
+
+#[derive(Debug, Deserialize, Serialize, PartialEq)]
 pub struct DeutschebankPaymentsResponse {
-    status: DeutschebankPaymentStatus,
-    id: String,
+    rc: String,
+    message: String,
+    timestamp: String,
+    back_ext_id: Option<String>,
+    back_rc: Option<String>,
+    event_id: Option<String>,
+    kind: Option<String>,
+    tx_action: Option<DeutschebankTXAction>,
+    tx_id: String,
+    amount_total: Option<DeutschebankAmount>,
+    transaction_info: Option<DeutschebankTransactionInfo>,
 }
 
-impl<F, T> TryFrom<ResponseRouterData<F, DeutschebankPaymentsResponse, T, PaymentsResponseData>>
-    for RouterData<F, T, PaymentsResponseData>
+impl
+    TryFrom<
+        ResponseRouterData<
+            CompleteAuthorize,
+            DeutschebankPaymentsResponse,
+            CompleteAuthorizeData,
+            PaymentsResponseData,
+        >,
+    > for RouterData<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: ResponseRouterData<F, DeutschebankPaymentsResponse, T, PaymentsResponseData>,
+        item: ResponseRouterData<
+            CompleteAuthorize,
+            DeutschebankPaymentsResponse,
+            CompleteAuthorizeData,
+            PaymentsResponseData,
+        >,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            status: common_enums::AttemptStatus::from(item.response.status),
+            status: if item.response.rc == "0" {
+                match item.data.request.is_auto_capture()? {
+                    true => common_enums::AttemptStatus::Charged,
+                    false => common_enums::AttemptStatus::Authorized,
+                }
+            } else {
+                common_enums::AttemptStatus::Failure
+            },
             response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(item.response.id),
+                resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
                 redirection_data: None,
                 mandate_reference: None,
                 connector_metadata: None,
@@ -144,87 +450,230 @@ impl<F, T> TryFrom<ResponseRouterData<F, DeutschebankPaymentsResponse, T, Paymen
     }
 }
 
-//TODO: Fill the struct with respective fields
-// REFUND :
-// Type definition for RefundRequest
-#[derive(Default, Debug, Serialize)]
-pub struct DeutschebankRefundRequest {
-    pub amount: StringMinorUnit,
+#[derive(Debug, Serialize, PartialEq)]
+#[serde(rename_all = "UPPERCASE")]
+pub enum DeutschebankTransactionKind {
+    Directdebit,
 }
 
-impl<F> TryFrom<&DeutschebankRouterData<&RefundsRouterData<F>>> for DeutschebankRefundRequest {
+#[derive(Debug, Serialize, PartialEq)]
+pub struct DeutschebankCaptureRequest {
+    changed_amount: MinorUnit,
+    kind: DeutschebankTransactionKind,
+}
+
+impl TryFrom<&DeutschebankRouterData<&PaymentsCaptureRouterData>> for DeutschebankCaptureRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &DeutschebankRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
+    fn try_from(
+        item: &DeutschebankRouterData<&PaymentsCaptureRouterData>,
+    ) -> Result<Self, Self::Error> {
         Ok(Self {
-            amount: item.amount.to_owned(),
+            changed_amount: item.amount,
+            kind: DeutschebankTransactionKind::Directdebit,
         })
     }
 }
 
-// Type definition for Refund Response
-
-#[allow(dead_code)]
-#[derive(Debug, Serialize, Default, Deserialize, Clone)]
-pub enum RefundStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+impl
+    TryFrom<
+        ResponseRouterData<
+            Capture,
+            DeutschebankPaymentsResponse,
+            PaymentsCaptureData,
+            PaymentsResponseData,
+        >,
+    > for RouterData<Capture, PaymentsCaptureData, PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<
+            Capture,
+            DeutschebankPaymentsResponse,
+            PaymentsCaptureData,
+            PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        Ok(Self {
+            response: Ok(PaymentsResponseData::TransactionResponse {
+                resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
+                redirection_data: None,
+                mandate_reference: None,
+                connector_metadata: None,
+                network_txn_id: None,
+                connector_response_reference_id: None,
+                incremental_authorization_allowed: None,
+                charge_id: None,
+            }),
+            status: if item.response.rc == "0" {
+                common_enums::AttemptStatus::Charged
+            } else {
+                common_enums::AttemptStatus::Failure
+            },
+            ..item.data
+        })
+    }
 }
 
-impl From<RefundStatus> for enums::RefundStatus {
-    fn from(item: RefundStatus) -> Self {
-        match item {
-            RefundStatus::Succeeded => Self::Success,
-            RefundStatus::Failed => Self::Failure,
-            RefundStatus::Processing => Self::Pending,
-            //TODO: Review mapping
+impl
+    TryFrom<
+        ResponseRouterData<
+            PSync,
+            DeutschebankPaymentsResponse,
+            PaymentsSyncData,
+            PaymentsResponseData,
+        >,
+    > for RouterData<PSync, PaymentsSyncData, PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<
+            PSync,
+            DeutschebankPaymentsResponse,
+            PaymentsSyncData,
+            PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        let status = if item.response.rc == "0" {
+            item.response
+                .tx_action
+                .and_then(|tx_action| match tx_action {
+                    DeutschebankTXAction::Preauthorization => {
+                        Some(common_enums::AttemptStatus::Authorized)
+                    }
+                    DeutschebankTXAction::Authorization | DeutschebankTXAction::Capture => {
+                        Some(common_enums::AttemptStatus::Charged)
+                    }
+                    DeutschebankTXAction::Credit
+                    | DeutschebankTXAction::Refund
+                    | DeutschebankTXAction::Reversal
+                    | DeutschebankTXAction::RiskCheck
+                    | DeutschebankTXAction::VerifyMop
+                    | DeutschebankTXAction::Payment
+                    | DeutschebankTXAction::AccountInformation => None,
+                })
+        } else {
+            Some(common_enums::AttemptStatus::Failure)
+        };
+        match status {
+            Some(status) => Ok(Self {
+                status,
+                ..item.data
+            }),
+            None => Ok(Self { ..item.data }),
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub struct RefundResponse {
-    id: String,
-    status: RefundStatus,
+#[derive(Debug, Serialize)]
+pub struct DeutschebankReversalRequest {
+    kind: DeutschebankTransactionKind,
+}
+
+impl TryFrom<&PaymentsCancelRouterData> for DeutschebankReversalRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(_item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
+        Ok(Self {
+            kind: DeutschebankTransactionKind::Directdebit,
+        })
+    }
 }
 
-impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
+impl TryFrom<PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>>
+    for PaymentsCancelRouterData
+{
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: RefundsResponseRouterData<Execute, RefundResponse>,
+        item: PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
-            }),
+            status: if item.response.rc == "0" {
+                common_enums::AttemptStatus::Voided
+            } else {
+                common_enums::AttemptStatus::VoidFailed
+            },
             ..item.data
         })
     }
 }
 
-impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
+#[derive(Debug, Serialize)]
+pub struct DeutschebankRefundRequest {
+    changed_amount: MinorUnit,
+    kind: DeutschebankTransactionKind,
+}
+
+impl<F> TryFrom<&DeutschebankRouterData<&RefundsRouterData<F>>> for DeutschebankRefundRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &DeutschebankRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
+        Ok(Self {
+            changed_amount: item.amount.to_owned(),
+            kind: DeutschebankTransactionKind::Directdebit,
+        })
+    }
+}
+
+impl TryFrom<RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>>
+    for RefundsRouterData<Execute>
+{
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: RefundsResponseRouterData<RSync, RefundResponse>,
+        item: RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             response: Ok(RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
+                connector_refund_id: item.response.tx_id,
+                refund_status: if item.response.rc == "0" {
+                    enums::RefundStatus::Success
+                } else {
+                    enums::RefundStatus::Failure
+                },
             }),
             ..item.data
         })
     }
 }
 
-//TODO: Fill the struct with respective fields
+impl TryFrom<RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>>
+    for RefundsRouterData<RSync>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
+    ) -> Result<Self, Self::Error> {
+        let status = if item.response.rc == "0" {
+            item.response
+                .tx_action
+                .and_then(|tx_action| match tx_action {
+                    DeutschebankTXAction::Credit | DeutschebankTXAction::Refund => {
+                        Some(enums::RefundStatus::Success)
+                    }
+                    DeutschebankTXAction::Preauthorization
+                    | DeutschebankTXAction::Authorization
+                    | DeutschebankTXAction::Capture
+                    | DeutschebankTXAction::Reversal
+                    | DeutschebankTXAction::RiskCheck
+                    | DeutschebankTXAction::VerifyMop
+                    | DeutschebankTXAction::Payment
+                    | DeutschebankTXAction::AccountInformation => None,
+                })
+        } else {
+            Some(enums::RefundStatus::Failure)
+        };
+        match status {
+            Some(refund_status) => Ok(Self {
+                response: Ok(RefundsResponseData {
+                    refund_status,
+                    connector_refund_id: item.data.request.get_connector_refund_id()?,
+                }),
+                ..item.data
+            }),
+            None => Ok(Self { ..item.data }),
+        }
+    }
+}
+
 #[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
 pub struct DeutschebankErrorResponse {
-    pub status_code: u16,
-    pub code: String,
+    pub rc: String,
     pub message: String,
-    pub reason: Option<String>,
 }
diff --git a/crates/hyperswitch_connectors/src/constants.rs b/crates/hyperswitch_connectors/src/constants.rs
index 86d6144b1f1..c5ca6512a34 100644
--- a/crates/hyperswitch_connectors/src/constants.rs
+++ b/crates/hyperswitch_connectors/src/constants.rs
@@ -7,7 +7,10 @@ pub(crate) mod headers {
     pub(crate) const DATE: &str = "Date";
     pub(crate) const IDEMPOTENCY_KEY: &str = "Idempotency-Key";
     pub(crate) const MESSAGE_SIGNATURE: &str = "Message-Signature";
+    pub(crate) const MERCHANT_ID: &str = "Merchant-ID";
     pub(crate) const TIMESTAMP: &str = "Timestamp";
     pub(crate) const X_ACCEPT_VERSION: &str = "X-Accept-Version";
     pub(crate) const X_NN_ACCESS_KEY: &str = "X-NN-Access-Key";
+    pub(crate) const X_RANDOM_VALUE: &str = "X-RandomValue";
+    pub(crate) const X_REQUEST_DATE: &str = "X-RequestDate";
 }
diff --git a/crates/hyperswitch_connectors/src/default_implementations.rs b/crates/hyperswitch_connectors/src/default_implementations.rs
index 1f50150c08d..b9ae736e435 100644
--- a/crates/hyperswitch_connectors/src/default_implementations.rs
+++ b/crates/hyperswitch_connectors/src/default_implementations.rs
@@ -190,7 +190,6 @@ macro_rules! default_imp_for_complete_authorize {
 
 default_imp_for_complete_authorize!(
     connectors::Bitpay,
-    connectors::Deutschebank,
     connectors::Fiserv,
     connectors::Fiservemea,
     connectors::Fiuu,
diff --git a/crates/hyperswitch_domain_models/src/payment_method_data.rs b/crates/hyperswitch_domain_models/src/payment_method_data.rs
index f714dfac86c..b64c745eec0 100644
--- a/crates/hyperswitch_domain_models/src/payment_method_data.rs
+++ b/crates/hyperswitch_domain_models/src/payment_method_data.rs
@@ -1308,6 +1308,16 @@ pub struct TokenizedBankRedirectValue2 {
     pub customer_id: Option<id_type::CustomerId>,
 }
 
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct TokenizedBankDebitValue2 {
+    pub customer_id: Option<id_type::CustomerId>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct TokenizedBankDebitValue1 {
+    pub data: BankDebitData,
+}
+
 pub trait GetPaymentMethodType {
     fn get_payment_method_type(&self) -> api_enums::PaymentMethodType;
 }
diff --git a/crates/hyperswitch_domain_models/src/types.rs b/crates/hyperswitch_domain_models/src/types.rs
index d27c7974092..3d47afb9b82 100644
--- a/crates/hyperswitch_domain_models/src/types.rs
+++ b/crates/hyperswitch_domain_models/src/types.rs
@@ -1,13 +1,14 @@
 use crate::{
-    router_data::RouterData,
+    router_data::{AccessToken, RouterData},
     router_flow_types::{
-        Authorize, CalculateTax, Capture, CompleteAuthorize, CreateConnectorCustomer, PSync,
-        PaymentMethodToken, RSync, SetupMandate, Void,
+        AccessTokenAuth, Authorize, CalculateTax, Capture, CompleteAuthorize,
+        CreateConnectorCustomer, PSync, PaymentMethodToken, RSync, SetupMandate, Void,
     },
     router_request_types::{
-        CompleteAuthorizeData, ConnectorCustomerData, PaymentMethodTokenizationData,
-        PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
-        PaymentsTaxCalculationData, RefundsData, SetupMandateRequestData,
+        AccessTokenRequestData, CompleteAuthorizeData, ConnectorCustomerData,
+        PaymentMethodTokenizationData, PaymentsAuthorizeData, PaymentsCancelData,
+        PaymentsCaptureData, PaymentsSyncData, PaymentsTaxCalculationData, RefundsData,
+        SetupMandateRequestData,
     },
     router_response_types::{
         PaymentsResponseData, RefundsResponseData, TaxCalculationResponseData,
@@ -31,3 +32,4 @@ pub type PaymentsCompleteAuthorizeRouterData =
     RouterData<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>;
 pub type PaymentsTaxCalculationRouterData =
     RouterData<CalculateTax, PaymentsTaxCalculationData, TaxCalculationResponseData>;
+pub type RefreshTokenRouterData = RouterData<AccessTokenAuth, AccessTokenRequestData, AccessToken>;
diff --git a/crates/router/src/configs/defaults.rs b/crates/router/src/configs/defaults.rs
index acffafa6c32..659c94423d4 100644
--- a/crates/router/src/configs/defaults.rs
+++ b/crates/router/src/configs/defaults.rs
@@ -11209,8 +11209,43 @@ impl Default for super::settings::RequiredFields {
                                                 }
                                             )
                                         ]),
-                                    })
-                               ]),
+                                    }
+                                ),
+                                (
+                                    enums::Connector::Deutschebank,
+                                    RequiredFieldFinal {
+                                        mandate: HashMap::new(),
+                                        non_mandate: HashMap::new(),
+                                        common: HashMap::from([ (
+                                            "billing.address.first_name".to_string(),
+                                            RequiredFieldInfo {
+                                                required_field: "payment_method_data.billing.address.first_name".to_string(),
+                                                display_name: "owner_name".to_string(),
+                                                field_type: enums::FieldType::UserBillingName,
+                                                value: None,
+                                            }),
+                                            (
+                                                "billing.address.last_name".to_string(),
+                                                RequiredFieldInfo {
+                                                    required_field: "payment_method_data.billing.address.last_name".to_string(),
+                                                    display_name: "owner_name".to_string(),
+                                                    field_type: enums::FieldType::UserBillingName,
+                                                    value: None,
+                                                }
+                                            ),
+                                            (
+                                                "payment_method_data.bank_debit.sepa.iban".to_string(),
+                                                RequiredFieldInfo {
+                                                    required_field: "payment_method_data.bank_debit.bacs.iban".to_string(),
+                                                    display_name: "bank_account_number".to_string(),
+                                                    field_type: enums::FieldType::Text,
+                                                    value: None,
+                                                }
+                                            )
+                                        ]),
+                                    }
+                                )
+                            ]),
                         },
                     ),
                     (
diff --git a/crates/router/src/core/admin.rs b/crates/router/src/core/admin.rs
index 996224d7bea..75b8d922f82 100644
--- a/crates/router/src/core/admin.rs
+++ b/crates/router/src/core/admin.rs
@@ -1300,6 +1300,10 @@ impl<'a> ConnectorAuthTypeAndMetadataValidation<'a> {
                 datatrans::transformers::DatatransAuthType::try_from(self.auth_type)?;
                 Ok(())
             }
+            api_enums::Connector::Deutschebank => {
+                deutschebank::transformers::DeutschebankAuthType::try_from(self.auth_type)?;
+                Ok(())
+            }
             api_enums::Connector::Dlocal => {
                 dlocal::transformers::DlocalAuthType::try_from(self.auth_type)?;
                 Ok(())
diff --git a/crates/router/src/core/payment_methods.rs b/crates/router/src/core/payment_methods.rs
index 0061eb4fbc0..9a39a3c341b 100644
--- a/crates/router/src/core/payment_methods.rs
+++ b/crates/router/src/core/payment_methods.rs
@@ -79,9 +79,22 @@ pub async fn retrieve_payment_method(
 
             Ok((pm_opt.to_owned(), payment_token))
         }
+        pm_opt @ Some(pm @ domain::PaymentMethodData::BankDebit(_)) => {
+            let payment_token = helpers::store_payment_method_data_in_vault(
+                state,
+                payment_attempt,
+                payment_intent,
+                enums::PaymentMethod::BankDebit,
+                pm,
+                merchant_key_store,
+                business_profile,
+            )
+            .await?;
+
+            Ok((pm_opt.to_owned(), payment_token))
+        }
         pm @ Some(domain::PaymentMethodData::PayLater(_)) => Ok((pm.to_owned(), None)),
         pm @ Some(domain::PaymentMethodData::Crypto(_)) => Ok((pm.to_owned(), None)),
-        pm @ Some(domain::PaymentMethodData::BankDebit(_)) => Ok((pm.to_owned(), None)),
         pm @ Some(domain::PaymentMethodData::Upi(_)) => Ok((pm.to_owned(), None)),
         pm @ Some(domain::PaymentMethodData::Voucher(_)) => Ok((pm.to_owned(), None)),
         pm @ Some(domain::PaymentMethodData::Reward) => Ok((pm.to_owned(), None)),
diff --git a/crates/router/src/core/payment_methods/vault.rs b/crates/router/src/core/payment_methods/vault.rs
index 54da4308bfb..75278010ceb 100644
--- a/crates/router/src/core/payment_methods/vault.rs
+++ b/crates/router/src/core/payment_methods/vault.rs
@@ -279,6 +279,58 @@ impl Vaultable for domain::BankRedirectData {
     }
 }
 
+impl Vaultable for domain::BankDebitData {
+    fn get_value1(
+        &self,
+        _customer_id: Option<id_type::CustomerId>,
+    ) -> CustomResult<String, errors::VaultError> {
+        let value1 = domain::TokenizedBankDebitValue1 {
+            data: self.to_owned(),
+        };
+
+        value1
+            .encode_to_string_of_json()
+            .change_context(errors::VaultError::RequestEncodingFailed)
+            .attach_printable("Failed to encode bank debit data")
+    }
+
+    fn get_value2(
+        &self,
+        customer_id: Option<id_type::CustomerId>,
+    ) -> CustomResult<String, errors::VaultError> {
+        let value2 = domain::TokenizedBankDebitValue2 { customer_id };
+
+        value2
+            .encode_to_string_of_json()
+            .change_context(errors::VaultError::RequestEncodingFailed)
+            .attach_printable("Failed to encode bank debit supplementary data")
+    }
+
+    fn from_values(
+        value1: String,
+        value2: String,
+    ) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
+        let value1: domain::TokenizedBankDebitValue1 = value1
+            .parse_struct("TokenizedBankDebitValue1")
+            .change_context(errors::VaultError::ResponseDeserializationFailed)
+            .attach_printable("Could not deserialize into bank debit data")?;
+
+        let value2: domain::TokenizedBankDebitValue2 = value2
+            .parse_struct("TokenizedBankDebitValue2")
+            .change_context(errors::VaultError::ResponseDeserializationFailed)
+            .attach_printable("Could not deserialize into supplementary bank debit data")?;
+
+        let bank_transfer_data = value1.data;
+
+        let supp_data = SupplementaryVaultData {
+            customer_id: value2.customer_id,
+            payment_method_id: None,
+        };
+
+        Ok((bank_transfer_data, supp_data))
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(tag = "type", content = "value", rename_all = "snake_case")]
 pub enum VaultPaymentMethod {
@@ -286,6 +338,7 @@ pub enum VaultPaymentMethod {
     Wallet(String),
     BankTransfer(String),
     BankRedirect(String),
+    BankDebit(String),
 }
 
 impl Vaultable for domain::PaymentMethodData {
@@ -302,6 +355,9 @@ impl Vaultable for domain::PaymentMethodData {
             Self::BankRedirect(bank_redirect) => {
                 VaultPaymentMethod::BankRedirect(bank_redirect.get_value1(customer_id)?)
             }
+            Self::BankDebit(bank_debit) => {
+                VaultPaymentMethod::BankDebit(bank_debit.get_value1(customer_id)?)
+            }
             _ => Err(errors::VaultError::PaymentMethodNotSupported)
                 .attach_printable("Payment method not supported")?,
         };
@@ -325,6 +381,9 @@ impl Vaultable for domain::PaymentMethodData {
             Self::BankRedirect(bank_redirect) => {
                 VaultPaymentMethod::BankRedirect(bank_redirect.get_value2(customer_id)?)
             }
+            Self::BankDebit(bank_debit) => {
+                VaultPaymentMethod::BankDebit(bank_debit.get_value2(customer_id)?)
+            }
             _ => Err(errors::VaultError::PaymentMethodNotSupported)
                 .attach_printable("Payment method not supported")?,
         };
@@ -374,6 +433,10 @@ impl Vaultable for domain::PaymentMethodData {
                     domain::BankRedirectData::from_values(mvalue1, mvalue2)?;
                 Ok((Self::BankRedirect(bank_redirect), supp_data))
             }
+            (VaultPaymentMethod::BankDebit(mvalue1), VaultPaymentMethod::BankDebit(mvalue2)) => {
+                let (bank_debit, supp_data) = domain::BankDebitData::from_values(mvalue1, mvalue2)?;
+                Ok((Self::BankDebit(bank_debit), supp_data))
+            }
 
             _ => Err(errors::VaultError::PaymentMethodNotSupported)
                 .attach_printable("Payment method not supported"),
diff --git a/crates/router/src/core/payments/helpers.rs b/crates/router/src/core/payments/helpers.rs
index 5f9c1a7be0b..6cb4532d617 100644
--- a/crates/router/src/core/payments/helpers.rs
+++ b/crates/router/src/core/payments/helpers.rs
@@ -1770,6 +1770,10 @@ pub async fn retrieve_payment_method_with_temporary_token(
             Some((the_pm, enums::PaymentMethod::BankRedirect))
         }
 
+        Some(the_pm @ domain::PaymentMethodData::BankDebit(_)) => {
+            Some((the_pm, enums::PaymentMethod::BankDebit))
+        }
+
         Some(_) => Err(errors::ApiErrorResponse::InternalServerError)
             .attach_printable("Payment method received from locker is unsupported by locker")?,
 
diff --git a/crates/router/src/types/api.rs b/crates/router/src/types/api.rs
index ca86003f4b4..34dea537b2d 100644
--- a/crates/router/src/types/api.rs
+++ b/crates/router/src/types/api.rs
@@ -359,9 +359,9 @@ impl ConnectorData {
                 enums::Connector::Datatrans => {
                     Ok(ConnectorEnum::Old(Box::new(connector::Datatrans::new())))
                 }
-                // enums::Connector::Deutschebank => {
-                //     Ok(ConnectorEnum::Old(Box::new(connector::Deutschebank::new())))
-                // }
+                enums::Connector::Deutschebank => {
+                    Ok(ConnectorEnum::Old(Box::new(connector::Deutschebank::new())))
+                }
                 enums::Connector::Dlocal => Ok(ConnectorEnum::Old(Box::new(&connector::Dlocal))),
                 #[cfg(feature = "dummy_connector")]
                 enums::Connector::DummyConnector1 => Ok(ConnectorEnum::Old(Box::new(
diff --git a/crates/router/src/types/domain/payments.rs b/crates/router/src/types/domain/payments.rs
index 1cf36bc4428..bfd7b54f556 100644
--- a/crates/router/src/types/domain/payments.rs
+++ b/crates/router/src/types/domain/payments.rs
@@ -6,8 +6,9 @@ pub use hyperswitch_domain_models::payment_method_data::{
     GooglePayThirdPartySdkData, GooglePayWalletData, GpayTokenizationData, IndomaretVoucherData,
     KakaoPayRedirection, MbWayRedirection, MifinityData, OpenBankingData, PayLaterData,
     PaymentMethodData, RealTimePaymentData, SamsungPayWalletData, SepaAndBacsBillingDetails,
-    SwishQrData, TokenizedBankRedirectValue1, TokenizedBankRedirectValue2,
-    TokenizedBankTransferValue1, TokenizedBankTransferValue2, TokenizedCardValue1,
-    TokenizedCardValue2, TokenizedWalletValue1, TokenizedWalletValue2, TouchNGoRedirection,
-    UpiCollectData, UpiData, UpiIntentData, VoucherData, WalletData, WeChatPayQr,
+    SwishQrData, TokenizedBankDebitValue1, TokenizedBankDebitValue2, TokenizedBankRedirectValue1,
+    TokenizedBankRedirectValue2, TokenizedBankTransferValue1, TokenizedBankTransferValue2,
+    TokenizedCardValue1, TokenizedCardValue2, TokenizedWalletValue1, TokenizedWalletValue2,
+    TouchNGoRedirection, UpiCollectData, UpiData, UpiIntentData, VoucherData, WalletData,
+    WeChatPayQr,
 };
diff --git a/crates/router/src/types/transformers.rs b/crates/router/src/types/transformers.rs
index f883d1d4c50..46210d4dd09 100644
--- a/crates/router/src/types/transformers.rs
+++ b/crates/router/src/types/transformers.rs
@@ -274,7 +274,7 @@ impl ForeignTryFrom<api_enums::Connector> for common_enums::RoutableConnectors {
             api_enums::Connector::Cryptopay => Self::Cryptopay,
             api_enums::Connector::Cybersource => Self::Cybersource,
             api_enums::Connector::Datatrans => Self::Datatrans,
-            // api_enums::Connector::Deutschebank => Self::Deutschebank,
+            api_enums::Connector::Deutschebank => Self::Deutschebank,
             api_enums::Connector::Dlocal => Self::Dlocal,
             api_enums::Connector::Ebanx => Self::Ebanx,
             api_enums::Connector::Fiserv => Self::Fiserv,
diff --git a/crates/router/tests/connectors/sample_auth.toml b/crates/router/tests/connectors/sample_auth.toml
index 6ed9bd7103d..f61770a5bde 100644
--- a/crates/router/tests/connectors/sample_auth.toml
+++ b/crates/router/tests/connectors/sample_auth.toml
@@ -276,7 +276,9 @@ api_key = "API Key"
 api_key="API Key"
 
 [deutschebank]
-api_key="API Key"
+api_key = "Client ID"
+key1 = "Merchant ID"
+api_secret = "Client Key"
 
 [thunes]
-api_key="API Key"
\ No newline at end of file
+api_key="API Key"
diff --git a/crates/test_utils/src/connector_auth.rs b/crates/test_utils/src/connector_auth.rs
index 68895e5876e..a0fed3c003a 100644
--- a/crates/test_utils/src/connector_auth.rs
+++ b/crates/test_utils/src/connector_auth.rs
@@ -31,7 +31,7 @@ pub struct ConnectorAuthentication {
     pub cryptopay: Option<BodyKey>,
     pub cybersource: Option<SignatureKey>,
     pub datatrans: Option<HeaderKey>,
-    pub deutschebank: Option<HeaderKey>,
+    pub deutschebank: Option<SignatureKey>,
     pub dlocal: Option<SignatureKey>,
     #[cfg(feature = "dummy_connector")]
     pub dummyconnector: Option<HeaderKey>,
diff --git a/loadtest/config/development.toml b/loadtest/config/development.toml
index b1f74f57feb..ed15e8893bd 100644
--- a/loadtest/config/development.toml
+++ b/loadtest/config/development.toml
@@ -96,7 +96,7 @@ coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
 datatrans.base_url = "https://api.sandbox.datatrans.com/"
-deutschebank.base_url = "https://sandbox.directpos.de/rest-api/services/v2.1"
+deutschebank.base_url = "https://testmerch.directpos.de/rest-api"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"

## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [ ] New feature
- [ ] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
<!-- Describe your changes in detail -->
Integrate SEPA Payments for connector Deutsche Bank
https://testmerch.directpos.de/rest-api/apidoc/v2.1/index.html#chap_sdd

### Additional Changes

- [ ] This PR modifies the API contract
- [ ] This PR modifies the database schema
- [ ] This PR modifies application configuration/environment variables

<!--
Provide links to the files with corresponding changes.

Following are the paths where you can find config files:
1. `config`
2. `crates/router/src/configs`
3. `loadtest/config`
-->


## Motivation and Context
<!--
Why is this change required? What problem does it solve?
If it fixes an open issue, please link to the issue here.

If you don't have an issue, we'd recommend starting with one first so the PR
can focus on the implementation (unless it is an obvious bug or documentation fix
that will have little conversation).
-->
https://github.com/juspay/hyperswitch/issues/5858

## How did you test it?
<!--
Did you write an integration/unit/API test to verify the code changes?
Or did you test this change manually (provide relevant screenshots)?
-->

1. Authorize:
Request:
```
curl --location 'http://localhost:8080/payments' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb' \
--data '{
    "amount": 9000,
    "currency": "EUR",
    "confirm": true,
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "customer_id": "customer123",
    
    "payment_method": "bank_debit",
    "payment_method_type": "sepa",
    "payment_method_data": {
        "bank_debit": {
            "sepa_bank_debit": {
                "iban": "DE87123456781234567890"
            }
        }
    },
    "billing": {
        "address": {
            "first_name": "joseph",
            "last_name": "Doe"
        }
    },
}'
```

Response:
```
{
    "payment_id": "pay_9SIimBI1UXiGdsR4XCmH",
    "merchant_id": "merchant_1725539597",
    "status": "requires_customer_action",
    "amount": 9000,
    "net_amount": 9000,
    "amount_capturable": 9000,
    "amount_received": null,
    "connector": "deutschebank",
    "client_secret": "pay_9SIimBI1UXiGdsR4XCmH_secret_s0dXk9MNEsKru7clJoNK",
    "created": "2024-09-12T10:41:39.816Z",
    "currency": "EUR",
    "customer_id": "customer123",
    "customer": {
        "id": "customer123",
        "name": "John Doe",
        "email": "customer@gmail.com",
        "phone": "9999999999",
        "phone_country_code": "+1"
    },
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": null,
    "payment_method": "bank_debit",
    "payment_method_data": {
        "bank_debit": {
            "sepa": {
                "iban": "DE871************67890",
                "bank_account_holder_name": null
            }
        },
        "billing": null
    },
    "payment_token": "token_IORpLx2lNN9VK64COwy0",
    "shipping": null,
    "billing": {
        "address": {
            "city": null,
            "country": null,
            "line1": null,
            "line2": null,
            "line3": null,
            "zip": null,
            "state": null,
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "customer@gmail.com",
    "name": "John Doe",
    "phone": "9999999999",
    "return_url": "https://example.com/",
    "authentication_type": "no_three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": {
        "type": "redirect_to_url",
        "redirect_to_url": "http://localhost:8080/payments/redirect/pay_9SIimBI1UXiGdsR4XCmH/merchant_1725539597/pay_9SIimBI1UXiGdsR4XCmH_1"
    },
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "sepa",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": {
        "customer_id": "customer123",
        "created_at": 1726137699,
        "expires": 1726141299,
        "secret": "epk_a677e949924b417cb73e1badf1ac05f8"
    },
    "manual_retry_allowed": null,
    "connector_transaction_id": null,
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-09-12T10:56:39.816Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-09-12T10:41:42.563Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```

Then do redirection

2. PSYNC:
Request:
```
curl --location 'http://localhost:8080/payments/pay_aCYBEjtBmw7l7u4jQWhM' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb'
```

Response:
```
{
    "payment_id": "pay_aCYBEjtBmw7l7u4jQWhM",
    "merchant_id": "merchant_1725539597",
    "status": "succeeded",
    "amount": 9000,
    "net_amount": 9000,
    "amount_capturable": 0,
    "amount_received": 9000,
    "connector": "deutschebank",
    "client_secret": "pay_aCYBEjtBmw7l7u4jQWhM_secret_4TLRv0W2zGPEaN5hxwOC",
    "created": "2024-09-12T10:32:33.053Z",
    "currency": "EUR",
    "customer_id": "customer123",
    "customer": {
        "id": "customer123",
        "name": "John Doe",
        "email": "customer@gmail.com",
        "phone": "9999999999",
        "phone_country_code": "+1"
    },
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": null,
    "payment_method": "bank_debit",
    "payment_method_data": {
        "bank_debit": {
            "sepa": {
                "iban": "DE871************67890",
                "bank_account_holder_name": null
            }
        },
        "billing": null
    },
    "payment_token": "token_1gP6ixqxxYORXgW6mAxq",
    "shipping": null,
    "billing": {
        "address": {
            "city": null,
            "country": null,
            "line1": null,
            "line2": null,
            "line3": null,
            "zip": null,
            "state": null,
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "customer@gmail.com",
    "name": "John Doe",
    "phone": "9999999999",
    "return_url": null,
    "authentication_type": "no_three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": null,
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "sepa",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "manual_retry_allowed": false,
    "connector_transaction_id": "fNo3C3goIky4BNzSU7ys9n",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-09-12T10:47:33.053Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-09-12T10:40:37.356Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```

3. Capture: 
Request:
```
curl --location 'http://localhost:8080/payments/pay_zwqrtx6EMgaV2gkK7WdS/capture' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb' \
--data '{}'
```

Response:
```
{
    "payment_id": "pay_zwqrtx6EMgaV2gkK7WdS",
    "merchant_id": "merchant_1725539597",
    "status": "succeeded",
    "amount": 9000,
    "net_amount": 9000,
    "amount_capturable": 0,
    "amount_received": 9000,
    "connector": "deutschebank",
    "client_secret": "pay_zwqrtx6EMgaV2gkK7WdS_secret_Br19bUUvGCMLAiG1Fusv",
    "created": "2024-09-12T10:42:41.662Z",
    "currency": "EUR",
    "customer_id": "customer123",
    "customer": {
        "id": "customer123",
        "name": "John Doe",
        "email": "customer@gmail.com",
        "phone": "9999999999",
        "phone_country_code": "+1"
    },
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": "manual",
    "payment_method": "bank_debit",
    "payment_method_data": {
        "bank_debit": {
            "sepa": {
                "iban": "DE871************67890",
                "bank_account_holder_name": null
            }
        },
        "billing": null
    },
    "payment_token": "token_RzJMp7J8sp2wWoRnBYPA",
    "shipping": null,
    "billing": {
        "address": {
            "city": null,
            "country": null,
            "line1": null,
            "line2": null,
            "line3": null,
            "zip": null,
            "state": null,
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "customer@gmail.com",
    "name": "John Doe",
    "phone": "9999999999",
    "return_url": null,
    "authentication_type": "no_three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": null,
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "sepa",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "manual_retry_allowed": false,
    "connector_transaction_id": "8v739jbpsaKxnsCB52QmeF",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-09-12T10:57:41.662Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-09-12T10:42:57.446Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```

4. Void:
Request:
```
curl --location 'http://localhost:8080/payments/pay_sH3vFdwGOoPjobg4sud9/cancel' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb' \
--data '{}'
```

Response:
```
{
    "payment_id": "pay_sH3vFdwGOoPjobg4sud9",
    "merchant_id": "merchant_1725539597",
    "status": "cancelled",
    "amount": 9000,
    "net_amount": 9000,
    "amount_capturable": 0,
    "amount_received": null,
    "connector": "deutschebank",
    "client_secret": "pay_sH3vFdwGOoPjobg4sud9_secret_jlUGjGn6ADDu02Ql8O4K",
    "created": "2024-09-12T10:44:13.912Z",
    "currency": "EUR",
    "customer_id": "customer123",
    "customer": {
        "id": "customer123",
        "name": "John Doe",
        "email": "customer@gmail.com",
        "phone": "9999999999",
        "phone_country_code": "+1"
    },
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": "manual",
    "payment_method": "bank_debit",
    "payment_method_data": {
        "bank_debit": {
            "sepa": {
                "iban": "DE871************67890",
                "bank_account_holder_name": null
            }
        },
        "billing": null
    },
    "payment_token": "token_2Mq0WwprhovjSGXcJmZa",
    "shipping": null,
    "billing": {
        "address": {
            "city": null,
            "country": null,
            "line1": null,
            "line2": null,
            "line3": null,
            "zip": null,
            "state": null,
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "customer@gmail.com",
    "name": "John Doe",
    "phone": "9999999999",
    "return_url": null,
    "authentication_type": "no_three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": null,
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "sepa",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "manual_retry_allowed": false,
    "connector_transaction_id": "9VFMneA8NhYUj7xoG0bmMA",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-09-12T10:59:13.912Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-09-12T10:44:39.083Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```

5. Refunds:
Request:
```
curl --location 'http://localhost:8080/refunds' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb' \
--data '{
    "payment_id": "pay_bBC3GTsRPYVPQ8v1XdVv",
    "refund_type": "instant"
}'
```

Response:
```
{
    "refund_id": "ref_UDEk9Xks0pRZI5GdY1BJ",
    "payment_id": "pay_bBC3GTsRPYVPQ8v1XdVv",
    "amount": 9000,
    "currency": "EUR",
    "status": "succeeded",
    "reason": null,
    "metadata": null,
    "error_message": null,
    "error_code": null,
    "created_at": "2024-09-16T07:57:15.637Z",
    "updated_at": "2024-09-16T07:57:18.072Z",
    "connector": "deutschebank",
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "charges": null
}
```

6. RSYNC:
Request:
```
curl --location 'http://localhost:8080/refunds/ref_UDEk9Xks0pRZI5GdY1BJ' \
--header 'Accept: application/json' \
--header 'api-key: dev_2QpEeK0ByPRkb2DPBxHfad4i1WxQO3hZSuVzlFcg9mTrLFUHRpGfE0SCuQwZjGEb'
```

Response:
```
{
    "refund_id": "ref_UDEk9Xks0pRZI5GdY1BJ",
    "payment_id": "pay_bBC3GTsRPYVPQ8v1XdVv",
    "amount": 9000,
    "currency": "EUR",
    "status": "succeeded",
    "reason": null,
    "metadata": null,
    "error_message": null,
    "error_code": null,
    "created_at": "2024-09-16T07:57:15.637Z",
    "updated_at": "2024-09-16T07:58:34.252Z",
    "connector": "deutschebank",
    "profile_id": "pro_EuXuxP2KVO0m1tlDWSau",
    "merchant_connector_id": "mca_MZAsrTowXuzpeXl4DMj2",
    "charges": null
}
```

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [x] I formatted the code `cargo +nightly fmt --all`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed the submitted code
- [ ] I added unit tests for my changes where possible
