Bug: [FEATURE]:Remove Braintree SDK Flow support 



Remove the SDK Support for the Braintree

diff --git a/config/config.example.toml b/config/config.example.toml
index 941a315aaee..a78e5b2c995 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -194,8 +194,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://$-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -542,8 +541,6 @@ adyen.banks = "affin_bank,agro_bank,alliance_bank,am_bank,bank_islam,bank_muamal
 [bank_config.online_banking_thailand]
 adyen.banks = "bangkok_bank,krungsri_bank,krung_thai_bank,the_siam_commercial_bank,kasikorn_bank"
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [applepay_decrypt_keys]
 apple_pay_ppc = "APPLE_PAY_PAYMENT_PROCESSING_CERTIFICATE"         # Payment Processing Certificate provided by Apple Pay (https://developer.apple.com/) Certificates, Identifiers & Profiles > Apple Pay Payment Processing Certificate
diff --git a/config/deployments/integration_test.toml b/config/deployments/integration_test.toml
index 7c946f8209b..4d433e1a9db 100644
--- a/config/deployments/integration_test.toml
+++ b/config/deployments/integration_test.toml
@@ -34,8 +34,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://$-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -157,8 +156,6 @@ card.debit = { connector_list = "cybersource" }             # Update Mandate sup
 [network_transaction_id_supported_connectors]
 connector_list = "stripe,adyen,cybersource"
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [payouts]
 payout_eligibility = true             # Defaults the eligibility of a payout method to true in case connector does not provide checks for payout eligibility
diff --git a/config/deployments/production.toml b/config/deployments/production.toml
index 4630b969224..5c843faf519 100644
--- a/config/deployments/production.toml
+++ b/config/deployments/production.toml
@@ -38,8 +38,7 @@ bitpay.base_url = "https://bitpay.com"
 bluesnap.base_url = "https://ws.bluesnap.com/"
 bluesnap.secondary_base_url = "https://pay.bluesnap.com/"
 boku.base_url = "https://country-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.braintree-api.com/graphql"
+braintree.base_url = "https://payments.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster14.api.cashtocode.com"
 checkout.base_url = "https://api.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -154,8 +153,6 @@ bank_redirect.giropay.connector_list = "adyen,globalpay,multisafepay"        # M
 card.credit = { connector_list = "cybersource" }            # Update Mandate supported payment method type and connector for card 
 card.debit = { connector_list = "cybersource" }             # Update Mandate supported payment method type and connector for card 
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [payouts]
 payout_eligibility = true            # Defaults the eligibility of a payout method to true in case connector does not provide checks for payout eligibility
diff --git a/config/deployments/sandbox.toml b/config/deployments/sandbox.toml
index 5fb7bfe0d68..fe0d99f8eeb 100644
--- a/config/deployments/sandbox.toml
+++ b/config/deployments/sandbox.toml
@@ -38,8 +38,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://$-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -157,8 +156,6 @@ card.debit = { connector_list = "cybersource" }             # Update Mandate sup
 [network_transaction_id_supported_connectors]
 connector_list = "stripe,adyen,cybersource"
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [payouts]
 payout_eligibility = true               # Defaults the eligibility of a payout method to true in case connector does not provide checks for payout eligibility
diff --git a/config/development.toml b/config/development.toml
index 48aa82b07a2..b3a64adf0ba 100644
--- a/config/development.toml
+++ b/config/development.toml
@@ -190,8 +190,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://$-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -573,8 +572,6 @@ merchant_ids_send_payment_id_as_connector_request_id = []
 [payouts]
 payout_eligibility = true
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [applepay_decrypt_keys]
 apple_pay_ppc = "APPLE_PAY_PAYMENT_PROCESSING_CERTIFICATE"
diff --git a/config/docker_compose.toml b/config/docker_compose.toml
index 61fdf86e457..6263e945b96 100644
--- a/config/docker_compose.toml
+++ b/config/docker_compose.toml
@@ -123,8 +123,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://$-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -439,8 +438,6 @@ connector_list = "stripe,adyen,cybersource"
 connector_list = "gocardless,stax,stripe"
 payout_connector_list = "stripe,wise"
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
 
 [payment_method_auth]
 redis_expiry = 900
diff --git a/crates/router/src/connector/braintree.rs b/crates/router/src/connector/braintree.rs
index fe15422a128..85b310397b2 100644
--- a/crates/router/src/connector/braintree.rs
+++ b/crates/router/src/connector/braintree.rs
@@ -1,10 +1,14 @@
-pub mod braintree_graphql_transformers;
 pub mod transformers;
-use std::{fmt::Debug, str::FromStr};
+use std::str::FromStr;
 
 use api_models::webhooks::IncomingWebhookEvent;
 use base64::Engine;
-use common_utils::{crypto, ext_traits::XmlExt, request::RequestContent};
+use common_utils::{
+    crypto,
+    ext_traits::XmlExt,
+    request::RequestContent,
+    types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
+};
 use diesel_models::enums;
 use error_stack::{report, Report, ResultExt};
 use masking::{ExposeInterface, PeekInterface, Secret};
@@ -37,19 +41,22 @@ use crate::{
     utils::{self, BytesExt},
 };
 
-#[derive(Debug, Clone)]
-pub struct Braintree;
-
-pub const BRAINTREE_VERSION: &str = "Braintree-Version";
-pub const BRAINTREE_VERSION_VALUE: &str = "2019-01-01";
-pub const BRAINTREE_API_VERSION: &str = "graphql_api";
+#[derive(Clone)]
+pub struct Braintree {
+    amount_converter: &'static (dyn AmountConvertor<Output = StringMajorUnit> + Sync),
+}
 
 impl Braintree {
-    pub fn is_braintree_graphql_version(&self, connector_api_version: &Option<String>) -> bool {
-        *connector_api_version == Some(BRAINTREE_API_VERSION.to_string())
+    pub const fn new() -> &'static Self {
+        &Self {
+            amount_converter: &StringMajorUnitForConnector,
+        }
     }
 }
 
+pub const BRAINTREE_VERSION: &str = "Braintree-Version";
+pub const BRAINTREE_VERSION_VALUE: &str = "2019-01-01";
+
 impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Braintree
 where
     Self: ConnectorIntegration<Flow, Request, Response>,
@@ -94,9 +101,11 @@ impl ConnectorCommon for Braintree {
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
         let auth = braintree::BraintreeAuthType::try_from(auth_type)
             .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+        let auth_key = format!("{}:{}", auth.public_key.peek(), auth.private_key.peek());
+        let auth_header = format!("Basic {}", consts::BASE64_ENGINE.encode(auth_key));
         Ok(vec![(
             headers::AUTHORIZATION.to_string(),
-            auth.auth_header.into_masked(),
+            auth_header.into_masked(),
         )])
     }
 
@@ -105,11 +114,13 @@ impl ConnectorCommon for Braintree {
         res: types::Response,
         event_builder: Option<&mut ConnectorEvent>,
     ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        let response: Result<braintree::ErrorResponse, Report<common_utils::errors::ParsingError>> =
-            res.response.parse_struct("Braintree Error Response");
+        let response: Result<
+            braintree::ErrorResponses,
+            Report<common_utils::errors::ParsingError>,
+        > = res.response.parse_struct("Braintree Error Response");
 
         match response {
-            Ok(braintree::ErrorResponse::BraintreeApiErrorResponse(response)) => {
+            Ok(braintree::ErrorResponses::BraintreeApiErrorResponse(response)) => {
                 event_builder.map(|i| i.set_error_response_body(&response));
                 router_env::logger::info!(connector_response=?response);
 
@@ -139,7 +150,7 @@ impl ConnectorCommon for Braintree {
                     connector_transaction_id: None,
                 })
             }
-            Ok(braintree::ErrorResponse::BraintreeErrorResponse(response)) => {
+            Ok(braintree::ErrorResponses::BraintreeErrorResponse(response)) => {
                 event_builder.map(|i| i.set_error_response_body(&response));
                 router_env::logger::info!(connector_response=?response);
 
@@ -205,109 +216,6 @@ impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, t
 impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
     for Braintree
 {
-    fn get_headers(
-        &self,
-        req: &types::PaymentsSessionRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let mut headers = vec![
-            (
-                headers::CONTENT_TYPE.to_string(),
-                types::PaymentsSessionType::get_content_type(self)
-                    .to_string()
-                    .into(),
-            ),
-            (headers::X_API_VERSION.to_string(), "6".to_string().into()),
-            (
-                headers::ACCEPT.to_string(),
-                "application/json".to_string().into(),
-            ),
-        ];
-        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-        headers.append(&mut api_key);
-        Ok(headers)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        "application/json"
-    }
-
-    fn get_url(
-        &self,
-        req: &types::PaymentsSessionRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        let auth_type = braintree::BraintreeAuthType::try_from(&req.connector_auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-        Ok(format!(
-            "{}/merchants/{}/client_token",
-            self.base_url(connectors),
-            auth_type.merchant_id.peek(),
-        ))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::PaymentsSessionRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(None),
-            false => {
-                let request = Some(
-                    services::RequestBuilder::new()
-                        .method(services::Method::Post)
-                        .url(&types::PaymentsSessionType::get_url(self, req, connectors)?)
-                        .attach_default_headers()
-                        .headers(types::PaymentsSessionType::get_headers(
-                            self, req, connectors,
-                        )?)
-                        .set_body(types::PaymentsSessionType::get_request_body(
-                            self, req, connectors,
-                        )?)
-                        .build(),
-                );
-                Ok(request)
-            }
-        }
-    }
-
-    fn get_error_response(
-        &self,
-        res: types::Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::PaymentsSessionRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_req = braintree::BraintreeSessionRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(connector_req)))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::PaymentsSessionRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PaymentsSessionRouterData, errors::ConnectorError> {
-        let response: braintree::BraintreeSessionTokenResponse = res
-            .response
-            .parse_struct("braintree SessionTokenResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
 }
 
 impl api::PaymentToken for Braintree {}
@@ -336,12 +244,7 @@ impl
         _req: &types::TokenizationRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let base_url = connectors
-            .braintree
-            .secondary_base_url
-            .as_ref()
-            .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-        Ok(base_url.to_string())
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn get_request_body(
@@ -349,7 +252,7 @@ impl
         req: &types::TokenizationRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_req = braintree_graphql_transformers::BraintreeTokenRequest::try_from(req)?;
+        let connector_req = transformers::BraintreeTokenRequest::try_from(req)?;
 
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
@@ -359,23 +262,18 @@ impl
         req: &types::TokenizationRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::Method::Post)
-                    .url(&types::TokenizationType::get_url(self, req, connectors)?)
-                    .attach_default_headers()
-                    .headers(types::TokenizationType::get_headers(self, req, connectors)?)
-                    .set_body(types::TokenizationType::get_request_body(
-                        self, req, connectors,
-                    )?)
-                    .build(),
-            )),
-            false => Ok(None),
-        }
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .url(&types::TokenizationType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::TokenizationType::get_headers(self, req, connectors)?)
+                .set_body(types::TokenizationType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
     }
-
     fn handle_response(
         &self,
         data: &types::TokenizationRouterData,
@@ -385,7 +283,7 @@ impl
     where
         types::PaymentsResponseData: Clone,
     {
-        let response: braintree_graphql_transformers::BraintreeTokenResponse = res
+        let response: transformers::BraintreeTokenResponse = res
             .response
             .parse_struct("BraintreeTokenResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -442,11 +340,7 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         req: &types::PaymentsCaptureRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version.clone();
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => Ok(vec![]),
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_content_type(&self) -> &'static str {
@@ -455,23 +349,10 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
 
     fn get_url(
         &self,
-        req: &types::PaymentsCaptureRouterData,
+        _req: &types::PaymentsCaptureRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = req.connector_api_version.clone();
-        match self.is_braintree_graphql_version(&connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn get_request_body(
@@ -479,28 +360,16 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         req: &types::PaymentsCaptureRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version.clone();
-        let connector_router_data =
-            braintree_graphql_transformers::BraintreeRouterData::try_from((
-                &self.get_currency_unit(),
-                req.request.currency,
-                req.request.amount_to_capture,
-                req,
-            ))?;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreeCaptureRequest::try_from(
-                        &connector_router_data,
-                    )?;
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount_to_capture,
+            req.request.currency,
+        )?;
+        let connector_router_data = braintree::BraintreeRouterData::try_from((amount, req))?;
+        let connector_req =
+            transformers::BraintreeCaptureRequest::try_from(&connector_router_data)?;
 
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => Err(errors::ConnectorError::NotImplemented(
-                "get_request_body method".to_string(),
-            )
-            .into()),
-        }
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -508,26 +377,19 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         req: &types::PaymentsCaptureRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::Method::Post)
-                    .url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
-                    .attach_default_headers()
-                    .headers(types::PaymentsCaptureType::get_headers(
-                        self, req, connectors,
-                    )?)
-                    .set_body(types::PaymentsCaptureType::get_request_body(
-                        self, req, connectors,
-                    )?)
-                    .build(),
-            )),
-            false => Err(errors::ConnectorError::NotImplemented(
-                "Capture flow not Implemented".to_string(),
-            )
-            .into()),
-        }
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::PaymentsCaptureType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(types::PaymentsCaptureType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
     }
 
     fn handle_response(
@@ -536,7 +398,7 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         event_builder: Option<&mut ConnectorEvent>,
         res: types::Response,
     ) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError> {
-        let response: braintree_graphql_transformers::BraintreeCaptureResponse = res
+        let response: transformers::BraintreeCaptureResponse = res
             .response
             .parse_struct("Braintree PaymentsCaptureResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -566,28 +428,7 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         req: &types::PaymentsSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => {
-                let mut headers = vec![
-                    (
-                        headers::CONTENT_TYPE.to_string(),
-                        types::PaymentsSyncType::get_content_type(self)
-                            .to_string()
-                            .into(),
-                    ),
-                    (headers::X_API_VERSION.to_string(), "6".to_string().into()),
-                    (
-                        headers::ACCEPT.to_string(),
-                        "application/json".to_string().into(),
-                    ),
-                ];
-                let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-                headers.append(&mut api_key);
-                Ok(headers)
-            }
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_content_type(&self) -> &'static str {
@@ -596,34 +437,10 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
 
     fn get_url(
         &self,
-        req: &types::PaymentsSyncRouterData,
+        _req: &types::PaymentsSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                let auth_type = braintree::BraintreeAuthType::try_from(&req.connector_auth_type)
-                    .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-                let connector_payment_id = req
-                    .request
-                    .connector_transaction_id
-                    .get_connector_transaction_id()
-                    .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
-                Ok(format!(
-                    "{}/merchants/{}/transactions/{connector_payment_id}",
-                    self.base_url(connectors),
-                    auth_type.merchant_id.peek()
-                ))
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn get_request_body(
@@ -631,16 +448,9 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         req: &types::PaymentsSyncRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreePSyncRequest::try_from(req)?;
+        let connector_req = transformers::BraintreePSyncRequest::try_from(req)?;
 
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => Err(report!(errors::ConnectorError::RequestEncodingFailed)),
-        }
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -648,31 +458,17 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         req: &types::PaymentsSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::Method::Post)
-                    .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
-                    .attach_default_headers()
-                    .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
-                    .set_body(types::PaymentsSyncType::get_request_body(
-                        self, req, connectors,
-                    )?)
-                    .build(),
-            )),
-            false => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::Method::Get)
-                    .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
-                    .attach_default_headers()
-                    .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
-                    .set_body(types::PaymentsSyncType::get_request_body(
-                        self, req, connectors,
-                    )?)
-                    .build(),
-            )),
-        }
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
+                .set_body(types::PaymentsSyncType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
     }
 
     fn handle_response(
@@ -681,35 +477,17 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         event_builder: Option<&mut ConnectorEvent>,
         res: types::Response,
     ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
-        let connector_api_version = &data.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let response: braintree_graphql_transformers::BraintreePSyncResponse = res
-                    .response
-                    .parse_struct("Braintree PaymentSyncResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-            false => {
-                let response: braintree::BraintreePaymentsResponse = res
-                    .response
-                    .parse_struct("Braintree PaymentsResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-        }
+        let response: transformers::BraintreePSyncResponse = res
+            .response
+            .parse_struct("Braintree PaymentSyncResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
     }
 
     fn get_error_response(
@@ -729,56 +507,15 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         req: &types::PaymentsAuthorizeRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => {
-                let mut headers = vec![
-                    (
-                        headers::CONTENT_TYPE.to_string(),
-                        types::PaymentsAuthorizeType::get_content_type(self)
-                            .to_string()
-                            .into(),
-                    ),
-                    (headers::X_API_VERSION.to_string(), "6".to_string().into()),
-                    (
-                        headers::ACCEPT.to_string(),
-                        "application/json".to_string().into(),
-                    ),
-                ];
-                let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-                headers.append(&mut api_key);
-                Ok(headers)
-            }
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_url(
         &self,
-        req: &types::PaymentsAuthorizeRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                let auth_type = braintree::BraintreeAuthType::try_from(&req.connector_auth_type)
-                    .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-
-                Ok(format!(
-                    "{}merchants/{}/transactions",
-                    self.base_url(connectors),
-                    auth_type.merchant_id.peek()
-                ))
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn build_request(
@@ -808,27 +545,15 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         req: &types::PaymentsAuthorizeRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        let connector_router_data =
-            braintree_graphql_transformers::BraintreeRouterData::try_from((
-                &self.get_currency_unit(),
-                req.request.currency,
-                req.request.amount,
-                req,
-            ))?;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreePaymentsRequest::try_from(
-                        &connector_router_data,
-                    )?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => {
-                let connector_req = braintree::BraintreePaymentsRequest::try_from(req)?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-        }
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount,
+            req.request.currency,
+        )?;
+        let connector_router_data = braintree::BraintreeRouterData::try_from((amount, req))?;
+        let connector_req: transformers::BraintreePaymentsRequest =
+            transformers::BraintreePaymentsRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn handle_response(
@@ -837,38 +562,9 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         event_builder: Option<&mut ConnectorEvent>,
         res: types::Response,
     ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
-        let connector_api_version = &data.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => match data.request.is_auto_capture()? {
-                true => {
-                    let response: braintree_graphql_transformers::BraintreePaymentsResponse = res
-                        .response
-                        .parse_struct("Braintree PaymentsResponse")
-                        .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                    event_builder.map(|i| i.set_response_body(&response));
-                    router_env::logger::info!(connector_response=?response);
-                    types::RouterData::try_from(types::ResponseRouterData {
-                        response,
-                        data: data.clone(),
-                        http_code: res.status_code,
-                    })
-                }
-                false => {
-                    let response: braintree_graphql_transformers::BraintreeAuthResponse = res
-                        .response
-                        .parse_struct("Braintree AuthResponse")
-                        .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                    event_builder.map(|i| i.set_response_body(&response));
-                    router_env::logger::info!(connector_response=?response);
-                    types::RouterData::try_from(types::ResponseRouterData {
-                        response,
-                        data: data.clone(),
-                        http_code: res.status_code,
-                    })
-                }
-            },
-            false => {
-                let response: braintree::BraintreePaymentsResponse = res
+        match data.request.is_auto_capture()? {
+            true => {
+                let response: transformers::BraintreePaymentsResponse = res
                     .response
                     .parse_struct("Braintree PaymentsResponse")
                     .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -880,6 +576,19 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
                     http_code: res.status_code,
                 })
             }
+            false => {
+                let response: transformers::BraintreeAuthResponse = res
+                    .response
+                    .parse_struct("Braintree AuthResponse")
+                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+                event_builder.map(|i| i.set_response_body(&response));
+                router_env::logger::info!(connector_response=?response);
+                types::RouterData::try_from(types::ResponseRouterData {
+                    response,
+                    data: data.clone(),
+                    http_code: res.status_code,
+                })
+            }
         }
     }
 
@@ -900,28 +609,7 @@ impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsR
         req: &types::PaymentsCancelRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => {
-                let mut headers = vec![
-                    (
-                        headers::CONTENT_TYPE.to_string(),
-                        types::PaymentsVoidType::get_content_type(self)
-                            .to_string()
-                            .into(),
-                    ),
-                    (headers::X_API_VERSION.to_string(), "6".to_string().into()),
-                    (
-                        headers::ACCEPT.to_string(),
-                        "application/json".to_string().into(),
-                    ),
-                ];
-                let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-                headers.append(&mut api_key);
-                Ok(headers)
-            }
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_content_type(&self) -> &'static str {
@@ -930,30 +618,10 @@ impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsR
 
     fn get_url(
         &self,
-        req: &types::PaymentsCancelRouterData,
+        _req: &types::PaymentsCancelRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                let auth_type = braintree::BraintreeAuthType::try_from(&req.connector_auth_type)
-                    .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-                Ok(format!(
-                    "{}merchants/{}/transactions/{}/void",
-                    self.base_url(connectors),
-                    auth_type.merchant_id.peek(),
-                    req.request.connector_transaction_id
-                ))
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn build_request(
@@ -979,15 +647,8 @@ impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsR
         req: &types::PaymentsCancelRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreeCancelRequest::try_from(req)?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => Err(report!(errors::ConnectorError::RequestEncodingFailed)),
-        }
+        let connector_req = transformers::BraintreeCancelRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn handle_response(
@@ -996,37 +657,18 @@ impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsR
         event_builder: Option<&mut ConnectorEvent>,
         res: types::Response,
     ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
-        let connector_api_version = &data.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let response: braintree_graphql_transformers::BraintreeCancelResponse = res
-                    .response
-                    .parse_struct("Braintree VoidResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-            false => {
-                let response: braintree::BraintreePaymentsResponse = res
-                    .response
-                    .parse_struct("Braintree PaymentsVoidResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-        }
+        let response: transformers::BraintreeCancelResponse = res
+            .response
+            .parse_struct("Braintree VoidResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
     }
-
     fn get_error_response(
         &self,
         res: types::Response,
@@ -1048,28 +690,7 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         req: &types::RefundsRouterData<api::Execute>,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => {
-                let mut headers = vec![
-                    (
-                        headers::CONTENT_TYPE.to_string(),
-                        types::RefundExecuteType::get_content_type(self)
-                            .to_string()
-                            .into(),
-                    ),
-                    (headers::X_API_VERSION.to_string(), "6".to_string().into()),
-                    (
-                        headers::ACCEPT.to_string(),
-                        "application/json".to_string().into(),
-                    ),
-                ];
-                let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-                headers.append(&mut api_key);
-                Ok(headers)
-            }
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_content_type(&self) -> &'static str {
@@ -1078,31 +699,10 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
 
     fn get_url(
         &self,
-        req: &types::RefundsRouterData<api::Execute>,
+        _req: &types::RefundsRouterData<api::Execute>,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                let auth_type = braintree::BraintreeAuthType::try_from(&req.connector_auth_type)
-                    .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-                let connector_payment_id = req.request.connector_transaction_id.clone();
-                Ok(format!(
-                    "{}merchants/{}/transactions/{}",
-                    self.base_url(connectors),
-                    auth_type.merchant_id.peek(),
-                    connector_payment_id
-                ))
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn get_request_body(
@@ -1110,29 +710,15 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         req: &types::RefundsRouterData<api::Execute>,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        let connector_router_data =
-            braintree_graphql_transformers::BraintreeRouterData::try_from((
-                &self.get_currency_unit(),
-                req.request.currency,
-                req.request.refund_amount,
-                req,
-            ))?;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreeRefundRequest::try_from(
-                        connector_router_data,
-                    )?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => {
-                let connector_req = braintree::BraintreeRefundRequest::try_from(req)?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-        }
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_refund_amount,
+            req.request.currency,
+        )?;
+        let connector_router_data = braintree::BraintreeRouterData::try_from((amount, req))?;
+        let connector_req = transformers::BraintreeRefundRequest::try_from(connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
-
     fn build_request(
         &self,
         req: &types::RefundsRouterData<api::Execute>,
@@ -1158,35 +744,17 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         event_builder: Option<&mut ConnectorEvent>,
         res: types::Response,
     ) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
-        let connector_api_version = &data.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let response: braintree_graphql_transformers::BraintreeRefundResponse = res
-                    .response
-                    .parse_struct("Braintree RefundResponse")
-                    .change_context(errors::ConnectorError::RequestEncodingFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-            false => {
-                let response: braintree::RefundResponse = res
-                    .response
-                    .parse_struct("Braintree RefundResponse")
-                    .change_context(errors::ConnectorError::RequestEncodingFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-        }
+        let response: transformers::BraintreeRefundResponse = res
+            .response
+            .parse_struct("Braintree RefundResponse")
+            .change_context(errors::ConnectorError::RequestEncodingFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
     }
 
     fn get_error_response(
@@ -1206,11 +774,7 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         req: &types::RefundSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => Ok(vec![]),
-        }
+        self.build_headers(req, connectors)
     }
 
     fn get_content_type(&self) -> &'static str {
@@ -1219,23 +783,10 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
 
     fn get_url(
         &self,
-        req: &types::RefundSyncRouterData,
+        _req: &types::RefundSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => {
-                Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
-            }
-        }
+        Ok(self.base_url(connectors).to_string())
     }
 
     fn get_request_body(
@@ -1243,15 +794,8 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         req: &types::RefundSyncRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreeRSyncRequest::try_from(req)?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => Err(report!(errors::ConnectorError::RequestEncodingFailed)),
-        }
+        let connector_req = transformers::BraintreeRSyncRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -1259,21 +803,17 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         req: &types::RefundSyncRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::Method::Post)
-                    .url(&types::RefundSyncType::get_url(self, req, connectors)?)
-                    .attach_default_headers()
-                    .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
-                    .set_body(types::RefundSyncType::get_request_body(
-                        self, req, connectors,
-                    )?)
-                    .build(),
-            )),
-            false => Ok(None),
-        }
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
+                .set_body(types::RefundSyncType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
     }
 
     fn handle_response(
@@ -1285,35 +825,17 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         types::RouterData<api::RSync, types::RefundsData, types::RefundsResponseData>,
         errors::ConnectorError,
     > {
-        let connector_api_version = &data.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let response: braintree_graphql_transformers::BraintreeRSyncResponse = res
-                    .response
-                    .parse_struct("Braintree RefundResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-            false => {
-                let response: braintree::RefundResponse = res
-                    .response
-                    .parse_struct("Braintree RefundResponse")
-                    .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-                event_builder.map(|i| i.set_response_body(&response));
-                router_env::logger::info!(connector_response=?response);
-                types::RouterData::try_from(types::ResponseRouterData {
-                    response,
-                    data: data.clone(),
-                    http_code: res.status_code,
-                })
-            }
-        }
+        let response: transformers::BraintreeRSyncResponse = res
+            .response
+            .parse_struct("Braintree RefundResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
     }
     fn get_error_response(
         &self,
@@ -1485,9 +1007,7 @@ impl api::IncomingWebhook for Braintree {
                         currency,
                     )?,
                     currency: dispute_data.currency_iso_code,
-                    dispute_stage: braintree_graphql_transformers::get_dispute_stage(
-                        dispute_data.kind.as_str(),
-                    )?,
+                    dispute_stage: transformers::get_dispute_stage(dispute_data.kind.as_str())?,
                     connector_dispute_id: dispute_data.id,
                     connector_reason: dispute_data.reason,
                     connector_reason_code: dispute_data.reason_code,
@@ -1516,16 +1036,15 @@ fn get_matching_webhook_signature(
 
 fn get_webhook_object_from_body(
     body: &[u8],
-) -> CustomResult<braintree_graphql_transformers::BraintreeWebhookResponse, errors::ParsingError> {
-    serde_urlencoded::from_bytes::<braintree_graphql_transformers::BraintreeWebhookResponse>(body)
-        .change_context(errors::ParsingError::StructParseFailure(
-            "BraintreeWebhookResponse",
-        ))
+) -> CustomResult<transformers::BraintreeWebhookResponse, errors::ParsingError> {
+    serde_urlencoded::from_bytes::<transformers::BraintreeWebhookResponse>(body).change_context(
+        errors::ParsingError::StructParseFailure("BraintreeWebhookResponse"),
+    )
 }
 
 fn decode_webhook_payload(
     payload: &[u8],
-) -> CustomResult<braintree_graphql_transformers::Notification, errors::ConnectorError> {
+) -> CustomResult<transformers::Notification, errors::ConnectorError> {
     let decoded_response = consts::BASE64_ENGINE
         .decode(payload)
         .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
@@ -1534,7 +1053,7 @@ fn decode_webhook_payload(
         .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
 
     xml_response
-        .parse_xml::<braintree_graphql_transformers::Notification>()
+        .parse_xml::<transformers::Notification>()
         .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)
 }
 
@@ -1548,17 +1067,16 @@ impl services::ConnectorRedirectResponse for Braintree {
         match action {
             services::PaymentAction::PSync => match json_payload {
                 Some(payload) => {
-                    let redirection_response:braintree_graphql_transformers::BraintreeRedirectionResponse = serde_json::from_value(payload)
-
-                            .change_context(
-                                errors::ConnectorError::MissingConnectorRedirectionPayload {
-                                    field_name: "redirection_response",
-                                },
-                            )?;
+                    let redirection_response: transformers::BraintreeRedirectionResponse =
+                        serde_json::from_value(payload).change_context(
+                            errors::ConnectorError::MissingConnectorRedirectionPayload {
+                                field_name: "redirection_response",
+                            },
+                        )?;
                     let braintree_payload =
-                        serde_json::from_str::<
-                            braintree_graphql_transformers::BraintreeThreeDsErrorResponse,
-                        >(&redirection_response.authentication_response);
+                        serde_json::from_str::<transformers::BraintreeThreeDsErrorResponse>(
+                            &redirection_response.authentication_response,
+                        );
                     let (error_code, error_message) = match braintree_payload {
                         Ok(braintree_response_payload) => (
                             braintree_response_payload.code,
@@ -1597,62 +1115,33 @@ impl
         req: &types::PaymentsCompleteAuthorizeRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => self.build_headers(req, connectors),
-            false => Err(errors::ConnectorError::NotImplemented(
-                "get_headers method".to_string(),
-            ))?,
-        }
+        self.build_headers(req, connectors)
     }
     fn get_content_type(&self) -> &'static str {
         self.common_get_content_type()
     }
     fn get_url(
         &self,
-        req: &types::PaymentsCompleteAuthorizeRouterData,
+        _req: &types::PaymentsCompleteAuthorizeRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let base_url = connectors
-                    .braintree
-                    .secondary_base_url
-                    .as_ref()
-                    .ok_or(errors::ConnectorError::FailedToObtainIntegrationUrl)?;
-                Ok(base_url.to_string())
-            }
-            false => Err(errors::ConnectorError::NotImplemented(
-                "get_url method".to_string(),
-            ))?,
-        }
+        Ok(self.base_url(connectors).to_string())
     }
     fn get_request_body(
         &self,
         req: &types::PaymentsCompleteAuthorizeRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_router_data =
-            braintree_graphql_transformers::BraintreeRouterData::try_from((
-                &self.get_currency_unit(),
-                req.request.currency,
-                req.request.amount,
-                req,
-            ))?;
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => {
-                let connector_req =
-                    braintree_graphql_transformers::BraintreePaymentsRequest::try_from(
-                        &connector_router_data,
-                    )?;
-                Ok(RequestContent::Json(Box::new(connector_req)))
-            }
-            false => Err(errors::ConnectorError::NotImplemented(
-                "get_request_body method".to_string(),
-            ))?,
-        }
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount,
+            req.request.currency,
+        )?;
+        let connector_router_data = braintree::BraintreeRouterData::try_from((amount, req))?;
+
+        let connector_req =
+            transformers::BraintreePaymentsRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -1660,27 +1149,21 @@ impl
         req: &types::PaymentsCompleteAuthorizeRouterData,
         connectors: &settings::Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let connector_api_version = &req.connector_api_version;
-        match self.is_braintree_graphql_version(connector_api_version) {
-            true => Ok(Some(
-                services::RequestBuilder::new()
-                    .method(services::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(),
-            )),
-            false => Err(errors::ConnectorError::NotImplemented(
-                "payment method".to_string(),
-            ))?,
-        }
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::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,
@@ -1691,7 +1174,7 @@ impl
         match connector_utils::PaymentsCompleteAuthorizeRequestData::is_auto_capture(&data.request)?
         {
             true => {
-                let response: braintree_graphql_transformers::BraintreeCompleteChargeResponse = res
+                let response: transformers::BraintreeCompleteChargeResponse = res
                     .response
                     .parse_struct("Braintree PaymentsResponse")
                     .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -1704,7 +1187,7 @@ impl
                 })
             }
             false => {
-                let response: braintree_graphql_transformers::BraintreeCompleteAuthResponse = res
+                let response: transformers::BraintreeCompleteAuthResponse = res
                     .response
                     .parse_struct("Braintree AuthResponse")
                     .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
diff --git a/crates/router/src/connector/braintree/braintree_graphql_transformers.rs b/crates/router/src/connector/braintree/braintree_graphql_transformers.rs
deleted file mode 100644
index af50bd10ce7..00000000000
--- a/crates/router/src/connector/braintree/braintree_graphql_transformers.rs
+++ /dev/null
@@ -1,1667 +0,0 @@
-use common_utils::pii;
-use error_stack::ResultExt;
-use masking::{ExposeInterface, Secret};
-use serde::{Deserialize, Serialize};
-use time::PrimitiveDateTime;
-
-use crate::{
-    connector::utils::{
-        self, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
-        RefundsRequestData, RouterData,
-    },
-    consts,
-    core::errors,
-    services,
-    types::{self, api, domain, storage::enums, MandateReference},
-    unimplemented_payment_method,
-};
-
-pub const CLIENT_TOKEN_MUTATION: &str = "mutation createClientToken($input: CreateClientTokenInput!) { createClientToken(input: $input) { clientToken}}";
-pub const TOKENIZE_CREDIT_CARD: &str = "mutation  tokenizeCreditCard($input: TokenizeCreditCardInput!) { tokenizeCreditCard(input: $input) { clientMutationId paymentMethod { id } } }";
-pub const CHARGE_CREDIT_CARD_MUTATION: &str = "mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id legacyId createdAt amount { value currencyCode } status } } }";
-pub const AUTHORIZE_CREDIT_CARD_MUTATION: &str = "mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) {  transaction { id legacyId amount { value currencyCode } status } } }";
-pub const CAPTURE_TRANSACTION_MUTATION: &str = "mutation captureTransaction($input: CaptureTransactionInput!) { captureTransaction(input: $input) { clientMutationId transaction { id legacyId amount { value currencyCode } status } } }";
-pub const VOID_TRANSACTION_MUTATION: &str = "mutation voidTransaction($input:  ReverseTransactionInput!) { reverseTransaction(input: $input) { clientMutationId reversal { ...  on Transaction { id legacyId amount { value currencyCode } status } } } }";
-pub const REFUND_TRANSACTION_MUTATION: &str = "mutation refundTransaction($input:  RefundTransactionInput!) { refundTransaction(input: $input) {clientMutationId refund { id legacyId amount { value currencyCode } status } } }";
-pub const AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION: &str="mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
-pub const CHARGE_AND_VAULT_TRANSACTION_MUTATION: &str ="mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
-
-#[derive(Debug, Serialize)]
-pub struct BraintreeRouterData<T> {
-    pub amount: String,
-    pub router_data: T,
-}
-
-impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for BraintreeRouterData<T> {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        (currency_unit, currency, amount, item): (&api::CurrencyUnit, enums::Currency, i64, T),
-    ) -> Result<Self, Self::Error> {
-        let amount = utils::get_amount_as_string(currency_unit, amount, currency)?;
-        Ok(Self {
-            amount,
-            router_data: item,
-        })
-    }
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PaymentInput {
-    payment_method_id: Secret<String>,
-    transaction: TransactionBody,
-}
-
-#[derive(Debug, Serialize)]
-pub struct VariablePaymentInput {
-    input: PaymentInput,
-}
-
-#[derive(Debug, Serialize)]
-pub struct CardPaymentRequest {
-    query: String,
-    variables: VariablePaymentInput,
-}
-
-#[derive(Debug, Serialize)]
-pub struct MandatePaymentRequest {
-    query: String,
-    variables: VariablePaymentInput,
-}
-
-#[derive(Debug, Serialize)]
-#[serde(untagged)]
-pub enum BraintreePaymentsRequest {
-    Card(CardPaymentRequest),
-    CardThreeDs(BraintreeClientTokenRequest),
-    Mandate(MandatePaymentRequest),
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BraintreeMeta {
-    merchant_account_id: Secret<String>,
-    merchant_config_currency: enums::Currency,
-}
-
-impl TryFrom<&Option<pii::SecretSerdeValue>> for BraintreeMeta {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
-        let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
-            .change_context(errors::ConnectorError::InvalidConnectorConfig {
-                config: "metadata",
-            })?;
-        Ok(metadata)
-    }
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RegularTransactionBody {
-    amount: String,
-    merchant_account_id: Secret<String>,
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct VaultTransactionBody {
-    amount: String,
-    merchant_account_id: Secret<String>,
-    vault_payment_method_after_transacting: TransactionTiming,
-}
-
-#[derive(Debug, Serialize)]
-#[serde(untagged)]
-pub enum TransactionBody {
-    Regular(RegularTransactionBody),
-    Vault(VaultTransactionBody),
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TransactionTiming {
-    when: String,
-}
-
-impl
-    TryFrom<(
-        &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
-        String,
-        BraintreeMeta,
-    )> for MandatePaymentRequest
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        (item, connector_mandate_id, metadata): (
-            &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
-            String,
-            BraintreeMeta,
-        ),
-    ) -> Result<Self, Self::Error> {
-        let (query, transaction_body) = (
-            match item.router_data.request.is_auto_capture()? {
-                true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
-                false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
-            },
-            TransactionBody::Regular(RegularTransactionBody {
-                amount: item.amount.to_owned(),
-                merchant_account_id: metadata.merchant_account_id,
-            }),
-        );
-        Ok(Self {
-            query,
-            variables: VariablePaymentInput {
-                input: PaymentInput {
-                    payment_method_id: connector_mandate_id.into(),
-                    transaction: transaction_body,
-                },
-            },
-        })
-    }
-}
-
-impl TryFrom<&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>>
-    for BraintreePaymentsRequest
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
-    ) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
-                .change_context(errors::ConnectorError::InvalidConnectorConfig {
-                    config: "metadata",
-                })?;
-        utils::validate_currency(
-            item.router_data.request.currency,
-            Some(metadata.merchant_config_currency),
-        )?;
-        match item.router_data.request.payment_method_data.clone() {
-            domain::PaymentMethodData::Card(_) => {
-                if item.router_data.is_three_ds() {
-                    Ok(Self::CardThreeDs(BraintreeClientTokenRequest::try_from(
-                        metadata,
-                    )?))
-                } else {
-                    Ok(Self::Card(CardPaymentRequest::try_from((item, metadata))?))
-                }
-            }
-            domain::PaymentMethodData::MandatePayment => {
-                let connector_mandate_id = item.router_data.request.connector_mandate_id().ok_or(
-                    errors::ConnectorError::MissingRequiredField {
-                        field_name: "connector_mandate_id",
-                    },
-                )?;
-                Ok(Self::Mandate(MandatePaymentRequest::try_from((
-                    item,
-                    connector_mandate_id,
-                    metadata,
-                ))?))
-            }
-            domain::PaymentMethodData::CardRedirect(_)
-            | domain::PaymentMethodData::Wallet(_)
-            | domain::PaymentMethodData::PayLater(_)
-            | domain::PaymentMethodData::BankRedirect(_)
-            | domain::PaymentMethodData::BankDebit(_)
-            | domain::PaymentMethodData::BankTransfer(_)
-            | domain::PaymentMethodData::Crypto(_)
-            | domain::PaymentMethodData::Reward
-            | domain::PaymentMethodData::RealTimePayment(_)
-            | domain::PaymentMethodData::Upi(_)
-            | domain::PaymentMethodData::Voucher(_)
-            | domain::PaymentMethodData::GiftCard(_)
-            | domain::PaymentMethodData::OpenBanking(_)
-            | domain::PaymentMethodData::CardToken(_) => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("braintree"),
-                )
-                .into())
-            }
-        }
-    }
-}
-
-impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
-    for BraintreePaymentsRequest
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
-    ) -> Result<Self, Self::Error> {
-        match item.router_data.payment_method {
-            api_models::enums::PaymentMethod::Card => {
-                Ok(Self::Card(CardPaymentRequest::try_from(item)?))
-            }
-            api_models::enums::PaymentMethod::CardRedirect
-            | api_models::enums::PaymentMethod::PayLater
-            | api_models::enums::PaymentMethod::Wallet
-            | api_models::enums::PaymentMethod::BankRedirect
-            | api_models::enums::PaymentMethod::BankTransfer
-            | api_models::enums::PaymentMethod::Crypto
-            | api_models::enums::PaymentMethod::BankDebit
-            | api_models::enums::PaymentMethod::Reward
-            | api_models::enums::PaymentMethod::RealTimePayment
-            | api_models::enums::PaymentMethod::Upi
-            | api_models::enums::PaymentMethod::Voucher
-            | api_models::enums::PaymentMethod::OpenBanking
-            | api_models::enums::PaymentMethod::GiftCard => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message(
-                        "complete authorize flow",
-                    ),
-                )
-                .into())
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AuthResponse {
-    data: DataAuthResponse,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeAuthResponse {
-    AuthResponse(Box<AuthResponse>),
-    ClientTokenResponse(Box<ClientTokenResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeCompleteAuthResponse {
-    AuthResponse(Box<AuthResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-struct PaymentMethodInfo {
-    id: Secret<String>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TransactionAuthChargeResponseBody {
-    id: String,
-    status: BraintreePaymentStatus,
-    payment_method: Option<PaymentMethodInfo>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DataAuthResponse {
-    authorize_credit_card: AuthChargeCreditCard,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AuthChargeCreditCard {
-    transaction: TransactionAuthChargeResponseBody,
-}
-
-impl<F>
-    TryFrom<
-        types::ResponseRouterData<
-            F,
-            BraintreeAuthResponse,
-            types::PaymentsAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    > for types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<
-            F,
-            BraintreeAuthResponse,
-            types::PaymentsAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeAuthResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors, item.http_code),
-                ..item.data
-            }),
-            BraintreeAuthResponse::AuthResponse(auth_response) => {
-                let transaction_data = auth_response.data.authorize_credit_card.transaction;
-
-                Ok(Self {
-                    status: enums::AttemptStatus::from(transaction_data.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
-                        redirection_data: None,
-                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
-                            MandateReference {
-                                connector_mandate_id: Some(pm.id.clone().expose()),
-                                payment_method_id: None,
-                            }
-                        }),
-                        connector_metadata: None,
-                        network_txn_id: None,
-                        connector_response_reference_id: None,
-                        incremental_authorization_allowed: None,
-                        charge_id: None,
-                    }),
-                    ..item.data
-                })
-            }
-            BraintreeAuthResponse::ClientTokenResponse(client_token_data) => Ok(Self {
-                status: enums::AttemptStatus::AuthenticationPending,
-                response: Ok(types::PaymentsResponseData::TransactionResponse {
-                    resource_id: types::ResponseId::NoResponseId,
-                    redirection_data: Some(get_braintree_redirect_form(
-                        *client_token_data,
-                        item.data.get_payment_method_token()?,
-                        item.data.request.payment_method_data.clone(),
-                    )?),
-                    mandate_reference: None,
-                    connector_metadata: None,
-                    network_txn_id: None,
-                    connector_response_reference_id: None,
-                    incremental_authorization_allowed: None,
-                    charge_id: None,
-                }),
-                ..item.data
-            }),
-        }
-    }
-}
-
-fn build_error_response<T>(
-    response: &[ErrorDetails],
-    http_code: u16,
-) -> Result<T, types::ErrorResponse> {
-    let error_messages = response
-        .iter()
-        .map(|error| error.message.to_string())
-        .collect::<Vec<String>>();
-
-    let reason = match !error_messages.is_empty() {
-        true => Some(error_messages.join(" ")),
-        false => None,
-    };
-
-    get_error_response(
-        response
-            .first()
-            .and_then(|err_details| err_details.extensions.as_ref())
-            .and_then(|extensions| extensions.legacy_code.clone()),
-        response
-            .first()
-            .map(|err_details| err_details.message.clone()),
-        reason,
-        http_code,
-    )
-}
-
-fn get_error_response<T>(
-    error_code: Option<String>,
-    error_msg: Option<String>,
-    error_reason: Option<String>,
-    http_code: u16,
-) -> Result<T, types::ErrorResponse> {
-    Err(types::ErrorResponse {
-        code: error_code.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
-        message: error_msg.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
-        reason: error_reason,
-        status_code: http_code,
-        attempt_status: None,
-        connector_transaction_id: None,
-    })
-}
-
-// Using Auth type from braintree/transformer.rs, need this in later time when we use graphql version
-// pub struct BraintreeAuthType {
-//     pub(super) auth_header: String,
-//     pub(super) merchant_id: Secret<String>,
-// }
-
-// impl TryFrom<&types::ConnectorAuthType> for BraintreeAuthType {
-//     type Error = error_stack::Report<errors::ConnectorError>;
-//     fn try_from(item: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
-//         if let types::ConnectorAuthType::SignatureKey {
-//             api_key: public_key,
-//             key1: merchant_id,
-//             api_secret: private_key,
-//         } = item
-//         {
-//             let auth_key = format!("{}:{}", public_key.peek(), private_key.peek());
-//             let auth_header = format!("Basic {}", consts::BASE64_ENGINE.encode(auth_key));
-//             Ok(Self {
-//                 auth_header,
-//                 merchant_id: merchant_id.to_owned(),
-//             })
-//         } else {
-//             Err(errors::ConnectorError::FailedToObtainAuthType)?
-//         }
-//     }
-// }
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum BraintreePaymentStatus {
-    Authorized,
-    Authorizing,
-    AuthorizedExpired,
-    Failed,
-    ProcessorDeclined,
-    GatewayRejected,
-    Voided,
-    Settling,
-    Settled,
-    SettlementPending,
-    SettlementDeclined,
-    SettlementConfirmed,
-    SubmittedForSettlement,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ErrorDetails {
-    pub message: String,
-    pub extensions: Option<AdditionalErrorDetails>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AdditionalErrorDetails {
-    pub legacy_code: Option<String>,
-}
-
-impl From<BraintreePaymentStatus> for enums::AttemptStatus {
-    fn from(item: BraintreePaymentStatus) -> Self {
-        match item {
-            BraintreePaymentStatus::Settling
-            | BraintreePaymentStatus::Settled
-            | BraintreePaymentStatus::SettlementConfirmed => Self::Charged,
-            BraintreePaymentStatus::Authorizing => Self::Authorizing,
-            BraintreePaymentStatus::AuthorizedExpired => Self::AuthorizationFailed,
-            BraintreePaymentStatus::Failed
-            | BraintreePaymentStatus::GatewayRejected
-            | BraintreePaymentStatus::ProcessorDeclined
-            | BraintreePaymentStatus::SettlementDeclined => Self::Failure,
-            BraintreePaymentStatus::Authorized => Self::Authorized,
-            BraintreePaymentStatus::Voided => Self::Voided,
-            BraintreePaymentStatus::SubmittedForSettlement
-            | BraintreePaymentStatus::SettlementPending => Self::Pending,
-        }
-    }
-}
-
-impl<F>
-    TryFrom<
-        types::ResponseRouterData<
-            F,
-            BraintreePaymentsResponse,
-            types::PaymentsAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    > for types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<
-            F,
-            BraintreePaymentsResponse,
-            types::PaymentsAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors.clone(), item.http_code),
-                ..item.data
-            }),
-            BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
-                let transaction_data = payment_response.data.charge_credit_card.transaction;
-
-                Ok(Self {
-                    status: enums::AttemptStatus::from(transaction_data.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
-                        redirection_data: None,
-                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
-                            MandateReference {
-                                connector_mandate_id: Some(pm.id.clone().expose()),
-                                payment_method_id: None,
-                            }
-                        }),
-                        connector_metadata: None,
-                        network_txn_id: None,
-                        connector_response_reference_id: None,
-                        incremental_authorization_allowed: None,
-                        charge_id: None,
-                    }),
-                    ..item.data
-                })
-            }
-            BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
-                status: enums::AttemptStatus::AuthenticationPending,
-                response: Ok(types::PaymentsResponseData::TransactionResponse {
-                    resource_id: types::ResponseId::NoResponseId,
-                    redirection_data: Some(get_braintree_redirect_form(
-                        *client_token_data,
-                        item.data.get_payment_method_token()?,
-                        item.data.request.payment_method_data.clone(),
-                    )?),
-                    mandate_reference: None,
-                    connector_metadata: None,
-                    network_txn_id: None,
-                    connector_response_reference_id: None,
-                    incremental_authorization_allowed: None,
-                    charge_id: None,
-                }),
-                ..item.data
-            }),
-        }
-    }
-}
-
-impl<F>
-    TryFrom<
-        types::ResponseRouterData<
-            F,
-            BraintreeCompleteChargeResponse,
-            types::CompleteAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    > for types::RouterData<F, types::CompleteAuthorizeData, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<
-            F,
-            BraintreeCompleteChargeResponse,
-            types::CompleteAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeCompleteChargeResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors.clone(), item.http_code),
-                ..item.data
-            }),
-            BraintreeCompleteChargeResponse::PaymentsResponse(payment_response) => {
-                let transaction_data = payment_response.data.charge_credit_card.transaction;
-
-                Ok(Self {
-                    status: enums::AttemptStatus::from(transaction_data.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
-                        redirection_data: None,
-                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
-                            MandateReference {
-                                connector_mandate_id: Some(pm.id.clone().expose()),
-                                payment_method_id: None,
-                            }
-                        }),
-                        connector_metadata: None,
-                        network_txn_id: None,
-                        connector_response_reference_id: None,
-                        incremental_authorization_allowed: None,
-                        charge_id: None,
-                    }),
-                    ..item.data
-                })
-            }
-        }
-    }
-}
-
-impl<F>
-    TryFrom<
-        types::ResponseRouterData<
-            F,
-            BraintreeCompleteAuthResponse,
-            types::CompleteAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    > for types::RouterData<F, types::CompleteAuthorizeData, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<
-            F,
-            BraintreeCompleteAuthResponse,
-            types::CompleteAuthorizeData,
-            types::PaymentsResponseData,
-        >,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeCompleteAuthResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors, item.http_code),
-                ..item.data
-            }),
-            BraintreeCompleteAuthResponse::AuthResponse(auth_response) => {
-                let transaction_data = auth_response.data.authorize_credit_card.transaction;
-
-                Ok(Self {
-                    status: enums::AttemptStatus::from(transaction_data.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
-                        redirection_data: None,
-                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
-                            MandateReference {
-                                connector_mandate_id: Some(pm.id.clone().expose()),
-                                payment_method_id: None,
-                            }
-                        }),
-                        connector_metadata: None,
-                        network_txn_id: None,
-                        connector_response_reference_id: None,
-                        incremental_authorization_allowed: None,
-                        charge_id: None,
-                    }),
-                    ..item.data
-                })
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct PaymentsResponse {
-    data: DataResponse,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreePaymentsResponse {
-    PaymentsResponse(Box<PaymentsResponse>),
-    ClientTokenResponse(Box<ClientTokenResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeCompleteChargeResponse {
-    PaymentsResponse(Box<PaymentsResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DataResponse {
-    charge_credit_card: AuthChargeCreditCard,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RefundInputData {
-    amount: String,
-    merchant_account_id: Secret<String>,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeRefundInput {
-    transaction_id: String,
-    refund: RefundInputData,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeRefundVariables {
-    input: BraintreeRefundInput,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeRefundRequest {
-    query: String,
-    variables: BraintreeRefundVariables,
-}
-
-impl<F> TryFrom<BraintreeRouterData<&types::RefundsRouterData<F>>> for BraintreeRefundRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: BraintreeRouterData<&types::RefundsRouterData<F>>,
-    ) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
-                .change_context(errors::ConnectorError::InvalidConnectorConfig {
-                    config: "metadata",
-                })?;
-
-        utils::validate_currency(
-            item.router_data.request.currency,
-            Some(metadata.merchant_config_currency),
-        )?;
-        let query = REFUND_TRANSACTION_MUTATION.to_string();
-        let variables = BraintreeRefundVariables {
-            input: BraintreeRefundInput {
-                transaction_id: item.router_data.request.connector_transaction_id.clone(),
-                refund: RefundInputData {
-                    amount: item.amount,
-                    merchant_account_id: metadata.merchant_account_id,
-                },
-            },
-        };
-        Ok(Self { query, variables })
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum BraintreeRefundStatus {
-    SettlementPending,
-    Settling,
-    Settled,
-    SubmittedForSettlement,
-    Failed,
-}
-
-impl From<BraintreeRefundStatus> for enums::RefundStatus {
-    fn from(item: BraintreeRefundStatus) -> Self {
-        match item {
-            BraintreeRefundStatus::Settled | BraintreeRefundStatus::Settling => Self::Success,
-            BraintreeRefundStatus::SubmittedForSettlement
-            | BraintreeRefundStatus::SettlementPending => Self::Pending,
-            BraintreeRefundStatus::Failed => Self::Failure,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct BraintreeRefundTransactionBody {
-    pub id: String,
-    pub status: BraintreeRefundStatus,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct BraintreeRefundTransaction {
-    pub refund: BraintreeRefundTransactionBody,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeRefundResponseData {
-    pub refund_transaction: BraintreeRefundTransaction,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-
-pub struct RefundResponse {
-    pub data: BraintreeRefundResponseData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeRefundResponse {
-    RefundResponse(Box<RefundResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-impl TryFrom<types::RefundsResponseRouterData<api::Execute, BraintreeRefundResponse>>
-    for types::RefundsRouterData<api::Execute>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::RefundsResponseRouterData<api::Execute, BraintreeRefundResponse>,
-    ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: match item.response {
-                BraintreeRefundResponse::ErrorResponse(error_response) => {
-                    build_error_response(&error_response.errors, item.http_code)
-                }
-                BraintreeRefundResponse::RefundResponse(refund_data) => {
-                    let refund_data = refund_data.data.refund_transaction.refund;
-
-                    Ok(types::RefundsResponseData {
-                        connector_refund_id: refund_data.id.clone(),
-                        refund_status: enums::RefundStatus::from(refund_data.status),
-                    })
-                }
-            },
-            ..item.data
-        })
-    }
-}
-
-#[derive(Debug, Serialize)]
-pub struct BraintreeRSyncRequest {
-    query: String,
-}
-
-impl TryFrom<&types::RefundSyncRouterData> for BraintreeRSyncRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta = utils::to_connector_meta_from_secret(
-            item.connector_meta_data.clone(),
-        )
-        .change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
-        utils::validate_currency(
-            item.request.currency,
-            Some(metadata.merchant_config_currency),
-        )?;
-        let refund_id = item.request.get_connector_refund_id()?;
-        let query = format!("query {{ search {{ refunds(input: {{ id: {{is: \"{}\"}} }}, first: 1) {{ edges {{ node {{ id status createdAt amount {{ value currencyCode }} orderId }} }} }} }} }}",refund_id);
-
-        Ok(Self { query })
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RSyncNodeData {
-    id: String,
-    status: BraintreeRefundStatus,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RSyncEdgeData {
-    node: RSyncNodeData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RefundData {
-    edges: Vec<RSyncEdgeData>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RSyncSearchData {
-    refunds: RefundData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RSyncResponseData {
-    search: RSyncSearchData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct RSyncResponse {
-    data: RSyncResponseData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeRSyncResponse {
-    RSyncResponse(Box<RSyncResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-impl TryFrom<types::RefundsResponseRouterData<api::RSync, BraintreeRSyncResponse>>
-    for types::RefundsRouterData<api::RSync>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::RefundsResponseRouterData<api::RSync, BraintreeRSyncResponse>,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeRSyncResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors, item.http_code),
-                ..item.data
-            }),
-            BraintreeRSyncResponse::RSyncResponse(rsync_response) => {
-                let edge_data = rsync_response
-                    .data
-                    .search
-                    .refunds
-                    .edges
-                    .first()
-                    .ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
-                let connector_refund_id = &edge_data.node.id;
-                let response = Ok(types::RefundsResponseData {
-                    connector_refund_id: connector_refund_id.to_string(),
-                    refund_status: enums::RefundStatus::from(edge_data.node.status.clone()),
-                });
-                Ok(Self {
-                    response,
-                    ..item.data
-                })
-            }
-        }
-    }
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CreditCardData {
-    number: cards::CardNumber,
-    expiration_year: Secret<String>,
-    expiration_month: Secret<String>,
-    cvv: Secret<String>,
-    cardholder_name: Secret<String>,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClientTokenInput {
-    merchant_account_id: Secret<String>,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InputData {
-    credit_card: CreditCardData,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct InputClientTokenData {
-    client_token: ClientTokenInput,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct VariableInput {
-    input: InputData,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct VariableClientTokenInput {
-    input: InputClientTokenData,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeTokenRequest {
-    query: String,
-    variables: VariableInput,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeClientTokenRequest {
-    query: String,
-    variables: VariableClientTokenInput,
-}
-
-impl TryFrom<&types::TokenizationRouterData> for BraintreeTokenRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
-        match item.request.payment_method_data.clone() {
-            domain::PaymentMethodData::Card(card_data) => {
-                let query = TOKENIZE_CREDIT_CARD.to_string();
-                let input = InputData {
-                    credit_card: CreditCardData {
-                        number: card_data.card_number,
-                        expiration_year: card_data.card_exp_year,
-                        expiration_month: card_data.card_exp_month,
-                        cvv: card_data.card_cvc,
-                        cardholder_name: item
-                            .get_optional_billing_full_name()
-                            .unwrap_or(Secret::new("".to_string())),
-                    },
-                };
-                Ok(Self {
-                    query,
-                    variables: VariableInput { input },
-                })
-            }
-            domain::PaymentMethodData::CardRedirect(_)
-            | domain::PaymentMethodData::Wallet(_)
-            | domain::PaymentMethodData::PayLater(_)
-            | domain::PaymentMethodData::BankRedirect(_)
-            | domain::PaymentMethodData::BankDebit(_)
-            | domain::PaymentMethodData::BankTransfer(_)
-            | domain::PaymentMethodData::Crypto(_)
-            | domain::PaymentMethodData::MandatePayment
-            | domain::PaymentMethodData::Reward
-            | domain::PaymentMethodData::RealTimePayment(_)
-            | domain::PaymentMethodData::Upi(_)
-            | domain::PaymentMethodData::Voucher(_)
-            | domain::PaymentMethodData::GiftCard(_)
-            | domain::PaymentMethodData::OpenBanking(_)
-            | domain::PaymentMethodData::CardToken(_) => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("braintree"),
-                )
-                .into())
-            }
-        }
-    }
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct TokenizePaymentMethodData {
-    id: Secret<String>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TokenizeCreditCardData {
-    payment_method: TokenizePaymentMethodData,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClientToken {
-    client_token: Secret<String>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TokenizeCreditCard {
-    tokenize_credit_card: TokenizeCreditCardData,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClientTokenData {
-    create_client_token: ClientToken,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ClientTokenResponse {
-    data: ClientTokenData,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct TokenResponse {
-    data: TokenizeCreditCard,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct ErrorResponse {
-    errors: Vec<ErrorDetails>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeTokenResponse {
-    TokenResponse(Box<TokenResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-impl<F, T>
-    TryFrom<types::ResponseRouterData<F, BraintreeTokenResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<F, BraintreeTokenResponse, T, types::PaymentsResponseData>,
-    ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: match item.response {
-                BraintreeTokenResponse::ErrorResponse(error_response) => {
-                    build_error_response(error_response.errors.as_ref(), item.http_code)
-                }
-
-                BraintreeTokenResponse::TokenResponse(token_response) => {
-                    Ok(types::PaymentsResponseData::TokenizationResponse {
-                        token: token_response
-                            .data
-                            .tokenize_credit_card
-                            .payment_method
-                            .id
-                            .expose()
-                            .clone(),
-                    })
-                }
-            },
-            ..item.data
-        })
-    }
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CaptureTransactionBody {
-    amount: String,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CaptureInputData {
-    transaction_id: String,
-    transaction: CaptureTransactionBody,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct VariableCaptureInput {
-    input: CaptureInputData,
-}
-
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeCaptureRequest {
-    query: String,
-    variables: VariableCaptureInput,
-}
-
-impl TryFrom<&BraintreeRouterData<&types::PaymentsCaptureRouterData>> for BraintreeCaptureRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: &BraintreeRouterData<&types::PaymentsCaptureRouterData>,
-    ) -> Result<Self, Self::Error> {
-        let query = CAPTURE_TRANSACTION_MUTATION.to_string();
-        let variables = VariableCaptureInput {
-            input: CaptureInputData {
-                transaction_id: item.router_data.request.connector_transaction_id.clone(),
-                transaction: CaptureTransactionBody {
-                    amount: item.amount.to_owned(),
-                },
-            },
-        };
-        Ok(Self { query, variables })
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CaptureResponseTransactionBody {
-    id: String,
-    status: BraintreePaymentStatus,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CaptureTransactionData {
-    transaction: CaptureResponseTransactionBody,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CaptureResponseData {
-    capture_transaction: CaptureTransactionData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CaptureResponse {
-    data: CaptureResponseData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeCaptureResponse {
-    CaptureResponse(Box<CaptureResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-impl TryFrom<types::PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>>
-    for types::PaymentsCaptureRouterData
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeCaptureResponse::CaptureResponse(capture_data) => {
-                let transaction_data = capture_data.data.capture_transaction.transaction;
-
-                Ok(Self {
-                    status: enums::AttemptStatus::from(transaction_data.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.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,
-                    }),
-                    ..item.data
-                })
-            }
-            BraintreeCaptureResponse::ErrorResponse(error_data) => Ok(Self {
-                response: build_error_response(&error_data.errors, item.http_code),
-                ..item.data
-            }),
-        }
-    }
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CancelInputData {
-    transaction_id: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct VariableCancelInput {
-    input: CancelInputData,
-}
-
-#[derive(Debug, Serialize)]
-pub struct BraintreeCancelRequest {
-    query: String,
-    variables: VariableCancelInput,
-}
-
-impl TryFrom<&types::PaymentsCancelRouterData> for BraintreeCancelRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
-        let query = VOID_TRANSACTION_MUTATION.to_string();
-        let variables = VariableCancelInput {
-            input: CancelInputData {
-                transaction_id: item.request.connector_transaction_id.clone(),
-            },
-        };
-        Ok(Self { query, variables })
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CancelResponseTransactionBody {
-    id: String,
-    status: BraintreePaymentStatus,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CancelTransactionData {
-    reversal: CancelResponseTransactionBody,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CancelResponseData {
-    reverse_transaction: CancelTransactionData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CancelResponse {
-    data: CancelResponseData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreeCancelResponse {
-    CancelResponse(Box<CancelResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-impl<F, T>
-    TryFrom<types::ResponseRouterData<F, BraintreeCancelResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<F, BraintreeCancelResponse, T, types::PaymentsResponseData>,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreeCancelResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors, item.http_code),
-                ..item.data
-            }),
-            BraintreeCancelResponse::CancelResponse(void_response) => {
-                let void_data = void_response.data.reverse_transaction.reversal;
-
-                let transaction_id = void_data.id;
-                Ok(Self {
-                    status: enums::AttemptStatus::from(void_data.status),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_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,
-                    }),
-                    ..item.data
-                })
-            }
-        }
-    }
-}
-
-#[derive(Debug, Serialize)]
-pub struct BraintreePSyncRequest {
-    query: String,
-}
-
-impl TryFrom<&types::PaymentsSyncRouterData> for BraintreePSyncRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
-        let transaction_id = item
-            .request
-            .connector_transaction_id
-            .get_connector_transaction_id()
-            .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
-        let query = format!("query {{ search {{ transactions(input: {{ id: {{is: \"{}\"}} }}, first: 1) {{ edges {{ node {{ id status createdAt amount {{ value currencyCode }} orderId }} }} }} }} }}", transaction_id);
-        Ok(Self { query })
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct NodeData {
-    id: String,
-    status: BraintreePaymentStatus,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct EdgeData {
-    node: NodeData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct TransactionData {
-    edges: Vec<EdgeData>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct SearchData {
-    transactions: TransactionData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct PSyncResponseData {
-    search: SearchData,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum BraintreePSyncResponse {
-    PSyncResponse(Box<PSyncResponse>),
-    ErrorResponse(Box<ErrorResponse>),
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct PSyncResponse {
-    data: PSyncResponseData,
-}
-
-impl<F, T>
-    TryFrom<types::ResponseRouterData<F, BraintreePSyncResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: types::ResponseRouterData<F, BraintreePSyncResponse, T, types::PaymentsResponseData>,
-    ) -> Result<Self, Self::Error> {
-        match item.response {
-            BraintreePSyncResponse::ErrorResponse(error_response) => Ok(Self {
-                response: build_error_response(&error_response.errors, item.http_code),
-                ..item.data
-            }),
-            BraintreePSyncResponse::PSyncResponse(psync_response) => {
-                let edge_data = psync_response
-                    .data
-                    .search
-                    .transactions
-                    .edges
-                    .first()
-                    .ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
-                let transaction_id = &edge_data.node.id;
-                Ok(Self {
-                    status: enums::AttemptStatus::from(edge_data.node.status.clone()),
-                    response: Ok(types::PaymentsResponseData::TransactionResponse {
-                        resource_id: types::ResponseId::ConnectorTransactionId(
-                            transaction_id.to_string(),
-                        ),
-                        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,
-                    }),
-                    ..item.data
-                })
-            }
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeThreeDsResponse {
-    pub nonce: Secret<String>,
-    pub liability_shifted: bool,
-    pub liability_shift_possible: bool,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeThreeDsErrorResponse {
-    pub code: String,
-    pub message: String,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BraintreeRedirectionResponse {
-    pub authentication_response: String,
-}
-
-impl TryFrom<BraintreeMeta> for BraintreeClientTokenRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(metadata: BraintreeMeta) -> Result<Self, Self::Error> {
-        Ok(Self {
-            query: CLIENT_TOKEN_MUTATION.to_owned(),
-            variables: VariableClientTokenInput {
-                input: InputClientTokenData {
-                    client_token: ClientTokenInput {
-                        merchant_account_id: metadata.merchant_account_id,
-                    },
-                },
-            },
-        })
-    }
-}
-
-impl
-    TryFrom<(
-        &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
-        BraintreeMeta,
-    )> for CardPaymentRequest
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        (item, metadata): (
-            &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
-            BraintreeMeta,
-        ),
-    ) -> Result<Self, Self::Error> {
-        let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
-            (
-                match item.router_data.request.is_auto_capture()? {
-                    true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
-                    false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
-                },
-                TransactionBody::Vault(VaultTransactionBody {
-                    amount: item.amount.to_owned(),
-                    merchant_account_id: metadata.merchant_account_id,
-                    vault_payment_method_after_transacting: TransactionTiming {
-                        when: "ALWAYS".to_string(),
-                    },
-                }),
-            )
-        } else {
-            (
-                match item.router_data.request.is_auto_capture()? {
-                    true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
-                    false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
-                },
-                TransactionBody::Regular(RegularTransactionBody {
-                    amount: item.amount.to_owned(),
-                    merchant_account_id: metadata.merchant_account_id,
-                }),
-            )
-        };
-        Ok(Self {
-            query,
-            variables: VariablePaymentInput {
-                input: PaymentInput {
-                    payment_method_id: match item.router_data.get_payment_method_token()? {
-                        types::PaymentMethodToken::Token(token) => token,
-                        types::PaymentMethodToken::ApplePayDecrypt(_) => Err(
-                            unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
-                        )?,
-                    },
-                    transaction: transaction_body,
-                },
-            },
-        })
-    }
-}
-
-impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
-    for CardPaymentRequest
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(
-        item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
-    ) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
-                .change_context(errors::ConnectorError::InvalidConnectorConfig {
-                    config: "metadata",
-                })?;
-        utils::validate_currency(
-            item.router_data.request.currency,
-            Some(metadata.merchant_config_currency),
-        )?;
-        let payload_data = PaymentsCompleteAuthorizeRequestData::get_redirect_response_payload(
-            &item.router_data.request,
-        )?
-        .expose();
-        let redirection_response: BraintreeRedirectionResponse = serde_json::from_value(
-            payload_data,
-        )
-        .change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
-            field_name: "redirection_response",
-        })?;
-        let three_ds_data = serde_json::from_str::<BraintreeThreeDsResponse>(
-            &redirection_response.authentication_response,
-        )
-        .change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
-            field_name: "three_ds_data",
-        })?;
-
-        let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
-            (
-                match item.router_data.request.is_auto_capture()? {
-                    true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
-                    false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
-                },
-                TransactionBody::Vault(VaultTransactionBody {
-                    amount: item.amount.to_owned(),
-                    merchant_account_id: metadata.merchant_account_id,
-                    vault_payment_method_after_transacting: TransactionTiming {
-                        when: "ALWAYS".to_string(),
-                    },
-                }),
-            )
-        } else {
-            (
-                match item.router_data.request.is_auto_capture()? {
-                    true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
-                    false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
-                },
-                TransactionBody::Regular(RegularTransactionBody {
-                    amount: item.amount.to_owned(),
-                    merchant_account_id: metadata.merchant_account_id,
-                }),
-            )
-        };
-        Ok(Self {
-            query,
-            variables: VariablePaymentInput {
-                input: PaymentInput {
-                    payment_method_id: three_ds_data.nonce,
-                    transaction: transaction_body,
-                },
-            },
-        })
-    }
-}
-
-fn get_braintree_redirect_form(
-    client_token_data: ClientTokenResponse,
-    payment_method_token: types::PaymentMethodToken,
-    card_details: domain::PaymentMethodData,
-) -> Result<services::RedirectForm, error_stack::Report<errors::ConnectorError>> {
-    Ok(services::RedirectForm::Braintree {
-        client_token: client_token_data
-            .data
-            .create_client_token
-            .client_token
-            .expose(),
-        card_token: match payment_method_token {
-            types::PaymentMethodToken::Token(token) => token.expose(),
-            types::PaymentMethodToken::ApplePayDecrypt(_) => Err(unimplemented_payment_method!(
-                "Apple Pay",
-                "Simplified",
-                "Braintree"
-            ))?,
-        },
-        bin: match card_details {
-            domain::PaymentMethodData::Card(card_details) => {
-                card_details.card_number.get_card_isin()
-            }
-            domain::PaymentMethodData::CardRedirect(_)
-            | domain::PaymentMethodData::Wallet(_)
-            | domain::PaymentMethodData::PayLater(_)
-            | domain::PaymentMethodData::BankRedirect(_)
-            | domain::PaymentMethodData::BankDebit(_)
-            | domain::PaymentMethodData::BankTransfer(_)
-            | domain::PaymentMethodData::Crypto(_)
-            | domain::PaymentMethodData::MandatePayment
-            | domain::PaymentMethodData::Reward
-            | domain::PaymentMethodData::RealTimePayment(_)
-            | domain::PaymentMethodData::Upi(_)
-            | domain::PaymentMethodData::Voucher(_)
-            | domain::PaymentMethodData::GiftCard(_)
-            | domain::PaymentMethodData::OpenBanking(_)
-            | domain::PaymentMethodData::CardToken(_) => Err(
-                errors::ConnectorError::NotImplemented("given payment method".to_owned()),
-            )?,
-        },
-    })
-}
-
-#[derive(Debug, Deserialize)]
-pub struct BraintreeWebhookResponse {
-    pub bt_signature: String,
-    pub bt_payload: String,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub struct Notification {
-    pub kind: String, // xml parse only string to fields
-    pub timestamp: String,
-    pub dispute: Option<BraintreeDisputeData>,
-}
-impl types::transformers::ForeignFrom<&str> for api_models::webhooks::IncomingWebhookEvent {
-    fn foreign_from(status: &str) -> Self {
-        match status {
-            "dispute_opened" => Self::DisputeOpened,
-            "dispute_lost" => Self::DisputeLost,
-            "dispute_won" => Self::DisputeWon,
-            "dispute_accepted" | "dispute_auto_accepted" => Self::DisputeAccepted,
-            "dispute_expired" => Self::DisputeExpired,
-            "dispute_disputed" => Self::DisputeChallenged,
-            _ => Self::EventNotSupported,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct BraintreeDisputeData {
-    pub amount_disputed: i64,
-    pub amount_won: Option<String>,
-    pub case_number: Option<String>,
-    pub chargeback_protection_level: Option<String>,
-    pub currency_iso_code: String,
-    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
-    pub created_at: Option<PrimitiveDateTime>,
-    pub evidence: Option<DisputeEvidence>,
-    pub id: String,
-    pub kind: String, // xml parse only string to fields
-    pub status: String,
-    pub reason: Option<String>,
-    pub reason_code: Option<String>,
-    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
-    pub updated_at: Option<PrimitiveDateTime>,
-    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
-    pub reply_by_date: Option<PrimitiveDateTime>,
-    pub transaction: DisputeTransaction,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct DisputeTransaction {
-    pub amount: String,
-    pub id: String,
-}
-#[derive(Debug, Deserialize, Serialize)]
-pub struct DisputeEvidence {
-    pub comment: String,
-    pub id: Secret<String>,
-    pub created_at: Option<PrimitiveDateTime>,
-    pub url: url::Url,
-}
-
-pub(crate) fn get_dispute_stage(code: &str) -> Result<enums::DisputeStage, errors::ConnectorError> {
-    match code {
-        "CHARGEBACK" => Ok(enums::DisputeStage::Dispute),
-        "PRE_ARBITATION" => Ok(enums::DisputeStage::PreArbitration),
-        "RETRIEVAL" => Ok(enums::DisputeStage::PreDispute),
-        _ => Err(errors::ConnectorError::WebhookBodyDecodingFailed),
-    }
-}
diff --git a/crates/router/src/connector/braintree/transformers.rs b/crates/router/src/connector/braintree/transformers.rs
index 717c4afc195..8a4ce8126dd 100644
--- a/crates/router/src/connector/braintree/transformers.rs
+++ b/crates/router/src/connector/braintree/transformers.rs
@@ -1,175 +1,308 @@
-use api_models::payments;
-use base64::Engine;
-use masking::{ExposeInterface, PeekInterface, Secret};
+use common_utils::{pii, types::StringMajorUnit};
+use error_stack::ResultExt;
+use masking::{ExposeInterface, Secret};
 use serde::{Deserialize, Serialize};
+use time::PrimitiveDateTime;
 
 use crate::{
-    connector::utils::{self},
+    connector::utils::{
+        self, PaymentsAuthorizeRequestData, PaymentsCompleteAuthorizeRequestData,
+        RefundsRequestData, RouterData,
+    },
     consts,
     core::errors,
-    types::{self, api, domain, storage::enums},
+    services,
+    types::{self, api, domain, storage::enums, MandateReference},
+    unimplemented_payment_method,
 };
+pub const CHANNEL_CODE: &str = "HyperSwitchBT_Ecom";
+pub const CLIENT_TOKEN_MUTATION: &str = "mutation createClientToken($input: CreateClientTokenInput!) { createClientToken(input: $input) { clientToken}}";
+pub const TOKENIZE_CREDIT_CARD: &str = "mutation  tokenizeCreditCard($input: TokenizeCreditCardInput!) { tokenizeCreditCard(input: $input) { clientMutationId paymentMethod { id } } }";
+pub const CHARGE_CREDIT_CARD_MUTATION: &str = "mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id legacyId createdAt amount { value currencyCode } status } } }";
+pub const AUTHORIZE_CREDIT_CARD_MUTATION: &str = "mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) {  transaction { id legacyId amount { value currencyCode } status } } }";
+pub const CAPTURE_TRANSACTION_MUTATION: &str = "mutation captureTransaction($input: CaptureTransactionInput!) { captureTransaction(input: $input) { clientMutationId transaction { id legacyId amount { value currencyCode } status } } }";
+pub const VOID_TRANSACTION_MUTATION: &str = "mutation voidTransaction($input:  ReverseTransactionInput!) { reverseTransaction(input: $input) { clientMutationId reversal { ...  on Transaction { id legacyId amount { value currencyCode } status } } } }";
+pub const REFUND_TRANSACTION_MUTATION: &str = "mutation refundTransaction($input:  RefundTransactionInput!) { refundTransaction(input: $input) {clientMutationId refund { id legacyId amount { value currencyCode } status } } }";
+pub const AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION: &str="mutation authorizeCreditCard($input: AuthorizeCreditCardInput!) { authorizeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
+pub const CHARGE_AND_VAULT_TRANSACTION_MUTATION: &str ="mutation ChargeCreditCard($input: ChargeCreditCardInput!) { chargeCreditCard(input: $input) { transaction { id status createdAt paymentMethod { id } } } }";
+pub const TRANSACTION_QUERY: &str = "query($input: TransactionSearchInput!) { search { transactions(input: $input) { edges { node { id status } } } } }";
+pub const REFUND_QUERY: &str = "query($input: RefundSearchInput!) { search { refunds(input: $input, first: 1) { edges { node { id status createdAt amount { value currencyCode } orderId } } } } }";
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct DeviceData;
+pub type CardPaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
+pub type MandatePaymentRequest = GenericBraintreeRequest<VariablePaymentInput>;
+pub type BraintreeClientTokenRequest = GenericBraintreeRequest<VariableClientTokenInput>;
+pub type BraintreeTokenRequest = GenericBraintreeRequest<VariableInput>;
+pub type BraintreeCaptureRequest = GenericBraintreeRequest<VariableCaptureInput>;
+pub type BraintreeRefundRequest = GenericBraintreeRequest<BraintreeRefundVariables>;
+pub type BraintreePSyncRequest = GenericBraintreeRequest<PSyncInput>;
+pub type BraintreeRSyncRequest = GenericBraintreeRequest<RSyncInput>;
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct PaymentOptions {
-    submit_for_settlement: bool,
+pub type BraintreeRefundResponse = GenericBraintreeResponse<RefundResponse>;
+pub type BraintreeCaptureResponse = GenericBraintreeResponse<CaptureResponse>;
+pub type BraintreePSyncResponse = GenericBraintreeResponse<PSyncResponse>;
+
+pub type VariablePaymentInput = GenericVariableInput<PaymentInput>;
+pub type VariableClientTokenInput = GenericVariableInput<InputClientTokenData>;
+pub type VariableInput = GenericVariableInput<InputData>;
+pub type VariableCaptureInput = GenericVariableInput<CaptureInputData>;
+pub type BraintreeRefundVariables = GenericVariableInput<BraintreeRefundInput>;
+pub type PSyncInput = GenericVariableInput<TransactionSearchInput>;
+pub type RSyncInput = GenericVariableInput<RefundSearchInput>;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct GenericBraintreeRequest<T> {
+    query: String,
+    variables: T,
+}
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum GenericBraintreeResponse<T> {
+    SuccessResponse(Box<T>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+#[derive(Debug, Clone, Serialize)]
+pub struct GenericVariableInput<T> {
+    input: T,
 }
 
-#[derive(Debug, Deserialize)]
-pub struct BraintreeMeta {
-    merchant_account_id: Option<Secret<String>>,
-    merchant_config_currency: Option<enums::Currency>,
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+
+pub struct BraintreeApiErrorResponse {
+    pub api_error_response: ApiErrorResponse,
 }
 
-#[derive(Debug, Serialize, Eq, PartialEq)]
-pub struct BraintreePaymentsRequest {
-    transaction: TransactionBody,
+#[derive(Debug, Deserialize, Serialize)]
+
+pub struct ErrorsObject {
+    pub errors: Vec<ErrorObject>,
+
+    pub transaction: Option<TransactionError>,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct BraintreeApiVersion {
-    version: String,
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+
+pub struct TransactionError {
+    pub errors: Vec<ErrorObject>,
+    pub credit_card: Option<CreditCardError>,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct BraintreeSessionRequest {
-    client_token: BraintreeApiVersion,
+#[derive(Debug, Deserialize, Serialize)]
+pub struct CreditCardError {
+    pub errors: Vec<ErrorObject>,
+}
+#[derive(Debug, Serialize)]
+pub struct BraintreeRouterData<T> {
+    pub amount: StringMajorUnit,
+    pub router_data: T,
 }
 
-impl TryFrom<&types::PaymentsSessionRouterData> for BraintreeSessionRequest {
+impl<T> TryFrom<(StringMajorUnit, T)> for BraintreeRouterData<T> {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(_item: &types::PaymentsSessionRouterData) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(_item.connector_meta_data.clone())?;
-
-        utils::validate_currency(_item.request.currency, metadata.merchant_config_currency)?;
+    fn try_from((amount, item): (StringMajorUnit, T)) -> Result<Self, Self::Error> {
         Ok(Self {
-            client_token: BraintreeApiVersion {
-                version: "2".to_string(),
-            },
+            amount,
+            router_data: item,
         })
     }
 }
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ErrorObject {
+    pub code: String,
+    pub message: String,
+}
 
-#[derive(Debug, Serialize, Eq, PartialEq)]
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct TransactionBody {
-    amount: String,
-    merchant_account_id: Option<Secret<String>>,
-    device_data: DeviceData,
-    options: PaymentOptions,
-    #[serde(flatten)]
-    payment_method_data_type: PaymentMethodType,
-    #[serde(rename = "type")]
-    kind: String,
-}
-
-#[derive(Debug, Serialize, Eq, PartialEq)]
+pub struct BraintreeErrorResponse {
+    pub errors: String,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-#[serde(tag = "type")]
-pub enum PaymentMethodType {
-    CreditCard(Card),
-    PaymentMethodNonce(Nonce),
+#[serde(untagged)]
+
+pub enum ErrorResponses {
+    BraintreeApiErrorResponse(Box<BraintreeApiErrorResponse>),
+    BraintreeErrorResponse(Box<BraintreeErrorResponse>),
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct Nonce {
-    payment_method_nonce: Secret<String>,
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ApiErrorResponse {
+    pub message: String,
+    pub errors: ErrorsObject,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct Card {
-    credit_card: CardDetails,
+pub struct BraintreeAuthType {
+    pub(super) public_key: Secret<String>,
+    pub(super) private_key: Secret<String>,
+}
+
+impl TryFrom<&types::ConnectorAuthType> for BraintreeAuthType {
+    type Error = error_stack::Report<errors::ConnectorError>;
+
+    fn try_from(item: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
+        if let types::ConnectorAuthType::SignatureKey {
+            api_key,
+            api_secret,
+            key1: _merchant_id,
+        } = item
+        {
+            Ok(Self {
+                public_key: api_key.to_owned(),
+                private_key: api_secret.to_owned(),
+            })
+        } else {
+            Err(errors::ConnectorError::FailedToObtainAuthType)?
+        }
+    }
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct CardDetails {
-    number: cards::CardNumber,
-    expiration_month: Secret<String>,
-    expiration_year: Secret<String>,
-    cvv: Secret<String>,
+pub struct PaymentInput {
+    payment_method_id: Secret<String>,
+    transaction: TransactionBody,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum BraintreePaymentsRequest {
+    Card(CardPaymentRequest),
+    CardThreeDs(BraintreeClientTokenRequest),
+    Mandate(MandatePaymentRequest),
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BraintreeMeta {
+    merchant_account_id: Secret<String>,
+    merchant_config_currency: enums::Currency,
 }
 
-impl TryFrom<&types::PaymentsAuthorizeRouterData> for BraintreePaymentsRequest {
+impl TryFrom<&Option<pii::SecretSerdeValue>> for BraintreeMeta {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(item.connector_meta_data.clone())?;
+    fn try_from(meta_data: &Option<pii::SecretSerdeValue>) -> Result<Self, Self::Error> {
+        let metadata: Self = utils::to_connector_meta_from_secret::<Self>(meta_data.clone())
+            .change_context(errors::ConnectorError::InvalidConnectorConfig {
+                config: "metadata",
+            })?;
+        Ok(metadata)
+    }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RegularTransactionBody {
+    amount: StringMajorUnit,
+    merchant_account_id: Secret<String>,
+    channel: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VaultTransactionBody {
+    amount: StringMajorUnit,
+    merchant_account_id: Secret<String>,
+    vault_payment_method_after_transacting: TransactionTiming,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum TransactionBody {
+    Regular(RegularTransactionBody),
+    Vault(VaultTransactionBody),
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionTiming {
+    when: String,
+}
 
-        utils::validate_currency(item.request.currency, metadata.merchant_config_currency)?;
-        let submit_for_settlement = matches!(
-            item.request.capture_method,
-            Some(enums::CaptureMethod::Automatic) | None
+impl
+    TryFrom<(
+        &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
+        String,
+        BraintreeMeta,
+    )> for MandatePaymentRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        (item, connector_mandate_id, metadata): (
+            &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
+            String,
+            BraintreeMeta,
+        ),
+    ) -> Result<Self, Self::Error> {
+        let (query, transaction_body) = (
+            match item.router_data.request.is_auto_capture()? {
+                true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
+                false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
+            },
+            TransactionBody::Regular(RegularTransactionBody {
+                amount: item.amount.to_owned(),
+                merchant_account_id: metadata.merchant_account_id,
+                channel: CHANNEL_CODE.to_string(),
+            }),
         );
-        let merchant_account_id = metadata.merchant_account_id;
-        let amount = utils::to_currency_base_unit(item.request.amount, item.request.currency)?;
-        let device_data = DeviceData {};
-        let options = PaymentOptions {
-            submit_for_settlement,
-        };
-        let kind = "sale".to_string();
-
-        let payment_method_data_type = match item.request.payment_method_data.clone() {
-            domain::PaymentMethodData::Card(ccard) => Ok(PaymentMethodType::CreditCard(Card {
-                credit_card: CardDetails {
-                    number: ccard.card_number,
-                    expiration_month: ccard.card_exp_month,
-                    expiration_year: ccard.card_exp_year,
-                    cvv: ccard.card_cvc,
+        Ok(Self {
+            query,
+            variables: VariablePaymentInput {
+                input: PaymentInput {
+                    payment_method_id: connector_mandate_id.into(),
+                    transaction: transaction_body,
                 },
-            })),
-            domain::PaymentMethodData::Wallet(ref wallet_data) => {
-                Ok(PaymentMethodType::PaymentMethodNonce(Nonce {
-                    payment_method_nonce: match wallet_data {
-                        domain::WalletData::PaypalSdk(wallet_data) => {
-                            Ok(wallet_data.token.to_owned())
-                        }
-                        domain::WalletData::ApplePay(_)
-                        | domain::WalletData::GooglePay(_)
-                        | domain::WalletData::SamsungPay(_)
-                        | domain::WalletData::AliPayQr(_)
-                        | domain::WalletData::AliPayRedirect(_)
-                        | domain::WalletData::AliPayHkRedirect(_)
-                        | domain::WalletData::MomoRedirect(_)
-                        | domain::WalletData::KakaoPayRedirect(_)
-                        | domain::WalletData::GoPayRedirect(_)
-                        | domain::WalletData::GcashRedirect(_)
-                        | domain::WalletData::ApplePayRedirect(_)
-                        | domain::WalletData::ApplePayThirdPartySdk(_)
-                        | domain::WalletData::DanaRedirect {}
-                        | domain::WalletData::GooglePayRedirect(_)
-                        | domain::WalletData::GooglePayThirdPartySdk(_)
-                        | domain::WalletData::MbWayRedirect(_)
-                        | domain::WalletData::MobilePayRedirect(_)
-                        | domain::WalletData::PaypalRedirect(_)
-                        | domain::WalletData::TwintRedirect {}
-                        | domain::WalletData::VippsRedirect {}
-                        | domain::WalletData::TouchNGoRedirect(_)
-                        | domain::WalletData::WeChatPayRedirect(_)
-                        | domain::WalletData::WeChatPayQr(_)
-                        | domain::WalletData::CashappQr(_)
-                        | domain::WalletData::SwishQr(_)
-                        | domain::WalletData::Mifinity(_) => {
-                            Err(errors::ConnectorError::NotImplemented(
-                                utils::get_unimplemented_payment_method_error_message("braintree"),
-                            ))
-                        }
-                    }?
-                    .into(),
-                }))
+            },
+        })
+    }
+}
+
+impl TryFrom<&BraintreeRouterData<&types::PaymentsAuthorizeRouterData>>
+    for BraintreePaymentsRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
+    ) -> Result<Self, Self::Error> {
+        let metadata: BraintreeMeta =
+            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
+                .change_context(errors::ConnectorError::InvalidConnectorConfig {
+                    config: "metadata",
+                })?;
+        utils::validate_currency(
+            item.router_data.request.currency,
+            Some(metadata.merchant_config_currency),
+        )?;
+        match item.router_data.request.payment_method_data.clone() {
+            domain::PaymentMethodData::Card(_) => {
+                if item.router_data.is_three_ds() {
+                    Ok(Self::CardThreeDs(BraintreeClientTokenRequest::try_from(
+                        metadata,
+                    )?))
+                } else {
+                    Ok(Self::Card(CardPaymentRequest::try_from((item, metadata))?))
+                }
+            }
+            domain::PaymentMethodData::MandatePayment => {
+                let connector_mandate_id = item.router_data.request.connector_mandate_id().ok_or(
+                    errors::ConnectorError::MissingRequiredField {
+                        field_name: "connector_mandate_id",
+                    },
+                )?;
+                Ok(Self::Mandate(MandatePaymentRequest::try_from((
+                    item,
+                    connector_mandate_id,
+                    metadata,
+                ))?))
             }
-            domain::PaymentMethodData::PayLater(_)
+            domain::PaymentMethodData::CardRedirect(_)
+            | domain::PaymentMethodData::Wallet(_)
+            | domain::PaymentMethodData::PayLater(_)
             | domain::PaymentMethodData::BankRedirect(_)
             | domain::PaymentMethodData::BankDebit(_)
             | domain::PaymentMethodData::BankTransfer(_)
             | domain::PaymentMethodData::Crypto(_)
-            | domain::PaymentMethodData::CardRedirect(_)
-            | domain::PaymentMethodData::MandatePayment
             | domain::PaymentMethodData::Reward
             | domain::PaymentMethodData::RealTimePayment(_)
             | domain::PaymentMethodData::Upi(_)
@@ -179,74 +312,253 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for BraintreePaymentsRequest {
             | domain::PaymentMethodData::CardToken(_) => {
                 Err(errors::ConnectorError::NotImplemented(
                     utils::get_unimplemented_payment_method_error_message("braintree"),
-                ))
+                )
+                .into())
             }
-        }?;
-        let braintree_transaction_body = TransactionBody {
-            amount,
-            merchant_account_id,
-            device_data,
-            options,
-            payment_method_data_type,
-            kind,
-        };
-        Ok(Self {
-            transaction: braintree_transaction_body,
-        })
+        }
     }
 }
 
-pub struct BraintreeAuthType {
-    pub(super) auth_header: String,
-    pub(super) merchant_id: Secret<String>,
+impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
+    for BraintreePaymentsRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
+    ) -> Result<Self, Self::Error> {
+        match item.router_data.payment_method {
+            api_models::enums::PaymentMethod::Card => {
+                Ok(Self::Card(CardPaymentRequest::try_from(item)?))
+            }
+            api_models::enums::PaymentMethod::CardRedirect
+            | api_models::enums::PaymentMethod::PayLater
+            | api_models::enums::PaymentMethod::Wallet
+            | api_models::enums::PaymentMethod::BankRedirect
+            | api_models::enums::PaymentMethod::BankTransfer
+            | api_models::enums::PaymentMethod::Crypto
+            | api_models::enums::PaymentMethod::BankDebit
+            | api_models::enums::PaymentMethod::Reward
+            | api_models::enums::PaymentMethod::RealTimePayment
+            | api_models::enums::PaymentMethod::Upi
+            | api_models::enums::PaymentMethod::OpenBanking
+            | api_models::enums::PaymentMethod::Voucher
+            | api_models::enums::PaymentMethod::GiftCard => {
+                Err(errors::ConnectorError::NotImplemented(
+                    utils::get_unimplemented_payment_method_error_message(
+                        "complete authorize flow",
+                    ),
+                )
+                .into())
+            }
+        }
+    }
 }
 
-impl TryFrom<&types::ConnectorAuthType> for BraintreeAuthType {
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct AuthResponse {
+    data: DataAuthResponse,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreeAuthResponse {
+    AuthResponse(Box<AuthResponse>),
+    ClientTokenResponse(Box<ClientTokenResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreeCompleteAuthResponse {
+    AuthResponse(Box<AuthResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+struct PaymentMethodInfo {
+    id: Secret<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionAuthChargeResponseBody {
+    id: String,
+    status: BraintreePaymentStatus,
+    payment_method: Option<PaymentMethodInfo>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataAuthResponse {
+    authorize_credit_card: AuthChargeCreditCard,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct AuthChargeCreditCard {
+    transaction: TransactionAuthChargeResponseBody,
+}
+
+impl<F>
+    TryFrom<
+        types::ResponseRouterData<
+            F,
+            BraintreeAuthResponse,
+            types::PaymentsAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    > for types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>
+{
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
-        if let types::ConnectorAuthType::SignatureKey {
-            api_key: public_key,
-            key1: merchant_id,
-            api_secret: private_key,
-        } = item
-        {
-            let auth_key = format!("{}:{}", public_key.peek(), private_key.peek());
-            let auth_header = format!("Basic {}", consts::BASE64_ENGINE.encode(auth_key));
-            Ok(Self {
-                auth_header,
-                merchant_id: merchant_id.to_owned(),
-            })
-        } else {
-            Err(errors::ConnectorError::FailedToObtainAuthType)?
+    fn try_from(
+        item: types::ResponseRouterData<
+            F,
+            BraintreeAuthResponse,
+            types::PaymentsAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreeAuthResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors, item.http_code),
+                ..item.data
+            }),
+            BraintreeAuthResponse::AuthResponse(auth_response) => {
+                let transaction_data = auth_response.data.authorize_credit_card.transaction;
+                let status = enums::AttemptStatus::from(transaction_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: transaction_data.status.to_string().clone(),
+                        message: transaction_data.status.to_string().clone(),
+                        reason: Some(transaction_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: Some(transaction_data.id),
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
+                        redirection_data: None,
+                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
+                            MandateReference {
+                                connector_mandate_id: Some(pm.id.clone().expose()),
+                                payment_method_id: None,
+                            }
+                        }),
+                        connector_metadata: None,
+                        network_txn_id: None,
+                        connector_response_reference_id: None,
+                        incremental_authorization_allowed: None,
+                        charge_id: None,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+            BraintreeAuthResponse::ClientTokenResponse(client_token_data) => Ok(Self {
+                status: enums::AttemptStatus::AuthenticationPending,
+                response: Ok(types::PaymentsResponseData::TransactionResponse {
+                    resource_id: types::ResponseId::NoResponseId,
+                    redirection_data: Some(get_braintree_redirect_form(
+                        *client_token_data,
+                        item.data.get_payment_method_token()?,
+                        item.data.request.payment_method_data.clone(),
+                    )?),
+                    mandate_reference: None,
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            }),
         }
     }
 }
 
-#[derive(Debug, Default, Clone, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
+fn build_error_response<T>(
+    response: &[ErrorDetails],
+    http_code: u16,
+) -> Result<T, types::ErrorResponse> {
+    let error_messages = response
+        .iter()
+        .map(|error| error.message.to_string())
+        .collect::<Vec<String>>();
+
+    let reason = match !error_messages.is_empty() {
+        true => Some(error_messages.join(" ")),
+        false => None,
+    };
+
+    get_error_response(
+        response
+            .first()
+            .and_then(|err_details| err_details.extensions.as_ref())
+            .and_then(|extensions| extensions.legacy_code.clone()),
+        response
+            .first()
+            .map(|err_details| err_details.message.clone()),
+        reason,
+        http_code,
+    )
+}
+
+fn get_error_response<T>(
+    error_code: Option<String>,
+    error_msg: Option<String>,
+    error_reason: Option<String>,
+    http_code: u16,
+) -> Result<T, types::ErrorResponse> {
+    Err(types::ErrorResponse {
+        code: error_code.unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
+        message: error_msg.unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
+        reason: error_reason,
+        status_code: http_code,
+        attempt_status: None,
+        connector_transaction_id: None,
+    })
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
 pub enum BraintreePaymentStatus {
-    Succeeded,
-    Failed,
     Authorized,
+    Authorizing,
     AuthorizedExpired,
+    Failed,
     ProcessorDeclined,
     GatewayRejected,
     Voided,
-    SubmittedForSettlement,
-    #[default]
     Settling,
     Settled,
     SettlementPending,
     SettlementDeclined,
     SettlementConfirmed,
+    SubmittedForSettlement,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ErrorDetails {
+    pub message: String,
+    pub extensions: Option<AdditionalErrorDetails>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AdditionalErrorDetails {
+    pub legacy_code: Option<String>,
 }
 
 impl From<BraintreePaymentStatus> for enums::AttemptStatus {
     fn from(item: BraintreePaymentStatus) -> Self {
         match item {
-            BraintreePaymentStatus::Succeeded
-            | BraintreePaymentStatus::Settling
-            | BraintreePaymentStatus::Settled => Self::Charged,
+            BraintreePaymentStatus::Settling
+            | BraintreePaymentStatus::Settled
+            | BraintreePaymentStatus::SettlementConfirmed => Self::Charged,
+            BraintreePaymentStatus::Authorizing => Self::Authorizing,
             BraintreePaymentStatus::AuthorizedExpired => Self::AuthorizationFailed,
             BraintreePaymentStatus::Failed
             | BraintreePaymentStatus::GatewayRejected
@@ -255,234 +567,1221 @@ impl From<BraintreePaymentStatus> for enums::AttemptStatus {
             BraintreePaymentStatus::Authorized => Self::Authorized,
             BraintreePaymentStatus::Voided => Self::Voided,
             BraintreePaymentStatus::SubmittedForSettlement
-            | BraintreePaymentStatus::SettlementPending
-            | BraintreePaymentStatus::SettlementConfirmed => Self::Pending,
+            | BraintreePaymentStatus::SettlementPending => Self::Pending,
         }
     }
 }
 
-impl<F, T>
-    TryFrom<types::ResponseRouterData<F, BraintreePaymentsResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
+impl<F>
+    TryFrom<
+        types::ResponseRouterData<
+            F,
+            BraintreePaymentsResponse,
+            types::PaymentsAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    > for types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
         item: types::ResponseRouterData<
             F,
             BraintreePaymentsResponse,
-            T,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        let id = item.response.transaction.id.clone();
-        Ok(Self {
-            status: enums::AttemptStatus::from(item.response.transaction.status),
-            response: Ok(types::PaymentsResponseData::TransactionResponse {
-                resource_id: types::ResponseId::ConnectorTransactionId(id.clone()),
-                redirection_data: None,
-                mandate_reference: None,
-                connector_metadata: None,
-                network_txn_id: None,
-                connector_response_reference_id: Some(id),
-                incremental_authorization_allowed: None,
-                charge_id: None,
+        match item.response {
+            BraintreePaymentsResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors.clone(), item.http_code),
+                ..item.data
             }),
-            ..item.data
-        })
+            BraintreePaymentsResponse::PaymentsResponse(payment_response) => {
+                let transaction_data = payment_response.data.charge_credit_card.transaction;
+                let status = enums::AttemptStatus::from(transaction_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: transaction_data.status.to_string().clone(),
+                        message: transaction_data.status.to_string().clone(),
+                        reason: Some(transaction_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: Some(transaction_data.id),
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
+                        redirection_data: None,
+                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
+                            MandateReference {
+                                connector_mandate_id: Some(pm.id.clone().expose()),
+                                payment_method_id: None,
+                            }
+                        }),
+                        connector_metadata: None,
+                        network_txn_id: None,
+                        connector_response_reference_id: None,
+                        incremental_authorization_allowed: None,
+                        charge_id: None,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+            BraintreePaymentsResponse::ClientTokenResponse(client_token_data) => Ok(Self {
+                status: enums::AttemptStatus::AuthenticationPending,
+                response: Ok(types::PaymentsResponseData::TransactionResponse {
+                    resource_id: types::ResponseId::NoResponseId,
+                    redirection_data: Some(get_braintree_redirect_form(
+                        *client_token_data,
+                        item.data.get_payment_method_token()?,
+                        item.data.request.payment_method_data.clone(),
+                    )?),
+                    mandate_reference: None,
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            }),
+        }
     }
 }
 
-impl<F, T>
+impl<F>
     TryFrom<
-        types::ResponseRouterData<F, BraintreeSessionTokenResponse, T, types::PaymentsResponseData>,
-    > for types::RouterData<F, T, types::PaymentsResponseData>
+        types::ResponseRouterData<
+            F,
+            BraintreeCompleteChargeResponse,
+            types::CompleteAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    > for types::RouterData<F, types::CompleteAuthorizeData, types::PaymentsResponseData>
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
         item: types::ResponseRouterData<
             F,
-            BraintreeSessionTokenResponse,
-            T,
+            BraintreeCompleteChargeResponse,
+            types::CompleteAuthorizeData,
             types::PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: Ok(types::PaymentsResponseData::SessionResponse {
-                session_token: api::SessionToken::Paypal(Box::new(
-                    payments::PaypalSessionTokenResponse {
-                        session_token: item.response.client_token.value.expose(),
-                        connector: "braintree".to_string(),
-                        sdk_next_action: payments::SdkNextAction {
-                            next_action: payments::NextActionCall::Confirm,
-                        },
-                    },
-                )),
+        match item.response {
+            BraintreeCompleteChargeResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors.clone(), item.http_code),
+                ..item.data
             }),
-            ..item.data
-        })
+            BraintreeCompleteChargeResponse::PaymentsResponse(payment_response) => {
+                let transaction_data = payment_response.data.charge_credit_card.transaction;
+                let status = enums::AttemptStatus::from(transaction_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: transaction_data.status.to_string().clone(),
+                        message: transaction_data.status.to_string().clone(),
+                        reason: Some(transaction_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: Some(transaction_data.id),
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
+                        redirection_data: None,
+                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
+                            MandateReference {
+                                connector_mandate_id: Some(pm.id.clone().expose()),
+                                payment_method_id: None,
+                            }
+                        }),
+                        connector_metadata: None,
+                        network_txn_id: None,
+                        connector_response_reference_id: None,
+                        incremental_authorization_allowed: None,
+                        charge_id: None,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+        }
     }
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreePaymentsResponse {
-    transaction: TransactionResponse,
+impl<F>
+    TryFrom<
+        types::ResponseRouterData<
+            F,
+            BraintreeCompleteAuthResponse,
+            types::CompleteAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    > for types::RouterData<F, types::CompleteAuthorizeData, types::PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::ResponseRouterData<
+            F,
+            BraintreeCompleteAuthResponse,
+            types::CompleteAuthorizeData,
+            types::PaymentsResponseData,
+        >,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreeCompleteAuthResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors, item.http_code),
+                ..item.data
+            }),
+            BraintreeCompleteAuthResponse::AuthResponse(auth_response) => {
+                let transaction_data = auth_response.data.authorize_credit_card.transaction;
+                let status = enums::AttemptStatus::from(transaction_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: transaction_data.status.to_string().clone(),
+                        message: transaction_data.status.to_string().clone(),
+                        reason: Some(transaction_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: Some(transaction_data.id),
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.id),
+                        redirection_data: None,
+                        mandate_reference: transaction_data.payment_method.as_ref().map(|pm| {
+                            MandateReference {
+                                connector_mandate_id: Some(pm.id.clone().expose()),
+                                payment_method_id: None,
+                            }
+                        }),
+                        connector_metadata: None,
+                        network_txn_id: None,
+                        connector_response_reference_id: None,
+                        incremental_authorization_allowed: None,
+                        charge_id: None,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+        }
+    }
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClientToken {
-    pub value: Secret<String>,
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct PaymentsResponse {
+    data: DataResponse,
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeSessionTokenResponse {
-    pub client_token: ClientToken,
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreePaymentsResponse {
+    PaymentsResponse(Box<PaymentsResponse>),
+    ClientTokenResponse(Box<ClientTokenResponse>),
+    ErrorResponse(Box<ErrorResponse>),
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Eq, PartialEq, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreeCompleteChargeResponse {
+    PaymentsResponse(Box<PaymentsResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct TransactionResponse {
-    id: String,
-    currency_iso_code: String,
-    amount: String,
-    status: BraintreePaymentStatus,
+pub struct DataResponse {
+    charge_credit_card: AuthChargeCreditCard,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct BraintreeApiErrorResponse {
-    pub api_error_response: ApiErrorResponse,
+pub struct RefundInputData {
+    amount: StringMajorUnit,
+    merchant_account_id: Secret<String>,
+}
+#[derive(Serialize, Debug, Clone)]
+struct IdFilter {
+    is: String,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct ErrorsObject {
-    pub errors: Vec<ErrorObject>,
-    pub transaction: Option<TransactionError>,
+#[derive(Debug, Clone, Serialize)]
+pub struct TransactionSearchInput {
+    id: IdFilter,
 }
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct TransactionError {
-    pub errors: Vec<ErrorObject>,
-    pub credit_card: Option<CreditCardError>,
+pub struct BraintreeRefundInput {
+    transaction_id: String,
+    refund: RefundInputData,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct CreditCardError {
-    pub errors: Vec<ErrorObject>,
+impl<F> TryFrom<BraintreeRouterData<&types::RefundsRouterData<F>>> for BraintreeRefundRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: BraintreeRouterData<&types::RefundsRouterData<F>>,
+    ) -> Result<Self, Self::Error> {
+        let metadata: BraintreeMeta =
+            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
+                .change_context(errors::ConnectorError::InvalidConnectorConfig {
+                    config: "metadata",
+                })?;
+
+        utils::validate_currency(
+            item.router_data.request.currency,
+            Some(metadata.merchant_config_currency),
+        )?;
+        let query = REFUND_TRANSACTION_MUTATION.to_string();
+        let variables = BraintreeRefundVariables {
+            input: BraintreeRefundInput {
+                transaction_id: item.router_data.request.connector_transaction_id.clone(),
+                refund: RefundInputData {
+                    amount: item.amount,
+                    merchant_account_id: metadata.merchant_account_id,
+                },
+            },
+        };
+        Ok(Self { query, variables })
+    }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct ErrorObject {
-    pub code: String,
-    pub message: String,
+#[derive(Debug, Clone, Deserialize, Serialize, strum::Display)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum BraintreeRefundStatus {
+    SettlementPending,
+    Settling,
+    Settled,
+    SubmittedForSettlement,
+    Failed,
 }
 
-#[derive(Debug, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BraintreeErrorResponse {
-    pub errors: String,
+impl From<BraintreeRefundStatus> for enums::RefundStatus {
+    fn from(item: BraintreeRefundStatus) -> Self {
+        match item {
+            BraintreeRefundStatus::Settled | BraintreeRefundStatus::Settling => Self::Success,
+            BraintreeRefundStatus::SubmittedForSettlement
+            | BraintreeRefundStatus::SettlementPending => Self::Pending,
+            BraintreeRefundStatus::Failed => Self::Failure,
+        }
+    }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct BraintreeRefundTransactionBody {
+    pub id: String,
+    pub status: BraintreeRefundStatus,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct BraintreeRefundTransaction {
+    pub refund: BraintreeRefundTransactionBody,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
+pub struct BraintreeRefundResponseData {
+    pub refund_transaction: BraintreeRefundTransaction,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+
+pub struct RefundResponse {
+    pub data: BraintreeRefundResponseData,
+}
+
+impl TryFrom<types::RefundsResponseRouterData<api::Execute, BraintreeRefundResponse>>
+    for types::RefundsRouterData<api::Execute>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::RefundsResponseRouterData<api::Execute, BraintreeRefundResponse>,
+    ) -> Result<Self, Self::Error> {
+        Ok(Self {
+            response: match item.response {
+                BraintreeRefundResponse::ErrorResponse(error_response) => {
+                    build_error_response(&error_response.errors, item.http_code)
+                }
+                BraintreeRefundResponse::SuccessResponse(refund_data) => {
+                    let refund_data = refund_data.data.refund_transaction.refund;
+                    let refund_status = enums::RefundStatus::from(refund_data.status.clone());
+                    if utils::is_refund_failure(refund_status) {
+                        Err(types::ErrorResponse {
+                            code: refund_data.status.to_string().clone(),
+                            message: refund_data.status.to_string().clone(),
+                            reason: Some(refund_data.status.to_string().clone()),
+                            attempt_status: None,
+                            connector_transaction_id: Some(refund_data.id),
+                            status_code: item.http_code,
+                        })
+                    } else {
+                        Ok(types::RefundsResponseData {
+                            connector_refund_id: refund_data.id.clone(),
+                            refund_status,
+                        })
+                    }
+                }
+            },
+            ..item.data
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct RefundSearchInput {
+    id: IdFilter,
+}
+impl TryFrom<&types::RefundSyncRouterData> for BraintreeRSyncRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
+        let metadata: BraintreeMeta = utils::to_connector_meta_from_secret(
+            item.connector_meta_data.clone(),
+        )
+        .change_context(errors::ConnectorError::InvalidConnectorConfig { config: "metadata" })?;
+        utils::validate_currency(
+            item.request.currency,
+            Some(metadata.merchant_config_currency),
+        )?;
+        let refund_id = item.request.get_connector_refund_id()?;
+        Ok(Self {
+            query: REFUND_QUERY.to_string(),
+            variables: RSyncInput {
+                input: RefundSearchInput {
+                    id: IdFilter { is: refund_id },
+                },
+            },
+        })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RSyncNodeData {
+    id: String,
+    status: BraintreeRefundStatus,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RSyncEdgeData {
+    node: RSyncNodeData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RefundData {
+    edges: Vec<RSyncEdgeData>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RSyncSearchData {
+    refunds: RefundData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RSyncResponseData {
+    search: RSyncSearchData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RSyncResponse {
+    data: RSyncResponseData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
+pub enum BraintreeRSyncResponse {
+    RSyncResponse(Box<RSyncResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
 
-pub enum ErrorResponse {
-    BraintreeApiErrorResponse(Box<BraintreeApiErrorResponse>),
-    BraintreeErrorResponse(Box<BraintreeErrorResponse>),
+impl TryFrom<types::RefundsResponseRouterData<api::RSync, BraintreeRSyncResponse>>
+    for types::RefundsRouterData<api::RSync>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::RefundsResponseRouterData<api::RSync, BraintreeRSyncResponse>,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreeRSyncResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors, item.http_code),
+                ..item.data
+            }),
+            BraintreeRSyncResponse::RSyncResponse(rsync_response) => {
+                let edge_data = rsync_response
+                    .data
+                    .search
+                    .refunds
+                    .edges
+                    .first()
+                    .ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
+                let connector_refund_id = &edge_data.node.id;
+                let response = Ok(types::RefundsResponseData {
+                    connector_refund_id: connector_refund_id.to_string(),
+                    refund_status: enums::RefundStatus::from(edge_data.node.status.clone()),
+                });
+                Ok(Self {
+                    response,
+                    ..item.data
+                })
+            }
+        }
+    }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct ApiErrorResponse {
-    pub message: String,
-    pub errors: ErrorsObject,
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreditCardData {
+    number: cards::CardNumber,
+    expiration_year: Secret<String>,
+    expiration_month: Secret<String>,
+    cvv: Secret<String>,
+    cardholder_name: Secret<String>,
 }
 
-#[derive(Default, Debug, Clone, Serialize)]
-pub struct BraintreeRefundRequest {
-    transaction: Amount,
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClientTokenInput {
+    merchant_account_id: Secret<String>,
 }
 
-#[derive(Default, Debug, Serialize, Clone)]
-pub struct Amount {
-    amount: Option<String>,
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InputData {
+    credit_card: CreditCardData,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct InputClientTokenData {
+    client_token: ClientTokenInput,
 }
 
-impl<F> TryFrom<&types::RefundsRouterData<F>> for BraintreeRefundRequest {
+impl TryFrom<&types::TokenizationRouterData> for BraintreeTokenRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
-        let metadata: BraintreeMeta =
-            utils::to_connector_meta_from_secret(item.connector_meta_data.clone())?;
+    fn try_from(item: &types::TokenizationRouterData) -> Result<Self, Self::Error> {
+        match item.request.payment_method_data.clone() {
+            domain::PaymentMethodData::Card(card_data) => Ok(Self {
+                query: TOKENIZE_CREDIT_CARD.to_string(),
+                variables: VariableInput {
+                    input: InputData {
+                        credit_card: CreditCardData {
+                            number: card_data.card_number,
+                            expiration_year: card_data.card_exp_year,
+                            expiration_month: card_data.card_exp_month,
+                            cvv: card_data.card_cvc,
+                            cardholder_name: item
+                                .get_optional_billing_full_name()
+                                .unwrap_or(Secret::new("".to_string())),
+                        },
+                    },
+                },
+            }),
+            domain::PaymentMethodData::CardRedirect(_)
+            | domain::PaymentMethodData::Wallet(_)
+            | domain::PaymentMethodData::PayLater(_)
+            | domain::PaymentMethodData::BankRedirect(_)
+            | domain::PaymentMethodData::BankDebit(_)
+            | domain::PaymentMethodData::BankTransfer(_)
+            | domain::PaymentMethodData::Crypto(_)
+            | domain::PaymentMethodData::MandatePayment
+            | domain::PaymentMethodData::OpenBanking(_)
+            | domain::PaymentMethodData::Reward
+            | domain::PaymentMethodData::RealTimePayment(_)
+            | domain::PaymentMethodData::Upi(_)
+            | domain::PaymentMethodData::Voucher(_)
+            | domain::PaymentMethodData::GiftCard(_)
+            | domain::PaymentMethodData::CardToken(_) => {
+                Err(errors::ConnectorError::NotImplemented(
+                    utils::get_unimplemented_payment_method_error_message("braintree"),
+                )
+                .into())
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TokenizePaymentMethodData {
+    id: Secret<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenizeCreditCardData {
+    payment_method: TokenizePaymentMethodData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClientToken {
+    client_token: Secret<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenizeCreditCard {
+    tokenize_credit_card: TokenizeCreditCardData,
+}
 
-        utils::validate_currency(item.request.currency, metadata.merchant_config_currency)?;
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClientTokenData {
+    create_client_token: ClientToken,
+}
 
-        let refund_amount =
-            utils::to_currency_base_unit(item.request.refund_amount, item.request.currency)?;
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ClientTokenResponse {
+    data: ClientTokenData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TokenResponse {
+    data: TokenizeCreditCard,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ErrorResponse {
+    errors: Vec<ErrorDetails>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreeTokenResponse {
+    TokenResponse(Box<TokenResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+
+impl<F, T>
+    TryFrom<types::ResponseRouterData<F, BraintreeTokenResponse, T, types::PaymentsResponseData>>
+    for types::RouterData<F, T, types::PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::ResponseRouterData<F, BraintreeTokenResponse, T, types::PaymentsResponseData>,
+    ) -> Result<Self, Self::Error> {
         Ok(Self {
-            transaction: Amount {
-                amount: Some(refund_amount),
+            response: match item.response {
+                BraintreeTokenResponse::ErrorResponse(error_response) => {
+                    build_error_response(error_response.errors.as_ref(), item.http_code)
+                }
+
+                BraintreeTokenResponse::TokenResponse(token_response) => {
+                    Ok(types::PaymentsResponseData::TokenizationResponse {
+                        token: token_response
+                            .data
+                            .tokenize_credit_card
+                            .payment_method
+                            .id
+                            .expose()
+                            .clone(),
+                    })
+                }
             },
+            ..item.data
         })
     }
 }
 
-#[allow(dead_code)]
-#[derive(Debug, Default, Deserialize, Clone, Serialize)]
-pub enum RefundStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptureTransactionBody {
+    amount: StringMajorUnit,
 }
 
-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,
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptureInputData {
+    transaction_id: String,
+    transaction: CaptureTransactionBody,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PsyncInputData {
+    transaction_id: String,
+}
+
+impl TryFrom<&BraintreeRouterData<&types::PaymentsCaptureRouterData>> for BraintreeCaptureRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &BraintreeRouterData<&types::PaymentsCaptureRouterData>,
+    ) -> Result<Self, Self::Error> {
+        let query = CAPTURE_TRANSACTION_MUTATION.to_string();
+        let variables = VariableCaptureInput {
+            input: CaptureInputData {
+                transaction_id: item.router_data.request.connector_transaction_id.clone(),
+                transaction: CaptureTransactionBody {
+                    amount: item.amount.to_owned(),
+                },
+            },
+        };
+        Ok(Self { query, variables })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CaptureResponseTransactionBody {
+    id: String,
+    status: BraintreePaymentStatus,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CaptureTransactionData {
+    transaction: CaptureResponseTransactionBody,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptureResponseData {
+    capture_transaction: CaptureTransactionData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CaptureResponse {
+    data: CaptureResponseData,
+}
+
+impl TryFrom<types::PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>>
+    for types::PaymentsCaptureRouterData
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::PaymentsCaptureResponseRouterData<BraintreeCaptureResponse>,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreeCaptureResponse::SuccessResponse(capture_data) => {
+                let transaction_data = capture_data.data.capture_transaction.transaction;
+                let status = enums::AttemptStatus::from(transaction_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: transaction_data.status.to_string().clone(),
+                        message: transaction_data.status.to_string().clone(),
+                        reason: Some(transaction_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: Some(transaction_data.id),
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(transaction_data.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,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+            BraintreeCaptureResponse::ErrorResponse(error_data) => Ok(Self {
+                response: build_error_response(&error_data.errors, item.http_code),
+                ..item.data
+            }),
         }
     }
 }
 
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct RefundResponse {
-    pub id: String,
-    pub status: RefundStatus,
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelInputData {
+    transaction_id: String,
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::Execute, RefundResponse>>
-    for types::RefundsRouterData<api::Execute>
+#[derive(Debug, Serialize)]
+pub struct VariableCancelInput {
+    input: CancelInputData,
+}
+
+#[derive(Debug, Serialize)]
+pub struct BraintreeCancelRequest {
+    query: String,
+    variables: VariableCancelInput,
+}
+
+impl TryFrom<&types::PaymentsCancelRouterData> for BraintreeCancelRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
+        let query = VOID_TRANSACTION_MUTATION.to_string();
+        let variables = VariableCancelInput {
+            input: CancelInputData {
+                transaction_id: item.request.connector_transaction_id.clone(),
+            },
+        };
+        Ok(Self { query, variables })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CancelResponseTransactionBody {
+    id: String,
+    status: BraintreePaymentStatus,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CancelTransactionData {
+    reversal: CancelResponseTransactionBody,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelResponseData {
+    reverse_transaction: CancelTransactionData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CancelResponse {
+    data: CancelResponseData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum BraintreeCancelResponse {
+    CancelResponse(Box<CancelResponse>),
+    ErrorResponse(Box<ErrorResponse>),
+}
+
+impl<F, T>
+    TryFrom<types::ResponseRouterData<F, BraintreeCancelResponse, T, types::PaymentsResponseData>>
+    for types::RouterData<F, T, types::PaymentsResponseData>
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
+        item: types::ResponseRouterData<F, BraintreeCancelResponse, T, types::PaymentsResponseData>,
     ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreeCancelResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors, item.http_code),
+                ..item.data
+            }),
+            BraintreeCancelResponse::CancelResponse(void_response) => {
+                let void_data = void_response.data.reverse_transaction.reversal;
+                let status = enums::AttemptStatus::from(void_data.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: void_data.status.to_string().clone(),
+                        message: void_data.status.to_string().clone(),
+                        reason: Some(void_data.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: None,
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::NoResponseId,
+                        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,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+        }
+    }
+}
+
+impl TryFrom<&types::PaymentsSyncRouterData> for BraintreePSyncRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
+        let transaction_id = item
+            .request
+            .connector_transaction_id
+            .get_connector_transaction_id()
+            .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
-                connector_refund_id: item.response.id,
-                refund_status: enums::RefundStatus::from(item.response.status),
+            query: TRANSACTION_QUERY.to_string(),
+            variables: PSyncInput {
+                input: TransactionSearchInput {
+                    id: IdFilter { is: transaction_id },
+                },
+            },
+        })
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct NodeData {
+    id: String,
+    status: BraintreePaymentStatus,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct EdgeData {
+    node: NodeData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TransactionData {
+    edges: Vec<EdgeData>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct SearchData {
+    transactions: TransactionData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct PSyncResponseData {
+    search: SearchData,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct PSyncResponse {
+    data: PSyncResponseData,
+}
+
+impl<F, T>
+    TryFrom<types::ResponseRouterData<F, BraintreePSyncResponse, T, types::PaymentsResponseData>>
+    for types::RouterData<F, T, types::PaymentsResponseData>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::ResponseRouterData<F, BraintreePSyncResponse, T, types::PaymentsResponseData>,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            BraintreePSyncResponse::ErrorResponse(error_response) => Ok(Self {
+                response: build_error_response(&error_response.errors, item.http_code),
+                ..item.data
             }),
-            ..item.data
+            BraintreePSyncResponse::SuccessResponse(psync_response) => {
+                let edge_data = psync_response
+                    .data
+                    .search
+                    .transactions
+                    .edges
+                    .first()
+                    .ok_or(errors::ConnectorError::MissingConnectorTransactionID)?;
+                let status = enums::AttemptStatus::from(edge_data.node.status.clone());
+                let response = if utils::is_payment_failure(status) {
+                    Err(types::ErrorResponse {
+                        code: edge_data.node.status.to_string().clone(),
+                        message: edge_data.node.status.to_string().clone(),
+                        reason: Some(edge_data.node.status.to_string().clone()),
+                        attempt_status: None,
+                        connector_transaction_id: None,
+                        status_code: item.http_code,
+                    })
+                } else {
+                    Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_id: types::ResponseId::ConnectorTransactionId(
+                            edge_data.node.id.clone(),
+                        ),
+                        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,
+                    })
+                };
+                Ok(Self {
+                    status,
+                    response,
+                    ..item.data
+                })
+            }
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BraintreeThreeDsResponse {
+    pub nonce: Secret<String>,
+    pub liability_shifted: bool,
+    pub liability_shift_possible: bool,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BraintreeThreeDsErrorResponse {
+    pub code: String,
+    pub message: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BraintreeRedirectionResponse {
+    pub authentication_response: String,
+}
+
+impl TryFrom<BraintreeMeta> for BraintreeClientTokenRequest {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(metadata: BraintreeMeta) -> Result<Self, Self::Error> {
+        Ok(Self {
+            query: CLIENT_TOKEN_MUTATION.to_owned(),
+            variables: VariableClientTokenInput {
+                input: InputClientTokenData {
+                    client_token: ClientTokenInput {
+                        merchant_account_id: metadata.merchant_account_id,
+                    },
+                },
+            },
         })
     }
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::RSync, RefundResponse>>
-    for types::RefundsRouterData<api::RSync>
+impl
+    TryFrom<(
+        &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
+        BraintreeMeta,
+    )> for CardPaymentRequest
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: types::RefundsResponseRouterData<api::RSync, RefundResponse>,
+        (item, metadata): (
+            &BraintreeRouterData<&types::PaymentsAuthorizeRouterData>,
+            BraintreeMeta,
+        ),
     ) -> Result<Self, Self::Error> {
+        let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
+            (
+                match item.router_data.request.is_auto_capture()? {
+                    true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
+                    false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
+                },
+                TransactionBody::Vault(VaultTransactionBody {
+                    amount: item.amount.to_owned(),
+                    merchant_account_id: metadata.merchant_account_id,
+                    vault_payment_method_after_transacting: TransactionTiming {
+                        when: "ALWAYS".to_string(),
+                    },
+                }),
+            )
+        } else {
+            (
+                match item.router_data.request.is_auto_capture()? {
+                    true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
+                    false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
+                },
+                TransactionBody::Regular(RegularTransactionBody {
+                    amount: item.amount.to_owned(),
+                    merchant_account_id: metadata.merchant_account_id,
+                    channel: CHANNEL_CODE.to_string(),
+                }),
+            )
+        };
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
-                connector_refund_id: item.response.id,
-                refund_status: enums::RefundStatus::from(item.response.status),
-            }),
-            ..item.data
+            query,
+            variables: VariablePaymentInput {
+                input: PaymentInput {
+                    payment_method_id: match item.router_data.get_payment_method_token()? {
+                        types::PaymentMethodToken::Token(token) => token,
+                        types::PaymentMethodToken::ApplePayDecrypt(_) => Err(
+                            unimplemented_payment_method!("Apple Pay", "Simplified", "Braintree"),
+                        )?,
+                    },
+                    transaction: transaction_body,
+                },
+            },
+        })
+    }
+}
+
+impl TryFrom<&BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>>
+    for CardPaymentRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &BraintreeRouterData<&types::PaymentsCompleteAuthorizeRouterData>,
+    ) -> Result<Self, Self::Error> {
+        let metadata: BraintreeMeta =
+            utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
+                .change_context(errors::ConnectorError::InvalidConnectorConfig {
+                    config: "metadata",
+                })?;
+        utils::validate_currency(
+            item.router_data.request.currency,
+            Some(metadata.merchant_config_currency),
+        )?;
+        let payload_data = PaymentsCompleteAuthorizeRequestData::get_redirect_response_payload(
+            &item.router_data.request,
+        )?
+        .expose();
+        let redirection_response: BraintreeRedirectionResponse = serde_json::from_value(
+            payload_data,
+        )
+        .change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
+            field_name: "redirection_response",
+        })?;
+        let three_ds_data = serde_json::from_str::<BraintreeThreeDsResponse>(
+            &redirection_response.authentication_response,
+        )
+        .change_context(errors::ConnectorError::MissingConnectorRedirectionPayload {
+            field_name: "three_ds_data",
+        })?;
+
+        let (query, transaction_body) = if item.router_data.request.is_mandate_payment() {
+            (
+                match item.router_data.request.is_auto_capture()? {
+                    true => CHARGE_AND_VAULT_TRANSACTION_MUTATION.to_string(),
+                    false => AUTHORIZE_AND_VAULT_CREDIT_CARD_MUTATION.to_string(),
+                },
+                TransactionBody::Vault(VaultTransactionBody {
+                    amount: item.amount.to_owned(),
+                    merchant_account_id: metadata.merchant_account_id,
+                    vault_payment_method_after_transacting: TransactionTiming {
+                        when: "ALWAYS".to_string(),
+                    },
+                }),
+            )
+        } else {
+            (
+                match item.router_data.request.is_auto_capture()? {
+                    true => CHARGE_CREDIT_CARD_MUTATION.to_string(),
+                    false => AUTHORIZE_CREDIT_CARD_MUTATION.to_string(),
+                },
+                TransactionBody::Regular(RegularTransactionBody {
+                    amount: item.amount.to_owned(),
+                    merchant_account_id: metadata.merchant_account_id,
+                    channel: CHANNEL_CODE.to_string(),
+                }),
+            )
+        };
+        Ok(Self {
+            query,
+            variables: VariablePaymentInput {
+                input: PaymentInput {
+                    payment_method_id: three_ds_data.nonce,
+                    transaction: transaction_body,
+                },
+            },
         })
     }
 }
+
+fn get_braintree_redirect_form(
+    client_token_data: ClientTokenResponse,
+    payment_method_token: types::PaymentMethodToken,
+    card_details: domain::PaymentMethodData,
+) -> Result<services::RedirectForm, error_stack::Report<errors::ConnectorError>> {
+    Ok(services::RedirectForm::Braintree {
+        client_token: client_token_data
+            .data
+            .create_client_token
+            .client_token
+            .expose(),
+        card_token: match payment_method_token {
+            types::PaymentMethodToken::Token(token) => token.expose(),
+            types::PaymentMethodToken::ApplePayDecrypt(_) => Err(unimplemented_payment_method!(
+                "Apple Pay",
+                "Simplified",
+                "Braintree"
+            ))?,
+        },
+        bin: match card_details {
+            domain::PaymentMethodData::Card(card_details) => {
+                card_details.card_number.get_card_isin()
+            }
+            domain::PaymentMethodData::CardRedirect(_)
+            | domain::PaymentMethodData::Wallet(_)
+            | domain::PaymentMethodData::PayLater(_)
+            | domain::PaymentMethodData::BankRedirect(_)
+            | domain::PaymentMethodData::BankDebit(_)
+            | domain::PaymentMethodData::BankTransfer(_)
+            | domain::PaymentMethodData::Crypto(_)
+            | domain::PaymentMethodData::MandatePayment
+            | domain::PaymentMethodData::OpenBanking(_)
+            | domain::PaymentMethodData::Reward
+            | domain::PaymentMethodData::RealTimePayment(_)
+            | domain::PaymentMethodData::Upi(_)
+            | domain::PaymentMethodData::Voucher(_)
+            | domain::PaymentMethodData::GiftCard(_)
+            | domain::PaymentMethodData::CardToken(_) => Err(
+                errors::ConnectorError::NotImplemented("given payment method".to_owned()),
+            )?,
+        },
+    })
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BraintreeWebhookResponse {
+    pub bt_signature: String,
+    pub bt_payload: String,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct Notification {
+    pub kind: String, // xml parse only string to fields
+    pub timestamp: String,
+    pub dispute: Option<BraintreeDisputeData>,
+}
+impl types::transformers::ForeignFrom<&str> for api_models::webhooks::IncomingWebhookEvent {
+    fn foreign_from(status: &str) -> Self {
+        match status {
+            "dispute_opened" => Self::DisputeOpened,
+            "dispute_lost" => Self::DisputeLost,
+            "dispute_won" => Self::DisputeWon,
+            "dispute_accepted" | "dispute_auto_accepted" => Self::DisputeAccepted,
+            "dispute_expired" => Self::DisputeExpired,
+            "dispute_disputed" => Self::DisputeChallenged,
+            _ => Self::EventNotSupported,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct BraintreeDisputeData {
+    pub amount_disputed: i64,
+    pub amount_won: Option<String>,
+    pub case_number: Option<String>,
+    pub chargeback_protection_level: Option<String>,
+    pub currency_iso_code: String,
+    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
+    pub created_at: Option<PrimitiveDateTime>,
+    pub evidence: Option<DisputeEvidence>,
+    pub id: String,
+    pub kind: String, // xml parse only string to fields
+    pub status: String,
+    pub reason: Option<String>,
+    pub reason_code: Option<String>,
+    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
+    pub updated_at: Option<PrimitiveDateTime>,
+    #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
+    pub reply_by_date: Option<PrimitiveDateTime>,
+    pub transaction: DisputeTransaction,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct DisputeTransaction {
+    pub amount: StringMajorUnit,
+    pub id: String,
+}
+#[derive(Debug, Deserialize, Serialize)]
+pub struct DisputeEvidence {
+    pub comment: String,
+    pub id: Secret<String>,
+    pub created_at: Option<PrimitiveDateTime>,
+    pub url: url::Url,
+}
+
+pub(crate) fn get_dispute_stage(code: &str) -> Result<enums::DisputeStage, errors::ConnectorError> {
+    match code {
+        "CHARGEBACK" => Ok(enums::DisputeStage::Dispute),
+        "PRE_ARBITATION" => Ok(enums::DisputeStage::PreArbitration),
+        "RETRIEVAL" => Ok(enums::DisputeStage::PreDispute),
+        _ => Err(errors::ConnectorError::WebhookBodyDecodingFailed),
+    }
+}
diff --git a/crates/router/src/core/admin.rs b/crates/router/src/core/admin.rs
index 51fffea3b53..30eee259ce5 100644
--- a/crates/router/src/core/admin.rs
+++ b/crates/router/src/core/admin.rs
@@ -1292,9 +1292,7 @@ impl<'a> ConnectorAuthTypeAndMetadataValidation<'a> {
             }
             api_enums::Connector::Braintree => {
                 braintree::transformers::BraintreeAuthType::try_from(self.auth_type)?;
-                braintree::braintree_graphql_transformers::BraintreeMeta::try_from(
-                    self.connector_meta_data,
-                )?;
+                braintree::transformers::BraintreeMeta::try_from(self.connector_meta_data)?;
                 Ok(())
             }
             api_enums::Connector::Cashtocode => {
diff --git a/crates/router/src/types/api.rs b/crates/router/src/types/api.rs
index ec474242d25..11ab940dabe 100644
--- a/crates/router/src/types/api.rs
+++ b/crates/router/src/types/api.rs
@@ -375,7 +375,7 @@ impl ConnectorData {
                 }
                 enums::Connector::Boku => Ok(ConnectorEnum::Old(Box::new(&connector::Boku))),
                 enums::Connector::Braintree => {
-                    Ok(ConnectorEnum::Old(Box::new(&connector::Braintree)))
+                    Ok(ConnectorEnum::Old(Box::new(connector::Braintree::new())))
                 }
                 enums::Connector::Cashtocode => {
                     Ok(ConnectorEnum::Old(Box::new(connector::Cashtocode::new())))
diff --git a/loadtest/config/development.toml b/loadtest/config/development.toml
index f080fd550d8..2bc9e5ccc83 100644
--- a/loadtest/config/development.toml
+++ b/loadtest/config/development.toml
@@ -88,8 +88,7 @@ bitpay.base_url = "https://test.bitpay.com"
 bluesnap.base_url = "https://sandbox.bluesnap.com/"
 bluesnap.secondary_base_url = "https://sandpay.bluesnap.com/"
 boku.base_url = "https://country-api4-stage.boku.com"
-braintree.base_url = "https://api.sandbox.braintreegateway.com/"
-braintree.secondary_base_url = "https://payments.sandbox.braintree-api.com/graphql"
+braintree.base_url = "https://payments.sandbox.braintree-api.com/graphql"
 cashtocode.base_url = "https://cluster05.api-test.cashtocode.com"
 checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
@@ -286,9 +285,6 @@ discord_invite_url = "https://discord.gg/wJZ7DVW8mm"
 [payouts]
 payout_eligibility = true
 
-[multiple_api_version_supported_connectors]
-supported_connectors = "braintree"
-
 [mandates.supported_payment_methods]
 pay_later.klarna = {connector_list = "adyen"}
 wallet.google_pay = {connector_list = "stripe,adyen,bankofamerica"}

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

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

## Description
<!-- Describe your changes in detail -->
Removed Braintree SDK Flow support. Only Graphql Supported now

### Additional Changes

- [ ] This PR modifies the API contract
- [ ] This PR modifies the database schema
- [x] 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).
-->


## How did you test it?
Basic Flow test : 
**3DS**
```
curl --location 'http://localhost:8080/payments' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data '{
    "amount": 2500,
    "currency": "USD",
    "confirm": true, 
    "capture_method": "automatic",
    "authentication_type": "three_ds",
    "return_url": "https://google.com",
    "payment_method": "card",
    "payment_method_type": "credit",
    "payment_method_data": {
        "card": {
            "card_number": "4111111111111111",
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "card_cvc": "124"
        }
    },
    "billing": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    },
    "shipping": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    }
}'
**Response** 
{
    "payment_id": "pay_ZMsZRMAjlDTm7mTnknHN",
    "merchant_id": "merchant_1722842775",
    "status": "requires_customer_action",
    "amount": 2500,
    "net_amount": 2500,
    "amount_capturable": 2500,
    "amount_received": null,
    "connector": "braintree",
    "client_secret": "pay_ZMsZRMAjlDTm7mTnknHN_secret_IBMfy3TysVyYKVzozo1F",
    "created": "2024-08-05T11:03:19.789Z",
    "currency": "USD",
    "customer_id": null,
    "customer": null,
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "1111",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "411111",
            "card_extended_bin": null,
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "payment_checks": null,
            "authentication_data": null
        },
        "billing": null
    },
    "payment_token": null,
    "shipping": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "billing": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "order_details": null,
    "email": null,
    "name": null,
    "phone": null,
    "return_url": "https://google.com/",
    "authentication_type": "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_ZMsZRMAjlDTm7mTnknHN/merchant_1722842775/pay_ZMsZRMAjlDTm7mTnknHN_1"
    },
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "credit",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "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_wLEKv9TwK4RabjeK5kUt",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-08-05T11:18:19.789Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-08-05T11:03:22.426Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```
**Non-3ds**
```
**Request**
curl --location 'http://localhost:8080/payments' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data '{
    "amount": 2500,
    "currency": "USD",
    "confirm": true, 
    "capture_method": "automatic",
    "authentication_type": "no_three_ds",
    "return_url": "https://google.com",
    "payment_method": "card",
    "payment_method_type": "credit",
    "payment_method_data": {
        "card": {
            "card_number": "4111111111111111",
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "card_cvc": "124"
        }
    },
    "billing": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    },
    "shipping": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    }
}'
**Response**
{
    "payment_id": "pay_yXxOTAlvdiTP6fIhkX7a",
    "merchant_id": "merchant_1722842775",
    "status": "processing",
    "amount": 2500,
    "net_amount": 2500,
    "amount_capturable": 0,
    "amount_received": null,
    "connector": "braintree",
    "client_secret": "pay_yXxOTAlvdiTP6fIhkX7a_secret_U4PE2hcifkfPIABqIpy5",
    "created": "2024-08-05T11:04:27.891Z",
    "currency": "USD",
    "customer_id": null,
    "customer": null,
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "1111",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "411111",
            "card_extended_bin": null,
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "payment_checks": null,
            "authentication_data": null
        },
        "billing": null
    },
    "payment_token": null,
    "shipping": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "billing": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "order_details": null,
    "email": null,
    "name": null,
    "phone": null,
    "return_url": "https://google.com/",
    "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": "credit",
    "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": "dHJhbnNhY3Rpb25fcWF2eWcyeWs",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_wLEKv9TwK4RabjeK5kUt",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-08-05T11:19:27.891Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-08-05T11:04:30.272Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}

```
Refunds
```
**Request**
curl --location 'http://localhost:8080/refunds' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data '{
  "payment_id": "pay_yXxOTAlvdiTP6fIhkX7a",
  "amount": 2000,
  "reason": "Customer returned product",
  "refund_type": "instant",
  "metadata": {
    "udf1": "value1",
    "new_customer": "true",
    "login_date": "2019-09-10T10:11:12Z"
  }
}'
**Response**
{
    "refund_id": "ref_wyHmoQg4HOoULxqCLHSZ",
    "payment_id": "pay_yXxOTAlvdiTP6fIhkX7a",
    "amount": 2000,
    "currency": "USD",
    "status": "pending",
    "reason": "Customer returned product",
    "metadata": {
        "udf1": "value1",
        "new_customer": "true",
        "login_date": "2019-09-10T10:11:12Z"
    },
    "error_message": null,
    "error_code": null,
    "created_at": "2024-08-05T11:06:48.010Z",
    "updated_at": "2024-08-05T11:06:49.108Z",
    "connector": "braintree",
    "profile_id": "pro_wLEKv9TwK4RabjeK5kUt",
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "charges": null
}
```
**Capture**
```
**Request**
curl --location 'http://localhost:8080/payments' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data '{
    "amount": 2500,
    "currency": "USD",
    "confirm": true, 
    "capture_method": "manual",
    "authentication_type": "no_three_ds",
    "return_url": "https://google.com",
    "payment_method": "card",
    "payment_method_type": "credit",
    "payment_method_data": {
        "card": {
            "card_number": "4111111111111111",
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "card_cvc": "124"
        }
    },
    "billing": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    },
    "shipping": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "city": "San Fransico",
            "state": "California",
            "zip": "94122",
            "country": "US",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    }
}'
**Response**
{
    "payment_id": "pay_u9sqbc5XCaQAvrBEPCAs",
    "merchant_id": "merchant_1722842775",
    "status": "requires_capture",
    "amount": 2500,
    "net_amount": 2500,
    "amount_capturable": 2500,
    "amount_received": null,
    "connector": "braintree",
    "client_secret": "pay_u9sqbc5XCaQAvrBEPCAs_secret_8BygWx4zVWcacDLr4ywC",
    "created": "2024-08-05T11:07:47.605Z",
    "currency": "USD",
    "customer_id": null,
    "customer": null,
    "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": "card",
    "payment_method_data": {
        "card": {
            "last4": "1111",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "411111",
            "card_extended_bin": null,
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "payment_checks": null,
            "authentication_data": null
        },
        "billing": null
    },
    "payment_token": null,
    "shipping": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "billing": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "order_details": null,
    "email": null,
    "name": null,
    "phone": null,
    "return_url": "https://google.com/",
    "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": "credit",
    "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": "dHJhbnNhY3Rpb25fZjl0M2MzeXc",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_wLEKv9TwK4RabjeK5kUt",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-08-05T11:22:47.605Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-08-05T11:07:48.803Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}

```

**Void**
```
curl --location 'http://localhost:8080/payments/pay_u9sqbc5XCaQAvrBEPCAs/cancel' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data '{"cancellation_reason":"requested_by_customer"}'

Response
{
    "payment_id": "pay_u9sqbc5XCaQAvrBEPCAs",
    "merchant_id": "merchant_1722842775",
    "status": "cancelled",
    "amount": 2500,
    "net_amount": 2500,
    "amount_capturable": 0,
    "amount_received": null,
    "connector": "braintree",
    "client_secret": "pay_u9sqbc5XCaQAvrBEPCAs_secret_8BygWx4zVWcacDLr4ywC",
    "created": "2024-08-05T11:07:47.605Z",
    "currency": "USD",
    "customer_id": null,
    "customer": null,
    "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": "card",
    "payment_method_data": {
        "card": {
            "last4": "1111",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "411111",
            "card_extended_bin": null,
            "card_exp_month": "09",
            "card_exp_year": "99",
            "card_holder_name": "joseph Doe",
            "payment_checks": null,
            "authentication_data": null
        },
        "billing": null
    },
    "payment_token": null,
    "shipping": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "billing": {
        "address": {
            "city": "San Fransico",
            "country": "US",
            "line1": "1467",
            "line2": "Harrison Street",
            "line3": "Harrison Street",
            "zip": "94122",
            "state": "California",
            "first_name": "joseph",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        },
        "email": null
    },
    "order_details": null,
    "email": null,
    "name": null,
    "phone": null,
    "return_url": "https://google.com/",
    "authentication_type": "no_three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": null,
    "cancellation_reason": "requested_by_customer",
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "credit",
    "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": "dHJhbnNhY3Rpb25fZjl0M2MzeXc",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_wLEKv9TwK4RabjeK5kUt",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-08-05T11:22:47.605Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": null,
    "payment_method_status": null,
    "updated": "2024-08-05T11:10:02.295Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": null
}
```

**Non-Zero Mandate**
**Request**
```
curl --location 'http://localhost:8080/payments' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'api-key:' \
--data-raw '{
    "amount": 12345,
    "currency": "USD",
    "confirm": true,
    "capture_method": "automatic",
    "customer_id": "mandate_customer_new",
    "email": "guest@example.com",
    "off_session": true,
    "recurring_details": {
        "type": "payment_method_id",
        "data": "pm_yrlSedzFMxzvk3n85oev"
    },
    "billing": {
        "address": {
            "city": "test",
            "country": "US",
            "line1": "here",
            "line2": "there",
            "line3": "anywhere",
            "zip": "560095",
            "state": "Washington",
            "first_name": "One",
            "last_name": "Two"
        },
        "phone": {
            "number": "1234567890",
            "country_code": "+1"
        },
        "email": "guest@example.com"
    },
    "authentication_type": "no_three_ds"
}'

```
**Response**
```
Response
{
    "payment_id": "pay_NzF4Wpvw1GxestklJTz5",
    "merchant_id": "merchant_1722842775",
    "status": "processing",
    "amount": 12345,
    "net_amount": 12345,
    "amount_capturable": 0,
    "amount_received": null,
    "connector": "braintree",
    "client_secret": "pay_NzF4Wpvw1GxestklJTz5_secret_cFbgsFDyDSb0QMcn4B32",
    "created": "2024-08-05T11:13:44.274Z",
    "currency": "USD",
    "customer_id": "mandate_customer_new",
    "customer": {
        "id": "mandate_customer_new",
        "name": "Joseph Doe",
        "email": "guest@example.com",
        "phone": "999999999",
        "phone_country_code": "+65"
    },
    "description": null,
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": null,
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "1111",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "411111",
            "card_extended_bin": null,
            "card_exp_month": "01",
            "card_exp_year": "39",
            "card_holder_name": "John T",
            "payment_checks": null,
            "authentication_data": null
        },
        "billing": null
    },
    "payment_token": null,
    "shipping": null,
    "billing": {
        "address": {
            "city": "test",
            "country": "US",
            "line1": "here",
            "line2": "there",
            "line3": "anywhere",
            "zip": "560095",
            "state": "Washington",
            "first_name": "One",
            "last_name": "Two"
        },
        "phone": {
            "number": "1234567890",
            "country_code": "+1"
        },
        "email": "guest@example.com"
    },
    "order_details": null,
    "email": "guest@example.com",
    "name": "Joseph Doe",
    "phone": "999999999",
    "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": null,
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": {
        "customer_id": "mandate_customer_new",
        "created_at": 1722856424,
        "expires": 1722860024,
        "secret": "epk_45cecd7501a64de384de1588cf088213"
    },
    "manual_retry_allowed": false,
    "connector_transaction_id": "dHJhbnNhY3Rpb25fYm44cGV2OGY",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": null,
    "reference_id": null,
    "payment_link": null,
    "profile_id": "pro_wLEKv9TwK4RabjeK5kUt",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_CuboB7cXkPtl5fULfa30",
    "incremental_authorization_allowed": null,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2024-08-05T11:28:44.274Z",
    "fingerprint": null,
    "browser_info": null,
    "payment_method_id": "pm_yrlSedzFMxzvk3n85oev",
    "payment_method_status": "active",
    "updated": "2024-08-05T11:13:46.073Z",
    "charges": null,
    "frm_metadata": null,
    "merchant_order_reference_id": 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
