Issue:
Bug: feat(connector): [DATATRANS] add Connector Payment Flows Code



Implemented Card Payments for Datatrans


Pull request description:
## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [ ] Bugfix
- [x] New feature
- [ ] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
Implemented Card Payments for Datatrans

### Additional Changes

- [x] 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
https://github.com/juspay/hyperswitch/issues/5027


## How did you test it?
Attached Postman Collection `postman/collection-json/datatrans.postman_collection.json`


## 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


Testing:
Attached Postman Collection `postman/collection-json/datatrans.postman_collection.json`

Patch:
diff --git a/config/development.toml b/config/development.toml
index b3548b35d06..4965723fb76 100644
--- a/config/development.toml
+++ b/config/development.toml
@@ -191,7 +191,7 @@ checkout.base_url = "https://api.sandbox.checkout.com/"
 coinbase.base_url = "https://api.commerce.coinbase.com"
 cryptopay.base_url = "https://business-sandbox.cryptopay.me"
 cybersource.base_url = "https://apitest.cybersource.com/"
-datatrans.base_url = "https://api.sandbox.datatrans.com"
+datatrans.base_url = "https://api.sandbox.datatrans.com/"
 dlocal.base_url = "https://sandbox.dlocal.com/"
 dummyconnector.base_url = "http://localhost:8080/dummy-connector"
 ebanx.base_url = "https://sandbox.ebanxpay.com/"
diff --git a/crates/api_models/src/enums.rs b/crates/api_models/src/enums.rs
index 29d344dfd5a..62e976b0933 100644
--- a/crates/api_models/src/enums.rs
+++ b/crates/api_models/src/enums.rs
@@ -90,7 +90,7 @@ pub enum Connector {
     Coinbase,
     Cryptopay,
     Cybersource,
-    // Datatrans,
+    Datatrans,
     Dlocal,
     Ebanx,
     Fiserv,
@@ -257,7 +257,7 @@ impl Connector {
             | Self::Razorpay
             | Self::Riskified
             | Self::Threedsecureio
-            // | Self::Datatrans
+            | Self::Datatrans
             | Self::Netcetera
             | Self::Noon
             | Self::Stripe => false,
diff --git a/crates/common_enums/src/enums.rs b/crates/common_enums/src/enums.rs
index 87d4f5e775a..850c6666548 100644
--- a/crates/common_enums/src/enums.rs
+++ b/crates/common_enums/src/enums.rs
@@ -132,7 +132,7 @@ pub enum RoutableConnectors {
     Coinbase,
     Cryptopay,
     Cybersource,
-    // Datatrans,
+    Datatrans,
     Dlocal,
     Ebanx,
     Fiserv,
diff --git a/crates/connector_configs/src/connector.rs b/crates/connector_configs/src/connector.rs
index baa606f82c1..e0ecbcb8797 100644
--- a/crates/connector_configs/src/connector.rs
+++ b/crates/connector_configs/src/connector.rs
@@ -156,6 +156,7 @@ pub struct ConnectorConfig {
     pub iatapay: Option<ConnectorTomlConfig>,
     pub opennode: Option<ConnectorTomlConfig>,
     pub bambora: Option<ConnectorTomlConfig>,
+    pub datatrans: Option<ConnectorTomlConfig>,
     pub dlocal: Option<ConnectorTomlConfig>,
     pub ebanx_payout: Option<ConnectorTomlConfig>,
     pub fiserv: Option<ConnectorTomlConfig>,
@@ -290,6 +291,7 @@ impl ConnectorConfig {
             Connector::Iatapay => Ok(connector_data.iatapay),
             Connector::Opennode => Ok(connector_data.opennode),
             Connector::Bambora => Ok(connector_data.bambora),
+            Connector::Datatrans => Ok(connector_data.datatrans),
             Connector::Dlocal => Ok(connector_data.dlocal),
             Connector::Ebanx => Ok(connector_data.ebanx_payout),
             Connector::Fiserv => Ok(connector_data.fiserv),
diff --git a/crates/connector_configs/toml/development.toml b/crates/connector_configs/toml/development.toml
index e62e8d8ea48..f3755e83bfb 100644
--- a/crates/connector_configs/toml/development.toml
+++ b/crates/connector_configs/toml/development.toml
@@ -2797,4 +2797,45 @@ three_ds_requestor_id="ThreeDS request id"
   payment_method_type = "UnionPay"
 [billwerk.connector_auth.BodyKey]
 api_key="Private Api Key"
-key1="Public Api Key"
\ No newline at end of file
+key1="Public Api Key"
+
+[datatrans]
+[[datatrans.credit]]
+  payment_method_type = "Mastercard"
+[[datatrans.credit]]
+  payment_method_type = "Visa"
+[[datatrans.credit]]
+  payment_method_type = "Interac"
+[[datatrans.credit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.credit]]
+  payment_method_type = "JCB"
+[[datatrans.credit]]
+  payment_method_type = "DinersClub"
+[[datatrans.credit]]
+  payment_method_type = "Discover"
+[[datatrans.credit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.credit]]
+  payment_method_type = "UnionPay"
+[[datatrans.debit]]
+  payment_method_type = "Mastercard"
+[[datatrans.debit]]
+  payment_method_type = "Visa"
+[[datatrans.debit]]
+  payment_method_type = "Interac"
+[[datatrans.debit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.debit]]
+  payment_method_type = "JCB"
+[[datatrans.debit]]
+  payment_method_type = "DinersClub"
+[[datatrans.debit]]
+  payment_method_type = "Discover"
+[[datatrans.debit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.debit]]
+  payment_method_type = "UnionPay"
+[datatrans.connector_auth.BodyKey]
+api_key = "Passcode"
+key1 = "datatrans MerchantId"
\ No newline at end of file
diff --git a/crates/connector_configs/toml/production.toml b/crates/connector_configs/toml/production.toml
index c31b75ad3fc..33c3c4a60d9 100644
--- a/crates/connector_configs/toml/production.toml
+++ b/crates/connector_configs/toml/production.toml
@@ -2026,4 +2026,45 @@ key1 = "Merchant ID"
   payment_method_type = "UnionPay"
 [billwerk.connector_auth.BodyKey]
 api_key="Private Api Key"
-key1="Public Api Key"
\ No newline at end of file
+key1="Public Api Key"
+
+[datatrans]
+[[datatrans.credit]]
+  payment_method_type = "Mastercard"
+[[datatrans.credit]]
+  payment_method_type = "Visa"
+[[datatrans.credit]]
+  payment_method_type = "Interac"
+[[datatrans.credit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.credit]]
+  payment_method_type = "JCB"
+[[datatrans.credit]]
+  payment_method_type = "DinersClub"
+[[datatrans.credit]]
+  payment_method_type = "Discover"
+[[datatrans.credit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.credit]]
+  payment_method_type = "UnionPay"
+[[datatrans.debit]]
+  payment_method_type = "Mastercard"
+[[datatrans.debit]]
+  payment_method_type = "Visa"
+[[datatrans.debit]]
+  payment_method_type = "Interac"
+[[datatrans.debit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.debit]]
+  payment_method_type = "JCB"
+[[datatrans.debit]]
+  payment_method_type = "DinersClub"
+[[datatrans.debit]]
+  payment_method_type = "Discover"
+[[datatrans.debit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.debit]]
+  payment_method_type = "UnionPay"
+[datatrans.connector_auth.BodyKey]
+api_key = "Passcode"
+key1 = "datatrans MerchantId"
\ No newline at end of file
diff --git a/crates/connector_configs/toml/sandbox.toml b/crates/connector_configs/toml/sandbox.toml
index 5b44dc1551d..1ae9fc665b2 100644
--- a/crates/connector_configs/toml/sandbox.toml
+++ b/crates/connector_configs/toml/sandbox.toml
@@ -2799,3 +2799,44 @@ three_ds_requestor_id="ThreeDS request id"
 [billwerk.connector_auth.BodyKey]
 api_key="Private Api Key"
 key1="Public Api Key"
+
+[datatrans]
+[[datatrans.credit]]
+  payment_method_type = "Mastercard"
+[[datatrans.credit]]
+  payment_method_type = "Visa"
+[[datatrans.credit]]
+  payment_method_type = "Interac"
+[[datatrans.credit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.credit]]
+  payment_method_type = "JCB"
+[[datatrans.credit]]
+  payment_method_type = "DinersClub"
+[[datatrans.credit]]
+  payment_method_type = "Discover"
+[[datatrans.credit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.credit]]
+  payment_method_type = "UnionPay"
+[[datatrans.debit]]
+  payment_method_type = "Mastercard"
+[[datatrans.debit]]
+  payment_method_type = "Visa"
+[[datatrans.debit]]
+  payment_method_type = "Interac"
+[[datatrans.debit]]
+  payment_method_type = "AmericanExpress"
+[[datatrans.debit]]
+  payment_method_type = "JCB"
+[[datatrans.debit]]
+  payment_method_type = "DinersClub"
+[[datatrans.debit]]
+  payment_method_type = "Discover"
+[[datatrans.debit]]
+  payment_method_type = "CartesBancaires"
+[[datatrans.debit]]
+  payment_method_type = "UnionPay"
+[datatrans.connector_auth.BodyKey]
+api_key = "Passcode"
+key1 = "datatrans MerchantId"
\ No newline at end of file
diff --git a/crates/router/src/connector/datatrans.rs b/crates/router/src/connector/datatrans.rs
index 90c6b38d2fb..9c7772c5b3e 100644
--- a/crates/router/src/connector/datatrans.rs
+++ b/crates/router/src/connector/datatrans.rs
@@ -1,13 +1,15 @@
 pub mod transformers;
-
-use std::fmt::Debug;
-
+use api_models::enums::{CaptureMethod, PaymentMethodType};
+use base64::Engine;
+use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
 use error_stack::{report, ResultExt};
-use masking::ExposeInterface;
-use transformers as datatrans;
+use masking::PeekInterface;
+use transformers::{self as datatrans};
 
+use super::{utils as connector_utils, utils::RefundsRequestData};
 use crate::{
     configs::settings,
+    consts,
     core::errors::{self, CustomResult},
     events::connector_api_logs::ConnectorEvent,
     headers,
@@ -24,9 +26,6 @@ use crate::{
     utils::BytesExt,
 };
 
-#[derive(Debug, Clone)]
-pub struct Datatrans;
-
 impl api::Payment for Datatrans {}
 impl api::PaymentSession for Datatrans {}
 impl api::ConnectorAccessToken for Datatrans {}
@@ -40,6 +39,19 @@ impl api::RefundExecute for Datatrans {}
 impl api::RefundSync for Datatrans {}
 impl api::PaymentToken for Datatrans {}
 
+#[derive(Clone)]
+pub struct Datatrans {
+    amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
+}
+
+impl Datatrans {
+    pub const fn new() -> &'static Self {
+        &Self {
+            amount_converter: &MinorUnitForConnector,
+        }
+    }
+}
+
 impl
     ConnectorIntegration<
         api::PaymentMethodToken,
@@ -92,9 +104,11 @@ impl ConnectorCommon for Datatrans {
     ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
         let auth = datatrans::DatatransAuthType::try_from(auth_type)
             .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+        let auth_key = format!("{}:{}", auth.merchant_id.peek(), auth.passcode.peek());
+        let auth_header = format!("Basic {}", consts::BASE64_ENGINE.encode(auth_key));
         Ok(vec![(
             headers::AUTHORIZATION.to_string(),
-            auth.api_key.expose().into_masked(),
+            auth_header.into_masked(),
         )])
     }
 
@@ -110,12 +124,11 @@ impl ConnectorCommon for Datatrans {
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-
         Ok(ErrorResponse {
             status_code: res.status_code,
-            code: response.code,
-            message: response.message,
-            reason: response.reason,
+            code: response.error.code,
+            message: response.error.message.clone(),
+            reason: Some(response.error.message.clone()),
             attempt_status: None,
             connector_transaction_id: None,
         })
@@ -124,6 +137,23 @@ impl ConnectorCommon for Datatrans {
 
 impl ConnectorValidation for Datatrans {
     //TODO: implement functions when support enabled
+    fn validate_capture_method(
+        &self,
+        capture_method: Option<CaptureMethod>,
+        _pmt: Option<PaymentMethodType>,
+    ) -> CustomResult<(), errors::ConnectorError> {
+        let capture_method = capture_method.unwrap_or_default();
+        match capture_method {
+            CaptureMethod::Automatic | CaptureMethod::Manual => Ok(()),
+            CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => {
+                Err(errors::ConnectorError::NotSupported {
+                    message: capture_method.to_string(),
+                    connector: self.id(),
+                }
+                .into())
+            }
+        }
+    }
 }
 
 impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
@@ -164,9 +194,10 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
     fn get_url(
         &self,
         _req: &types::PaymentsAuthorizeRouterData,
-        _connectors: &settings::Connectors,
+        connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let base_url = self.base_url(connectors);
+        Ok(format!("{base_url}v1/transactions/authorize"))
     }
 
     fn get_request_body(
@@ -174,12 +205,12 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         req: &types::PaymentsAuthorizeRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_router_data = datatrans::DatatransRouterData::try_from((
-            &self.get_currency_unit(),
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount,
             req.request.currency,
-            req.request.amount,
-            req,
-        ))?;
+        )?;
+        let connector_router_data = datatrans::DatatransRouterData::try_from((amount, req))?;
         let connector_req = datatrans::DatatransPaymentsRequest::try_from(&connector_router_data)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
@@ -212,7 +243,7 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
-        let response: datatrans::DatatransPaymentsResponse = res
+        let response: datatrans::DatatransResponse = res
             .response
             .parse_struct("Datatrans PaymentsAuthorizeResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
@@ -251,10 +282,16 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
 
     fn get_url(
         &self,
-        _req: &types::PaymentsSyncRouterData,
-        _connectors: &settings::Connectors,
+        req: &types::PaymentsSyncRouterData,
+        connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let connector_payment_id = req
+            .request
+            .connector_transaction_id
+            .get_connector_transaction_id()
+            .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
+        let base_url = self.base_url(connectors);
+        Ok(format!("{base_url}v1/transactions/{connector_payment_id}"))
     }
 
     fn build_request(
@@ -278,9 +315,9 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
-        let response: datatrans::DatatransPaymentsResponse = res
+        let response: datatrans::DatatransSyncResponse = res
             .response
-            .parse_struct("datatrans PaymentsSyncResponse")
+            .parse_struct("datatrans DatatransSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -317,18 +354,29 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
 
     fn get_url(
         &self,
-        _req: &types::PaymentsCaptureRouterData,
-        _connectors: &settings::Connectors,
+        req: &types::PaymentsCaptureRouterData,
+        connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let connector_payment_id = req.request.connector_transaction_id.clone();
+        let base_url = self.base_url(connectors);
+        Ok(format!(
+            "{base_url}v1/transactions/{connector_payment_id}/settle"
+        ))
     }
 
     fn get_request_body(
         &self,
-        _req: &types::PaymentsCaptureRouterData,
+        req: &types::PaymentsCaptureRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_amount_to_capture,
+            req.request.currency,
+        )?;
+        let connector_router_data = datatrans::DatatransRouterData::try_from((amount, req))?;
+        let connector_req = datatrans::DataPaymentCaptureRequest::try_from(&connector_router_data)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
@@ -357,10 +405,13 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError> {
-        let response: datatrans::DatatransPaymentsResponse = res
-            .response
-            .parse_struct("Datatrans PaymentsCaptureResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        let response = if res.response.is_empty() {
+            datatrans::DataTransCaptureResponse::Empty
+        } else {
+            res.response
+                .parse_struct("Datatrans DataTransCaptureResponse")
+                .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 {
@@ -382,6 +433,74 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
 impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
     for Datatrans
 {
+    fn get_headers(
+        &self,
+        req: &types::PaymentsCancelRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &types::PaymentsCancelRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let transaction_id = req.request.connector_transaction_id.clone();
+        let base_url = self.base_url(connectors);
+        Ok(format!("{base_url}v1/transactions/{transaction_id}/cancel"))
+    }
+
+    fn build_request(
+        &self,
+        req: &types::PaymentsCancelRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        let request = services::RequestBuilder::new()
+            .method(services::Method::Post)
+            .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+            .attach_default_headers()
+            .headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
+            .set_body(types::PaymentsVoidType::get_request_body(
+                self, req, connectors,
+            )?)
+            .build();
+        Ok(Some(request))
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::PaymentsCancelRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
+        let response = if res.response.is_empty() {
+            datatrans::DataTransCancelResponse::Empty
+        } else {
+            res.response
+                .parse_struct("Datatrans DataTransCancelResponse")
+                .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: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
 }
 
 impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
@@ -401,10 +520,12 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
 
     fn get_url(
         &self,
-        _req: &types::RefundsRouterData<api::Execute>,
-        _connectors: &settings::Connectors,
+        req: &types::RefundsRouterData<api::Execute>,
+        connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let transaction_id = req.request.connector_transaction_id.clone();
+        let base_url = self.base_url(connectors);
+        Ok(format!("{base_url}v1/transactions/{transaction_id}/credit"))
     }
 
     fn get_request_body(
@@ -412,12 +533,12 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         req: &types::RefundsRouterData<api::Execute>,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_router_data = datatrans::DatatransRouterData::try_from((
-            &self.get_currency_unit(),
+        let amount = connector_utils::convert_amount(
+            self.amount_converter,
+            req.request.minor_refund_amount,
             req.request.currency,
-            req.request.refund_amount,
-            req,
-        ))?;
+        )?;
+        let connector_router_data = datatrans::DatatransRouterData::try_from((amount, req))?;
         let connector_req = datatrans::DatatransRefundRequest::try_from(&connector_router_data)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
@@ -447,11 +568,12 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
-        let response: datatrans::RefundResponse = res
+        let response: datatrans::DatatransRefundsResponse = res
             .response
-            .parse_struct("datatrans RefundResponse")
+            .parse_struct("datatrans DatatransRefundsResponse")
             .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,
@@ -486,10 +608,12 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
 
     fn get_url(
         &self,
-        _req: &types::RefundSyncRouterData,
-        _connectors: &settings::Connectors,
+        req: &types::RefundSyncRouterData,
+        connectors: &settings::Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        let connector_refund_id = req.request.get_connector_refund_id()?;
+        let base_url = self.base_url(connectors);
+        Ok(format!("{base_url}v1/transactions/{connector_refund_id}"))
     }
 
     fn build_request(
@@ -516,9 +640,9 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<types::RefundSyncRouterData, errors::ConnectorError> {
-        let response: datatrans::RefundResponse = res
+        let response: datatrans::DatatransSyncResponse = res
             .response
-            .parse_struct("datatrans RefundSyncResponse")
+            .parse_struct("datatrans DatatransSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
diff --git a/crates/router/src/connector/datatrans/transformers.rs b/crates/router/src/connector/datatrans/transformers.rs
index b079708e233..bb8c85b77da 100644
--- a/crates/router/src/connector/datatrans/transformers.rs
+++ b/crates/router/src/connector/datatrans/transformers.rs
@@ -1,24 +1,149 @@
+use std::fmt::Debug;
+
+use common_utils::types::MinorUnit;
 use masking::Secret;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    connector::utils::PaymentsAuthorizeRequestData,
+    connector::{
+        utils as connector_utils,
+        utils::{PaymentsAuthorizeRequestData, RouterData},
+    },
     core::errors,
-    types::{self, api, domain, storage::enums},
+    types::{
+        self,
+        api::{self, enums},
+        domain,
+        transformers::ForeignFrom,
+    },
 };
 
-//TODO: Fill the struct with respective fields
+const TRANSACTION_ALREADY_CANCELLED: &str = "transaction already canceled";
+const TRANSACTION_ALREADY_SETTLED: &str = "already settled";
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct DatatransErrorResponse {
+    pub error: DatatransError,
+}
+pub struct DatatransAuthType {
+    pub(super) merchant_id: Secret<String>,
+    pub(super) passcode: Secret<String>,
+}
+
 pub struct DatatransRouterData<T> {
-    pub amount: i64, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
+    pub amount: MinorUnit,
     pub router_data: T,
 }
 
-impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for DatatransRouterData<T> {
+#[derive(Debug, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DatatransPaymentsRequest {
+    pub amount: MinorUnit,
+    pub currency: enums::Currency,
+    pub card: PlainCardDetails,
+    pub refno: String,
+    pub auto_settle: bool,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TransactionType {
+    Payment,
+    Credit,
+    CardCheck,
+}
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TransactionStatus {
+    Initialized,
+    Authenticated,
+    Authorized,
+    Settled,
+    Canceled,
+    Transmitted,
+    Failed,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(untagged)]
+pub enum DatatransSyncResponse {
+    Error(DatatransError),
+    Response(SyncResponse),
+}
+#[derive(Debug, Deserialize, Serialize)]
+pub enum DataTransCaptureResponse {
+    Error(DatatransError),
+    Empty,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub enum DataTransCancelResponse {
+    Error(DatatransError),
+    Empty,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncResponse {
+    pub transaction_id: String,
+    #[serde(rename = "type")]
+    pub res_type: TransactionType,
+    pub status: TransactionStatus,
+}
+
+#[derive(Serialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct PlainCardDetails {
+    #[serde(rename = "type")]
+    pub res_type: String,
+    pub number: cards::CardNumber,
+    pub expiry_month: Secret<String>,
+    pub expiry_year: Secret<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Default, Deserialize)]
+pub struct DatatransError {
+    pub code: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum DatatransResponse {
+    TransactionResponse(DatatransSuccessResponse),
+    ErrorResponse(DatatransError),
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatatransSuccessResponse {
+    pub transaction_id: String,
+    pub acquirer_authorization_code: String,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum DatatransRefundsResponse {
+    Success(DatatransSuccessResponse),
+    Error(DatatransError),
+}
+
+#[derive(Default, Debug, Serialize)]
+pub struct DatatransRefundRequest {
+    pub amount: MinorUnit,
+    pub currency: enums::Currency,
+    pub refno: String,
+}
+
+#[derive(Debug, Serialize, Clone)]
+pub struct DataPaymentCaptureRequest {
+    pub amount: MinorUnit,
+    pub currency: enums::Currency,
+    pub refno: String,
+}
+
+impl<T> TryFrom<(MinorUnit, T)> for DatatransRouterData<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> {
-        //Todo :  use utils to convert the amount to the type of amount that a connector accepts
+    fn try_from((amount, item): (MinorUnit, T)) -> Result<Self, Self::Error> {
         Ok(Self {
             amount,
             router_data: item,
@@ -26,22 +151,6 @@ impl<T> TryFrom<(&api::CurrencyUnit, enums::Currency, i64, T)> for DatatransRout
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct DatatransPaymentsRequest {
-    amount: i64,
-    card: DatatransCard,
-}
-
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
-pub struct DatatransCard {
-    number: cards::CardNumber,
-    expiry_month: Secret<String>,
-    expiry_year: Secret<String>,
-    cvc: Secret<String>,
-    complete: bool,
-}
-
 impl TryFrom<&DatatransRouterData<&types::PaymentsAuthorizeRouterData>>
     for DatatransPaymentsRequest
 {
@@ -49,108 +158,162 @@ impl TryFrom<&DatatransRouterData<&types::PaymentsAuthorizeRouterData>>
     fn try_from(
         item: &DatatransRouterData<&types::PaymentsAuthorizeRouterData>,
     ) -> Result<Self, Self::Error> {
+        if item.router_data.is_three_ds() {
+            return Err(errors::ConnectorError::NotImplemented(
+                "Three_ds payments through Datatrans".to_string(),
+            )
+            .into());
+        };
         match item.router_data.request.payment_method_data.clone() {
-            domain::PaymentMethodData::Card(req_card) => {
-                let card = DatatransCard {
+            domain::PaymentMethodData::Card(req_card) => Ok(Self {
+                amount: item.amount,
+                currency: item.router_data.request.currency,
+                card: PlainCardDetails {
+                    res_type: "PLAIN".to_string(),
                     number: req_card.card_number,
                     expiry_month: req_card.card_exp_month,
                     expiry_year: req_card.card_exp_year,
-                    cvc: req_card.card_cvc,
-                    complete: item.router_data.request.is_auto_capture()?,
-                };
-                Ok(Self {
-                    amount: item.amount.to_owned(),
-                    card,
-                })
+                },
+                refno: item.router_data.connector_request_reference_id.clone(),
+                auto_settle: matches!(
+                    item.router_data.request.capture_method,
+                    Some(enums::CaptureMethod::Automatic)
+                ),
+            }),
+            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::CardRedirect(_)
+            | domain::PaymentMethodData::Voucher(_)
+            | domain::PaymentMethodData::GiftCard(_)
+            | domain::PaymentMethodData::CardToken(_) => {
+                Err(errors::ConnectorError::NotImplemented(
+                    connector_utils::get_unimplemented_payment_method_error_message("Datatrans"),
+                ))?
             }
-            _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
         }
     }
 }
-
-//TODO: Fill the struct with respective fields
-// Auth Struct
-pub struct DatatransAuthType {
-    pub(super) api_key: Secret<String>,
-}
-
 impl TryFrom<&types::ConnectorAuthType> for DatatransAuthType {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
         match auth_type {
-            types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
-                api_key: api_key.to_owned(),
+            types::ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
+                merchant_id: key1.clone(),
+                passcode: api_key.clone(),
             }),
             _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
         }
     }
 }
-// PaymentsResponse
-//TODO: Append the remaining status flags
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "lowercase")]
-pub enum DatatransPaymentStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
-}
 
-impl From<DatatransPaymentStatus> for enums::AttemptStatus {
-    fn from(item: DatatransPaymentStatus) -> Self {
+impl ForeignFrom<(&DatatransResponse, bool)> for enums::AttemptStatus {
+    fn foreign_from((item, is_auto_capture): (&DatatransResponse, bool)) -> Self {
         match item {
-            DatatransPaymentStatus::Succeeded => Self::Charged,
-            DatatransPaymentStatus::Failed => Self::Failure,
-            DatatransPaymentStatus::Processing => Self::Authorizing,
+            DatatransResponse::ErrorResponse(_) => Self::Failure,
+            DatatransResponse::TransactionResponse(_) => {
+                if is_auto_capture {
+                    Self::Charged
+                } else {
+                    Self::Authorized
+                }
+            }
+        }
+    }
+}
+impl From<SyncResponse> for enums::AttemptStatus {
+    fn from(item: SyncResponse) -> Self {
+        match item.res_type {
+            TransactionType::Payment => match item.status {
+                TransactionStatus::Authorized => Self::Authorized,
+                TransactionStatus::Settled | TransactionStatus::Transmitted => Self::Charged,
+                TransactionStatus::Canceled => Self::Voided,
+                TransactionStatus::Failed => Self::Failure,
+                TransactionStatus::Initialized | TransactionStatus::Authenticated => Self::Pending,
+            },
+            TransactionType::Credit | TransactionType::CardCheck => Self::Failure,
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct DatatransPaymentsResponse {
-    status: DatatransPaymentStatus,
-    id: String,
+impl From<SyncResponse> for enums::RefundStatus {
+    fn from(item: SyncResponse) -> Self {
+        match item.res_type {
+            TransactionType::Credit => match item.status {
+                TransactionStatus::Settled | TransactionStatus::Transmitted => Self::Success,
+                TransactionStatus::Initialized
+                | TransactionStatus::Authenticated
+                | TransactionStatus::Authorized
+                | TransactionStatus::Canceled
+                | TransactionStatus::Failed => Self::Failure,
+            },
+            TransactionType::Payment | TransactionType::CardCheck => Self::Failure,
+        }
+    }
 }
 
-impl<F, T>
-    TryFrom<types::ResponseRouterData<F, DatatransPaymentsResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
+impl<F>
+    TryFrom<
+        types::ResponseRouterData<
+            F,
+            DatatransResponse,
+            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,
-            DatatransPaymentsResponse,
-            T,
+            DatatransResponse,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            status: enums::AttemptStatus::from(item.response.status),
-            response: Ok(types::PaymentsResponseData::TransactionResponse {
-                resource_id: types::ResponseId::ConnectorTransactionId(item.response.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,
+        let status = enums::AttemptStatus::foreign_from((
+            &item.response,
+            item.data.request.is_auto_capture()?,
+        ));
+        let response = match &item.response {
+            DatatransResponse::ErrorResponse(error) => Err(types::ErrorResponse {
+                code: error.code.clone(),
+                message: error.message.clone(),
+                reason: Some(error.message.clone()),
+                attempt_status: None,
+                connector_transaction_id: None,
+                status_code: item.http_code,
             }),
+            DatatransResponse::TransactionResponse(response) => {
+                Ok(types::PaymentsResponseData::TransactionResponse {
+                    resource_id: types::ResponseId::ConnectorTransactionId(
+                        response.transaction_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
         })
     }
 }
 
-//TODO: Fill the struct with respective fields
-// REFUND :
-// Type definition for RefundRequest
-#[derive(Default, Debug, Serialize)]
-pub struct DatatransRefundRequest {
-    pub amount: i64,
-}
-
 impl<F> TryFrom<&DatatransRouterData<&types::RefundsRouterData<F>>> for DatatransRefundRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
@@ -158,78 +321,191 @@ impl<F> TryFrom<&DatatransRouterData<&types::RefundsRouterData<F>>> for Datatran
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             amount: item.amount.to_owned(),
+            currency: item.router_data.request.currency,
+            refno: item.router_data.request.refund_id.clone(),
         })
     }
 }
 
-// Type definition for Refund Response
+impl TryFrom<types::RefundsResponseRouterData<api::Execute, DatatransRefundsResponse>>
+    for types::RefundsRouterData<api::Execute>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::RefundsResponseRouterData<api::Execute, DatatransRefundsResponse>,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            DatatransRefundsResponse::Error(error) => Ok(Self {
+                response: Err(types::ErrorResponse {
+                    code: error.code.clone(),
+                    message: error.message.clone(),
+                    reason: Some(error.message),
+                    attempt_status: None,
+                    connector_transaction_id: None,
+                    status_code: item.http_code,
+                }),
+                ..item.data
+            }),
+            DatatransRefundsResponse::Success(response) => Ok(Self {
+                response: Ok(types::RefundsResponseData {
+                    connector_refund_id: response.transaction_id,
+                    refund_status: enums::RefundStatus::Success,
+                }),
+                ..item.data
+            }),
+        }
+    }
+}
 
-#[allow(dead_code)]
-#[derive(Debug, Serialize, Default, Deserialize, Clone)]
-pub enum RefundStatus {
-    Succeeded,
-    Failed,
-    #[default]
-    Processing,
+impl TryFrom<types::RefundsResponseRouterData<api::RSync, DatatransSyncResponse>>
+    for types::RefundsRouterData<api::RSync>
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::RefundsResponseRouterData<api::RSync, DatatransSyncResponse>,
+    ) -> Result<Self, Self::Error> {
+        let response = match item.response {
+            DatatransSyncResponse::Error(error) => Err(types::ErrorResponse {
+                code: error.code.clone(),
+                message: error.message.clone(),
+                reason: Some(error.message),
+                attempt_status: None,
+                connector_transaction_id: None,
+                status_code: item.http_code,
+            }),
+            DatatransSyncResponse::Response(response) => Ok(types::RefundsResponseData {
+                connector_refund_id: response.transaction_id.to_string(),
+                refund_status: enums::RefundStatus::from(response),
+            }),
+        };
+        Ok(Self {
+            response,
+            ..item.data
+        })
+    }
 }
 
-impl From<RefundStatus> for enums::RefundStatus {
-    fn from(item: RefundStatus) -> Self {
-        match item {
-            RefundStatus::Succeeded => Self::Success,
-            RefundStatus::Failed => Self::Failure,
-            RefundStatus::Processing => Self::Pending,
-            //TODO: Review mapping
+impl TryFrom<types::PaymentsSyncResponseRouterData<DatatransSyncResponse>>
+    for types::PaymentsSyncRouterData
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: types::PaymentsSyncResponseRouterData<DatatransSyncResponse>,
+    ) -> Result<Self, Self::Error> {
+        match item.response {
+            DatatransSyncResponse::Error(error) => {
+                let response = Err(types::ErrorResponse {
+                    code: error.code.clone(),
+                    message: error.message.clone(),
+                    reason: Some(error.message),
+                    attempt_status: None,
+                    connector_transaction_id: None,
+                    status_code: item.http_code,
+                });
+                Ok(Self {
+                    response,
+                    ..item.data
+                })
+            }
+            DatatransSyncResponse::Response(response) => {
+                let resource_id =
+                    types::ResponseId::ConnectorTransactionId(response.transaction_id.to_string());
+                Ok(Self {
+                    status: enums::AttemptStatus::from(response),
+                    response: Ok(types::PaymentsResponseData::TransactionResponse {
+                        resource_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
+                })
+            }
         }
     }
 }
 
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub struct RefundResponse {
-    id: String,
-    status: RefundStatus,
+impl TryFrom<&DatatransRouterData<&types::PaymentsCaptureRouterData>>
+    for DataPaymentCaptureRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: &DatatransRouterData<&types::PaymentsCaptureRouterData>,
+    ) -> Result<Self, Self::Error> {
+        Ok(Self {
+            amount: item.amount,
+            currency: item.router_data.request.currency,
+            refno: item.router_data.connector_request_reference_id.clone(),
+        })
+    }
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::Execute, RefundResponse>>
-    for types::RefundsRouterData<api::Execute>
+impl TryFrom<types::PaymentsCaptureResponseRouterData<DataTransCaptureResponse>>
+    for types::PaymentsCaptureRouterData
 {
     type Error = error_stack::Report<errors::ConnectorError>;
+
     fn try_from(
-        item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
+        item: types::PaymentsCaptureResponseRouterData<DataTransCaptureResponse>,
     ) -> Result<Self, Self::Error> {
+        let status = match item.response {
+            DataTransCaptureResponse::Error(error) => {
+                if error.message == *TRANSACTION_ALREADY_SETTLED {
+                    common_enums::AttemptStatus::Charged
+                } else {
+                    common_enums::AttemptStatus::Failure
+                }
+            }
+            // Datatrans http code 204 implies Successful Capture
+            //https://api-reference.datatrans.ch/#tag/v1transactions/operation/settle
+            DataTransCaptureResponse::Empty => {
+                if item.http_code == 204 {
+                    common_enums::AttemptStatus::Charged
+                } else {
+                    common_enums::AttemptStatus::Failure
+                }
+            }
+        };
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
-            }),
+            status,
             ..item.data
         })
     }
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::RSync, RefundResponse>>
-    for types::RefundsRouterData<api::RSync>
+impl TryFrom<types::PaymentsCancelResponseRouterData<DataTransCancelResponse>>
+    for types::PaymentsCancelRouterData
 {
     type Error = error_stack::Report<errors::ConnectorError>;
+
     fn try_from(
-        item: types::RefundsResponseRouterData<api::RSync, RefundResponse>,
+        item: types::PaymentsCancelResponseRouterData<DataTransCancelResponse>,
     ) -> Result<Self, Self::Error> {
+        let status = match item.response {
+            // Datatrans http code 204 implies Successful Cancellation
+            //https://api-reference.datatrans.ch/#tag/v1transactions/operation/cancel
+            DataTransCancelResponse::Empty => {
+                if item.http_code == 204 {
+                    common_enums::AttemptStatus::Voided
+                } else {
+                    common_enums::AttemptStatus::Failure
+                }
+            }
+            DataTransCancelResponse::Error(error) => {
+                if error.message == *TRANSACTION_ALREADY_CANCELLED {
+                    common_enums::AttemptStatus::Voided
+                } else {
+                    common_enums::AttemptStatus::Failure
+                }
+            }
+        };
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
-                connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
-            }),
+            status,
             ..item.data
         })
     }
 }
-
-//TODO: Fill the struct with respective fields
-#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DatatransErrorResponse {
-    pub status_code: u16,
-    pub code: String,
-    pub message: String,
-    pub reason: Option<String>,
-}
diff --git a/crates/router/src/core/admin.rs b/crates/router/src/core/admin.rs
index dc72ec2ba89..5f082625eeb 100644
--- a/crates/router/src/core/admin.rs
+++ b/crates/router/src/core/admin.rs
@@ -2220,11 +2220,10 @@ pub(crate) fn validate_auth_and_metadata_type_with_connector(
             cybersource::transformers::CybersourceAuthType::try_from(val)?;
             Ok(())
         }
-        // api_enums::Connector::Datatrans => {
-        //     datatrans::transformers::DatatransAuthType::try_from(val)?;
-        //     Ok(())
-        // }
-        // added for future use
+        api_enums::Connector::Datatrans => {
+            datatrans::transformers::DatatransAuthType::try_from(val)?;
+            Ok(())
+        }
         api_enums::Connector::Dlocal => {
             dlocal::transformers::DlocalAuthType::try_from(val)?;
             Ok(())
diff --git a/crates/router/src/core/payments/connector_integration_v2_impls.rs b/crates/router/src/core/payments/connector_integration_v2_impls.rs
index b54838e5258..5528db77153 100644
--- a/crates/router/src/core/payments/connector_integration_v2_impls.rs
+++ b/crates/router/src/core/payments/connector_integration_v2_impls.rs
@@ -620,6 +620,7 @@ default_imp_for_new_connector_integration_payment!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -703,6 +704,7 @@ default_imp_for_new_connector_integration_refund!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -781,6 +783,7 @@ default_imp_for_new_connector_integration_connector_access_token!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -881,6 +884,7 @@ default_imp_for_new_connector_integration_accept_dispute!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -963,6 +967,7 @@ default_imp_for_new_connector_integration_defend_dispute!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1029,6 +1034,7 @@ default_imp_for_new_connector_integration_submit_evidence!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1122,6 +1128,7 @@ default_imp_for_new_connector_integration_file_upload!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1197,6 +1204,7 @@ default_imp_for_new_connector_integration_payouts!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1282,6 +1290,7 @@ default_imp_for_new_connector_integration_payouts_create!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1367,6 +1376,7 @@ default_imp_for_new_connector_integration_payouts_eligibility!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1452,6 +1462,7 @@ default_imp_for_new_connector_integration_payouts_fulfill!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1537,6 +1548,7 @@ default_imp_for_new_connector_integration_payouts_cancel!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1622,6 +1634,7 @@ default_imp_for_new_connector_integration_payouts_quote!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1707,6 +1720,7 @@ default_imp_for_new_connector_integration_payouts_recipient!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1792,6 +1806,7 @@ default_imp_for_new_connector_integration_payouts_recipient_account!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1875,6 +1890,7 @@ default_imp_for_new_connector_integration_webhook_source_verification!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -1950,6 +1966,7 @@ default_imp_for_new_connector_integration_frm!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2035,6 +2052,7 @@ default_imp_for_new_connector_integration_frm_sale!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2120,6 +2138,7 @@ default_imp_for_new_connector_integration_frm_checkout!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2205,6 +2224,7 @@ default_imp_for_new_connector_integration_frm_transaction!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2290,6 +2310,7 @@ default_imp_for_new_connector_integration_frm_fulfillment!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2375,6 +2396,7 @@ default_imp_for_new_connector_integration_frm_record_return!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2457,6 +2479,7 @@ default_imp_for_new_connector_integration_revoking_mandates!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
@@ -2567,6 +2590,7 @@ default_imp_for_new_connector_integration_connector_authentication!(
     connector::Cryptopay,
     connector::Coinbase,
     connector::Cybersource,
+    connector::Datatrans,
     connector::Dlocal,
     connector::Ebanx,
     connector::Fiserv,
diff --git a/crates/router/src/types/api.rs b/crates/router/src/types/api.rs
index 443ca00f24f..c93cdb80022 100644
--- a/crates/router/src/types/api.rs
+++ b/crates/router/src/types/api.rs
@@ -388,6 +388,9 @@ impl ConnectorData {
                 enums::Connector::Cybersource => {
                     Ok(ConnectorEnum::Old(Box::new(&connector::Cybersource)))
                 }
+                enums::Connector::Datatrans => {
+                    Ok(ConnectorEnum::Old(Box::new(connector::Datatrans::new())))
+                }
                 enums::Connector::Dlocal => Ok(ConnectorEnum::Old(Box::new(&connector::Dlocal))),
                 #[cfg(feature = "dummy_connector")]
                 enums::Connector::DummyConnector1 => Ok(ConnectorEnum::Old(Box::new(
diff --git a/crates/router/src/types/transformers.rs b/crates/router/src/types/transformers.rs
index b06599769f4..4b937a68139 100644
--- a/crates/router/src/types/transformers.rs
+++ b/crates/router/src/types/transformers.rs
@@ -239,7 +239,7 @@ impl ForeignTryFrom<api_enums::Connector> for common_enums::RoutableConnectors {
             api_enums::Connector::Coinbase => Self::Coinbase,
             api_enums::Connector::Cryptopay => Self::Cryptopay,
             api_enums::Connector::Cybersource => Self::Cybersource,
-            // api_enums::Connector::Datatrans => Self::Datatrans,  added as template code for future use
+            api_enums::Connector::Datatrans => Self::Datatrans,
             api_enums::Connector::Dlocal => Self::Dlocal,
             api_enums::Connector::Ebanx => Self::Ebanx,
             api_enums::Connector::Fiserv => Self::Fiserv,
diff --git a/postman/collection-json/datatrans.postman_collection.json b/postman/collection-json/datatrans.postman_collection.json
new file mode 100644
index 00000000000..a0c5175623b
--- /dev/null
+++ b/postman/collection-json/datatrans.postman_collection.json
@@ -0,0 +1,3869 @@
+{
+	"info": {
+		"_postman_id": "600681c5-58d0-4009-b0ec-9c72b9fa14f9",
+		"name": "Datatrans",
+		"description": "## Get started\n\nJuspay Router provides a collection of APIs that enable you to process and manage payments. Our APIs accept and return JSON in the HTTP body, and return standard HTTP response codes.  \nYou can consume the APIs directly using your favorite HTTP/REST library.  \nWe have a testing environment referred to \"sandbox\", which you can setup to test API calls without affecting production data.\n\n### Base URLs\n\nUse the following base URLs when making requests to the APIs:\n\n| Environment | Base URL |\n| --- | --- |\n| Sandbox | [https://sandbox.hyperswitch.io](https://sandbox.hyperswitch.io) |\n| Production | [https://router.juspay.io](https://router.juspay.io) |\n\n# Authentication\n\nWhen you sign up for an account, you are given a secret key (also referred as api-key). You may authenticate all API requests with Juspay server by providing the appropriate key in the request Authorization header.  \nNever share your secret api keys. Keep them guarded and secure.\n\nContact Support:  \nName: Juspay Support  \nEmail: [support@juspay.in](mailto:support@juspay.in)",
+		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
+		"_exporter_id": "29167164"
+	},
+	"item": [
+		{
+			"name": "Health check",
+			"item": []
+		},
+		{
+			"name": "Flow Testcases",
+			"item": [
+				{
+					"name": "QuickStart",
+					"item": [
+						{
+							"name": "Merchant Account - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx",
+											"pm.test(\"[POST]::/accounts - Status code is 2xx\", function () {",
+											"  pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[POST]::/accounts - Content-Type is application/json\", function () {",
+											"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+											"    \"application/json\",",
+											"  );",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {",
+											"  jsonData = pm.response.json();",
+											"} catch (e) {}",
+											"",
+											"// pm.collectionVariables - Set merchant_id as variable for jsonData.merchant_id",
+											"if (jsonData?.merchant_id) {",
+											"  pm.collectionVariables.set(\"merchant_id\", jsonData.merchant_id);",
+											"  console.log(",
+											"    \"- use {{merchant_id}} as collection variable for value\",",
+											"    jsonData.merchant_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{merchant_id}}, as jsonData.merchant_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set api_key as variable for jsonData.api_key",
+											"if (jsonData?.api_key) {",
+											"  pm.collectionVariables.set(\"api_key\", jsonData.api_key);",
+											"  console.log(",
+											"    \"- use {{api_key}} as collection variable for value\",",
+											"    jsonData.api_key,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{api_key}}, as jsonData.api_key is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set publishable_key as variable for jsonData.publishable_key",
+											"if (jsonData?.publishable_key) {",
+											"  pm.collectionVariables.set(\"publishable_key\", jsonData.publishable_key);",
+											"  console.log(",
+											"    \"- use {{publishable_key}} as collection variable for value\",",
+											"    jsonData.publishable_key,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{publishable_key}}, as jsonData.publishable_key is undefined.\",",
+											"  );",
+											"}",
+											""
+										],
+										"type": "text/javascript"
+									}
+								},
+								{
+									"listen": "prerequest",
+									"script": {
+										"exec": [
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"auth": {
+									"type": "apikey",
+									"apikey": [
+										{
+											"key": "value",
+											"value": "{{admin_api_key}}",
+											"type": "string"
+										},
+										{
+											"key": "key",
+											"value": "api-key",
+											"type": "string"
+										},
+										{
+											"key": "in",
+											"value": "header",
+											"type": "string"
+										}
+									]
+								},
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\"merchant_id\":\"postman_merchant_GHAction_{{$guid}}\",\"locker_id\":\"m0010\",\"merchant_name\":\"Braintree Merchant\",\"primary_business_details\":[{\"country\":\"US\",\"business\":\"default\"}],\"merchant_details\":{\"primary_contact_person\":\"John Test\",\"primary_email\":\"JohnTest@test.com\",\"primary_phone\":\"sunt laborum\",\"secondary_contact_person\":\"John Test2\",\"secondary_email\":\"JohnTest2@test.com\",\"secondary_phone\":\"cillum do dolor id\",\"website\":\"www.example.com\",\"about_business\":\"Online Retail with a wide selection of organic products for North America\",\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\"}},\"return_url\":\"https://duck.com/success\",\"webhook_details\":{\"webhook_version\":\"1.0.1\",\"webhook_username\":\"ekart_retail\",\"webhook_password\":\"password_ekart@123\",\"payment_created_enabled\":true,\"payment_succeeded_enabled\":true,\"payment_failed_enabled\":true},\"sub_merchants_enabled\":false,\"metadata\":{\"city\":\"NY\",\"unit\":\"245\"}}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/accounts",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"accounts"
+									]
+								},
+								"description": "Create a new account for a merchant. The merchant could be a seller or retailer or client who likes to receive and send payments."
+							},
+							"response": []
+						},
+						{
+							"name": "API Key - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx",
+											"pm.test(\"[POST]::/api_keys/:merchant_id - Status code is 2xx\", function () {",
+											"  pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(",
+											"  \"[POST]::/api_keys/:merchant_id - Content-Type is application/json\",",
+											"  function () {",
+											"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+											"      \"application/json\",",
+											"    );",
+											"  },",
+											");",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {",
+											"  jsonData = pm.response.json();",
+											"} catch (e) {}",
+											"",
+											"// pm.collectionVariables - Set api_key_id as variable for jsonData.key_id",
+											"if (jsonData?.key_id) {",
+											"  pm.collectionVariables.set(\"api_key_id\", jsonData.key_id);",
+											"  console.log(",
+											"    \"- use {{api_key_id}} as collection variable for value\",",
+											"    jsonData.key_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{api_key_id}}, as jsonData.key_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set api_key as variable for jsonData.api_key",
+											"if (jsonData?.api_key) {",
+											"  pm.collectionVariables.set(\"api_key\", jsonData.api_key);",
+											"  console.log(",
+											"    \"- use {{api_key}} as collection variable for value\",",
+											"    jsonData.api_key,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{api_key}}, as jsonData.api_key is undefined.\",",
+											"  );",
+											"}",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"auth": {
+									"type": "apikey",
+									"apikey": [
+										{
+											"key": "value",
+											"value": "{{admin_api_key}}",
+											"type": "string"
+										},
+										{
+											"key": "key",
+											"value": "api-key",
+											"type": "string"
+										}
+									]
+								},
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\"name\":\"API Key 1\",\"description\":null,\"expiration\":\"2069-09-23T01:02:03.000Z\"}"
+								},
+								"url": {
+									"raw": "{{baseUrl}}/api_keys/:merchant_id",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"api_keys",
+										":merchant_id"
+									],
+									"variable": [
+										{
+											"key": "merchant_id",
+											"value": "{{merchant_id}}"
+										}
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Payment Connector - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx",
+											"pm.test(",
+											"  \"[POST]::/account/:account_id/connectors - Status code is 2xx\",",
+											"  function () {",
+											"    pm.response.to.be.success;",
+											"  },",
+											");",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(",
+											"  \"[POST]::/account/:account_id/connectors - Content-Type is application/json\",",
+											"  function () {",
+											"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+											"      \"application/json\",",
+											"    );",
+											"  },",
+											");",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {",
+											"  jsonData = pm.response.json();",
+											"} catch (e) {}",
+											"",
+											"// pm.collectionVariables - Set merchant_connector_id as variable for jsonData.merchant_connector_id",
+											"if (jsonData?.merchant_connector_id) {",
+											"  pm.collectionVariables.set(",
+											"    \"merchant_connector_id\",",
+											"    jsonData.merchant_connector_id,",
+											"  );",
+											"  console.log(",
+											"    \"- use {{merchant_connector_id}} as collection variable for value\",",
+											"    jsonData.merchant_connector_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{merchant_connector_id}}, as jsonData.merchant_connector_id is undefined.\",",
+											"  );",
+											"}",
+											""
+										],
+										"type": "text/javascript"
+									}
+								},
+								{
+									"listen": "prerequest",
+									"script": {
+										"exec": [
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"auth": {
+									"type": "apikey",
+									"apikey": [
+										{
+											"key": "value",
+											"value": "{{admin_api_key}}",
+											"type": "string"
+										},
+										{
+											"key": "key",
+											"value": "api-key",
+											"type": "string"
+										},
+										{
+											"key": "in",
+											"value": "header",
+											"type": "string"
+										}
+									]
+								},
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n  \"connector_type\": \"fiz_operations\",\n  \"connector_name\": \"datatrans\",\n  \"connector_account_details\": {\n    \"auth_type\": \"BodyKey\",\n    \"key1\": \"{{merchantId}}\",\n    \"api_key\": \"{{passcode}}\"\n  },\n  \"test_mode\": false,\n  \"disabled\": false,\n  \"payment_methods_enabled\": [\n    {\n      \"payment_method\": \"card\",\n      \"payment_method_types\": [\n        {\n          \"payment_method_type\": \"credit\",\n          \"card_networks\": [\n            \"Visa\",\n            \"Mastercard\"\n          ],\n          \"minimum_amount\": 1,\n          \"maximum_amount\": 68607706,\n          \"recurring_enabled\": true,\n          \"installment_payment_enabled\": true\n        },\n        {\n          \"payment_method_type\": \"debit\",\n          \"card_networks\": [\n            \"Visa\",\n            \"Mastercard\"\n          ],\n          \"minimum_amount\": 1,\n          \"maximum_amount\": 68607706,\n          \"recurring_enabled\": true,\n          \"installment_payment_enabled\": true\n        }\n      ]\n    }\n  ],\n  \"metadata\": {\n    \"city\": \"NY\",\n    \"unit\": \"245\"\n  }\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/account/:account_id/connectors",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"account",
+										":account_id",
+										"connectors"
+									],
+									"variable": [
+										{
+											"key": "account_id",
+											"value": "{{merchant_id}}",
+											"description": "(Required) The unique identifier for the merchant account"
+										}
+									]
+								},
+								"description": "Create a new Payment Connector for the merchant account. The connector could be a payment processor / facilitator / acquirer or specialised services like Fraud / Accounting etc."
+							},
+							"response": []
+						},
+						{
+							"name": "Payments - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx",
+											"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+											"  pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+											"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+											"    \"application/json\",",
+											"  );",
+											"});",
+											"",
+											"// Validate if response has JSON Body",
+											"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+											"  pm.response.to.have.jsonBody();",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {",
+											"  jsonData = pm.response.json();",
+											"} catch (e) {}",
+											"",
+											"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+											"if (jsonData?.payment_id) {",
+											"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+											"  console.log(",
+											"    \"- use {{payment_id}} as collection variable for value\",",
+											"    jsonData.payment_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+											"if (jsonData?.mandate_id) {",
+											"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+											"  console.log(",
+											"    \"- use {{mandate_id}} as collection variable for value\",",
+											"    jsonData.mandate_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+											"if (jsonData?.client_secret) {",
+											"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+											"  console.log(",
+											"    \"- use {{client_secret}} as collection variable for value\",",
+											"    jsonData.client_secret,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+											"  );",
+											"}",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n    \"amount\": 16000,\n    \"currency\": \"USD\",\n    \"confirm\": true, \n    \"capture_method\": \"automatic\",\n    \"capture_on\": \"2022-09-10T10:11:12Z\",\n    \"amount_to_capture\": 16000,\n    \"customer_id\": \"First Customer\",\n    \"email\": \"guest@example.com\",\n    \"name\": \"John Doe\",\n    \"phone\": \"999999999\",\n    \"phone_country_code\": \"+65\",\n    \"description\": \"Its my first payment request\",\n    \"authentication_type\": \"no_three_ds\",\n    \"return_url\": \"https://duck.com\",\n    \"payment_method\": \"card\",\n    \"payment_method_type\": \"debit\",\n    \"payment_method_data\": {\n        \"card\": {\n            \"card_number\": \"5127880999999990\",\n            \"card_exp_month\": \"10\",\n            \"card_exp_year\": \"25\",\n            \"card_holder_name\": \"joseph Doe\",\n            \"card_cvc\": \"123\"\n        }\n    },\n    \"billing\": {\n        \"address\": {\n            \"line1\": \"1467\",\n            \"line2\": \"Harrison Street\",\n            \"line3\": \"Harrison Street\",\n            \"city\": \"San Fransico\",\n            \"state\": \"California\",\n            \"zip\": \"94122\",\n            \"country\": \"US\",\n            \"first_name\": \"joseph\",\n            \"last_name\": \"Doe\"\n        },\n        \"phone\": {\n            \"number\": \"8056594427\",\n            \"country_code\": \"+91\"\n        }\n    },\n    \"shipping\": {\n        \"address\": {\n            \"line1\": \"1467\",\n            \"line2\": \"Harrison Street\",\n            \"line3\": \"Harrison Street\",\n            \"city\": \"San Fransico\",\n            \"state\": \"California\",\n            \"zip\": \"94122\",\n            \"country\": \"US\",\n            \"first_name\": \"joseph\",\n            \"last_name\": \"Doe\"\n        },\n        \"phone\": {\n            \"number\": \"8056594427\",\n            \"country_code\": \"+91\"\n        }\n    },\n    \"statement_descriptor_name\": \"joseph\",\n    \"statement_descriptor_suffix\": \"JS\",\n    \"metadata\": {\n        \"udf1\": \"value1\",\n        \"new_customer\": \"true\",\n        \"login_date\": \"2019-09-10T10:11:12Z\"\n    }\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/payments",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"payments"
+									]
+								},
+								"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+							},
+							"response": []
+						},
+						{
+							"name": "Payments - Retrieve",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx",
+											"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+											"  pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+											"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+											"    \"application/json\",",
+											"  );",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {",
+											"  jsonData = pm.response.json();",
+											"} catch (e) {}",
+											"",
+											"// Validate if response has JSON Body",
+											"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+											"  pm.response.to.have.jsonBody();",
+											"});",
+											"",
+											"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+											"if (jsonData?.payment_id) {",
+											"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+											"  console.log(",
+											"    \"- use {{payment_id}} as collection variable for value\",",
+											"    jsonData.payment_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+											"if (jsonData?.mandate_id) {",
+											"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+											"  console.log(",
+											"    \"- use {{mandate_id}} as collection variable for value\",",
+											"    jsonData.mandate_id,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+											"  );",
+											"}",
+											"",
+											"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+											"if (jsonData?.client_secret) {",
+											"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+											"  console.log(",
+											"    \"- use {{client_secret}} as collection variable for value\",",
+											"    jsonData.client_secret,",
+											"  );",
+											"} else {",
+											"  console.log(",
+											"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+											"  );",
+											"}",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"payments",
+										":id"
+									],
+									"query": [
+										{
+											"key": "force_sync",
+											"value": "true"
+										}
+									],
+									"variable": [
+										{
+											"key": "id",
+											"value": "{{payment_id}}",
+											"description": "(Required) unique payment id"
+										}
+									]
+								},
+								"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+							},
+							"response": []
+						},
+						{
+							"name": "Payment-Capture",
+							"request": {
+								"method": "POST",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n  \"amount_to_capture\": 6540,\n  \"statement_descriptor_name\": \"Joseph\",\n  \"statement_descriptor_suffix\": \"JS\"\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/payments/:id/capture",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"payments",
+										":id",
+										"capture"
+									],
+									"variable": [
+										{
+											"key": "id",
+											"value": "{{payment_id}}"
+										}
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Refunds - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx ",
+											"pm.test(\"[POST]::/refunds - Status code is 2xx\", function () {",
+											"   pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[POST]::/refunds - Content-Type is application/json\", function () {",
+											"   pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {jsonData = pm.response.json();}catch(e){}",
+											"",
+											"// pm.collectionVariables - Set refund_id as variable for jsonData.payment_id",
+											"if (jsonData?.refund_id) {",
+											"   pm.collectionVariables.set(\"refund_id\", jsonData.refund_id);",
+											"   console.log(\"- use {{refund_id}} as collection variable for value\",jsonData.refund_id);",
+											"} else {",
+											"   console.log('INFO - Unable to assign variable {{refund_id}}, as jsonData.refund_id is undefined.');",
+											"};",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n  \"payment_id\": \"{{payment_id}}\",\n  \"amount\": 600,\n  \"reason\": \"Customer returned product\",\n  \"refund_type\": \"instant\"\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/refunds",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"refunds"
+									]
+								},
+								"description": "To create a refund against an already processed payment"
+							},
+							"response": []
+						}
+					]
+				},
+				{
+					"name": "Happy Cases",
+					"item": [
+						{
+							"name": "Scenario 1 - Create payment with confirm true",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6541,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Retrieve",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "GET",
+										"header": [
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id"
+											],
+											"query": [
+												{
+													"key": "force_sync",
+													"value": "true"
+												}
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 2 - Create payment with confirm false",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_confirmation\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'requires_confirmation'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_confirmation\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6542,\"currency\":\"USD\",\"confirm\":false,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"BraintreeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Confirm",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments/:id/confirm - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/confirm - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id/confirm - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"auth": {
+											"type": "apikey",
+											"apikey": [
+												{
+													"key": "value",
+													"value": "{{publishable_key}}",
+													"type": "string"
+												},
+												{
+													"key": "key",
+													"value": "api-key",
+													"type": "string"
+												},
+												{
+													"key": "in",
+													"value": "header",
+													"type": "string"
+												}
+											]
+										},
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"client_secret\":\"{{client_secret}}\"}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/confirm",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"confirm"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "This API is to confirm the payment request and forward payment to the payment processor. This API provides more granular control upon when the API is forwarded to the payment processor. Alternatively you can confirm the payment within the Payments-Create API"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Retrieve",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments:id - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "GET",
+										"header": [
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id"
+											],
+											"query": [
+												{
+													"key": "force_sync",
+													"value": "true"
+												}
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 3 - Create payment without PMD",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_payment_method\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'requires_payment_method'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_payment_method\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6543,\"currency\":\"USD\",\"confirm\":false,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"BraintreeCustomer1\",\"email\":\"guest1@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Confirm",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments/:id/confirm - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/confirm - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments:id/confirm - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"auth": {
+											"type": "apikey",
+											"apikey": [
+												{
+													"key": "value",
+													"value": "{{publishable_key}}",
+													"type": "string"
+												},
+												{
+													"key": "key",
+													"value": "api-key",
+													"type": "string"
+												},
+												{
+													"key": "in",
+													"value": "header",
+													"type": "string"
+												}
+											]
+										},
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"client_secret\":\"{{client_secret}}\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/confirm",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"confirm"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "This API is to confirm the payment request and forward payment to the payment processor. This API provides more granular control upon when the API is forwarded to the payment processor. Alternatively you can confirm the payment within the Payments-Create API"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Retrieve",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments:id - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "GET",
+										"header": [
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id"
+											],
+											"query": [
+												{
+													"key": "force_sync",
+													"value": "true"
+												}
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 4 - Void the payment",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_capture\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'requires_capture'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_capture\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6544,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"manual\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Cancel",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Disabling this for now since there's an issue with cancelling a payment in the code",
+													"// Validate status 2xx",
+													"// pm.test(\"[POST]::/payments/:id/cancel - Status code is 2xx\", function () {",
+													"//    pm.response.to.be.success;",
+													"// });",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/cancel - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/cancel - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"cancelled\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id/cancel - Content check if value for 'status' matches 'cancelled'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"cancelled\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"cancellation_reason\":\"requested_by_customer\"}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/cancel",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"cancel"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "A Payment could can be cancelled when it is in one of these statuses: requires_payment_method, requires_capture, requires_confirmation, requires_customer_action"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Retrieve",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Disabling this for now since there's an issue with cancelling a payment in the code",
+													"// Response body should have value \"cancelled\" for \"status\"",
+													"// if (jsonData?.status) {",
+													"// pm.test(\"[POST]::/payments/:id - Content check if value for 'status' matches 'cancelled'\", function() {",
+													"//   pm.expect(jsonData.status).to.eql(\"cancelled\");",
+													"// })};",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "GET",
+										"header": [
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id"
+											],
+											"query": [
+												{
+													"key": "force_sync",
+													"value": "true"
+												}
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+									},
+									"response": []
+								}
+							]
+						}
+					]
+				},
+				{
+					"name": "Variation Cases",
+					"item": [
+						{
+							"name": "Scenario 1 - Create payment with Invalid card details",
+							"item": [
+								{
+									"name": "Payments - Create(Invalid card number)",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"error\"",
+													"pm.test(\"[POST]::/payments - Content check if 'error' exists\", function () {",
+													"  pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"});",
+													"",
+													"// Response body should have value \"connector error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'error.type' matches 'connector_error'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"connector_error\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\n  \"amount\": 8600,\n  \"currency\": \"USD\",\n  \"confirm\": true,\n  \"capture_method\": \"automatic\",\n  \"payment_method\": \"card\",\n  \"payment_method_type\": \"credit\",\n  \"payment_method_data\": {\n    \"card\": {\n      \"card_number\": \"3423322\",\n      \"card_exp_month\": \"06\",\n      \"card_exp_year\": \"25\",\n      \"card_holder_name\": \"joseph Doe\",\n      \"card_cvc\":\"232\"\n    }\n  }\n}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Create(Invalid Exp month)",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"next_action.redirect_to_url\"",
+													"pm.test(\"[POST]::/payments - Content check if 'error' exists\", function () {",
+													"  pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"});",
+													"",
+													"// Response body should have value \"invalid_request error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6548,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"13\",\"card_exp_year\":\"2023\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Create(Invalid Exp Year)",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"next_action.redirect_to_url\"",
+													"pm.test(\"[POST]::/payments - Content check if 'error' exists\", function () {",
+													"  pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"});",
+													"",
+													"// Response body should have value \"invalid_request error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6549,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"19990\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Create(invalid CVV)",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"error\"",
+													"pm.test(\"[POST]::/payments - Content check if 'error' exists\", function () {",
+													"  pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"});",
+													"",
+													"// Response body should have value \"invalid_request error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6550,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4217651111111119\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"12345\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 2 - Confirming the payment without PMD",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_payment_method\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'requires_payment_method'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_payment_method\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6551,\"currency\":\"USD\",\"confirm\":false,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Confirm",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/confirm - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"error\"",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content check if 'error' exists\",",
+													"  function () {",
+													"    pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"  },",
+													");",
+													"",
+													"// Response body should have value \"connector error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id/confirm - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"auth": {
+											"type": "apikey",
+											"apikey": [
+												{
+													"key": "value",
+													"value": "{{publishable_key}}",
+													"type": "string"
+												},
+												{
+													"key": "key",
+													"value": "api-key",
+													"type": "string"
+												},
+												{
+													"key": "in",
+													"value": "header",
+													"type": "string"
+												}
+											]
+										},
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"client_secret\":\"{{client_secret}}\"}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/confirm",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"confirm"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "This API is to confirm the payment request and forward payment to the payment processor. This API provides more granular control upon when the API is forwarded to the payment processor. Alternatively you can confirm the payment within the Payments-Create API"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 3 - Void the success_slash_failure payment",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"processing\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'processing'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"processing\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount\":6552,\"currency\":\"USD\",\"confirm\":true,\"capture_method\":\"automatic\",\"capture_on\":\"2022-09-10T10:11:12Z\",\"amount_to_capture\":6540,\"customer_id\":\"StripeCustomer\",\"email\":\"guest@example.com\",\"name\":\"John Doe\",\"phone\":\"999999999\",\"phone_country_code\":\"+65\",\"description\":\"Its my first payment request\",\"authentication_type\":\"no_three_ds\",\"return_url\":\"https://duck.com\",\"payment_method\":\"card\",\"payment_method_data\":{\"card\":{\"card_number\":\"4242424242424242\",\"card_exp_month\":\"10\",\"card_exp_year\":\"25\",\"card_holder_name\":\"joseph Doe\",\"card_cvc\":\"123\"}},\"billing\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"shipping\":{\"address\":{\"line1\":\"1467\",\"line2\":\"Harrison Street\",\"line3\":\"Harrison Street\",\"city\":\"San Fransico\",\"state\":\"California\",\"zip\":\"94122\",\"country\":\"US\",\"first_name\":\"PiX\"}},\"statement_descriptor_name\":\"joseph\",\"statement_descriptor_suffix\":\"JS\",\"metadata\":{\"udf1\":\"value1\",\"new_customer\":\"true\",\"login_date\":\"2019-09-10T10:11:12Z\"}}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Cancel",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments/:id/cancel - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/cancel - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/cancel - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"error\"",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content check if 'error' exists\",",
+													"  function () {",
+													"    pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"  },",
+													");",
+													"",
+													"// Response body should have value \"connector error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id/confirm - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"cancellation_reason\":\"requested_by_customer\"}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/cancel",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"cancel"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "A Payment could can be cancelled when it is in one of these statuses: requires_payment_method, requires_capture, requires_confirmation, requires_customer_action"
+									},
+									"response": []
+								}
+							]
+						},
+						{
+							"name": "Scenario 4 - Create a payment with greater capture",
+							"item": [
+								{
+									"name": "Payments - Create",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[POST]::/payments - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[POST]::/payments - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_capture\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments - Content check if value for 'status' matches 'requires_capture'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_capture\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\n    \"amount\": 6553,\n    \"currency\": \"USD\",\n    \"confirm\": true,\n    \"capture_method\": \"manual\",\n    \"capture_on\": \"2022-09-10T10:11:12Z\",\n    \"amount_to_capture\": 6540,\n    \"customer_id\": \"StripeCustomer\",\n    \"email\": \"guest@example.com\",\n    \"name\": \"John Doe\",\n    \"phone\": \"999999999\",\n    \"phone_country_code\": \"+65\",\n    \"description\": \"Its my first payment request\",\n    \"authentication_type\": \"no_three_ds\",\n    \"return_url\": \"https://duck.com\",\n    \"payment_method\": \"card\",\n    \"payment_method_data\": {\n        \"card\": {\n      \"card_number\": \"4444090101010103\",\n      \"card_exp_month\": \"06\",\n      \"card_exp_year\": \"25\",\n      \"card_holder_name\": \"joseph Doe\",\n      \"card_cvc\":\"232\"\n    }\n    },\n    \"billing\": {\n        \"address\": {\n            \"line1\": \"1467\",\n            \"line2\": \"Harrison Street\",\n            \"line3\": \"Harrison Street\",\n            \"city\": \"San Fransico\",\n            \"state\": \"California\",\n            \"zip\": \"94122\",\n            \"country\": \"US\",\n            \"first_name\": \"PiX\"\n        }\n    },\n    \"shipping\": {\n        \"address\": {\n            \"line1\": \"1467\",\n            \"line2\": \"Harrison Street\",\n            \"line3\": \"Harrison Street\",\n            \"city\": \"San Fransico\",\n            \"state\": \"California\",\n            \"zip\": \"94122\",\n            \"country\": \"US\",\n            \"first_name\": \"PiX\"\n        }\n    },\n    \"statement_descriptor_name\": \"joseph\",\n    \"statement_descriptor_suffix\": \"JS\",\n    \"metadata\": {\n        \"udf1\": \"value1\",\n        \"new_customer\": \"true\",\n        \"login_date\": \"2019-09-10T10:11:12Z\"\n    }\n}\n\n",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments"
+											]
+										},
+										"description": "To process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Retrieve",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 2xx",
+													"pm.test(\"[GET]::/payments/:id - Status code is 2xx\", function () {",
+													"  pm.response.to.be.success;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(\"[GET]::/payments/:id - Content-Type is application/json\", function () {",
+													"  pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"    \"application/json\",",
+													"  );",
+													"});",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[GET]::/payments/:id - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have value \"requires_capture\" for \"status\"",
+													"if (jsonData?.status) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id - Content check if value for 'status' matches 'requires_capture'\",",
+													"    function () {",
+													"      pm.expect(jsonData.status).to.eql(\"requires_capture\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "GET",
+										"header": [
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id?force_sync=true",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id"
+											],
+											"query": [
+												{
+													"key": "force_sync",
+													"value": "true"
+												}
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+									},
+									"response": []
+								},
+								{
+									"name": "Payments - Capture",
+									"event": [
+										{
+											"listen": "test",
+											"script": {
+												"exec": [
+													"// Validate status 4xx",
+													"pm.test(\"[POST]::/payments/:id/capture - Status code is 4xx\", function () {",
+													"  pm.response.to.be.error;",
+													"});",
+													"",
+													"// Validate if response header has matching content-type",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/capture - Content-Type is application/json\",",
+													"  function () {",
+													"    pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(",
+													"      \"application/json\",",
+													"    );",
+													"  },",
+													");",
+													"",
+													"// Validate if response has JSON Body",
+													"pm.test(\"[POST]::/payments/:id/capture - Response has JSON Body\", function () {",
+													"  pm.response.to.have.jsonBody();",
+													"});",
+													"",
+													"// Set response object as internal variable",
+													"let jsonData = {};",
+													"try {",
+													"  jsonData = pm.response.json();",
+													"} catch (e) {}",
+													"",
+													"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+													"if (jsonData?.payment_id) {",
+													"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+													"  console.log(",
+													"    \"- use {{payment_id}} as collection variable for value\",",
+													"    jsonData.payment_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{payment_id}}, as jsonData.payment_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set mandate_id as variable for jsonData.mandate_id",
+													"if (jsonData?.mandate_id) {",
+													"  pm.collectionVariables.set(\"mandate_id\", jsonData.mandate_id);",
+													"  console.log(",
+													"    \"- use {{mandate_id}} as collection variable for value\",",
+													"    jsonData.mandate_id,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{mandate_id}}, as jsonData.mandate_id is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// pm.collectionVariables - Set client_secret as variable for jsonData.client_secret",
+													"if (jsonData?.client_secret) {",
+													"  pm.collectionVariables.set(\"client_secret\", jsonData.client_secret);",
+													"  console.log(",
+													"    \"- use {{client_secret}} as collection variable for value\",",
+													"    jsonData.client_secret,",
+													"  );",
+													"} else {",
+													"  console.log(",
+													"    \"INFO - Unable to assign variable {{client_secret}}, as jsonData.client_secret is undefined.\",",
+													"  );",
+													"}",
+													"",
+													"// Response body should have \"error\"",
+													"pm.test(",
+													"  \"[POST]::/payments/:id/confirm - Content check if 'error' exists\",",
+													"  function () {",
+													"    pm.expect(typeof jsonData.error !== \"undefined\").to.be.true;",
+													"  },",
+													");",
+													"",
+													"// Response body should have value \"connector error\" for \"error type\"",
+													"if (jsonData?.error?.type) {",
+													"  pm.test(",
+													"    \"[POST]::/payments/:id/confirm - Content check if value for 'error.type' matches 'invalid_request'\",",
+													"    function () {",
+													"      pm.expect(jsonData.error.type).to.eql(\"invalid_request\");",
+													"    },",
+													"  );",
+													"}",
+													""
+												],
+												"type": "text/javascript"
+											}
+										}
+									],
+									"request": {
+										"method": "POST",
+										"header": [
+											{
+												"key": "Content-Type",
+												"value": "application/json"
+											},
+											{
+												"key": "Accept",
+												"value": "application/json"
+											}
+										],
+										"body": {
+											"mode": "raw",
+											"raw": "{\"amount_to_capture\":7540,\"statement_descriptor_name\":\"Joseph\",\"statement_descriptor_suffix\":\"JS\"}",
+											"options": {
+												"raw": {
+													"language": "json"
+												}
+											}
+										},
+										"url": {
+											"raw": "{{baseUrl}}/payments/:id/capture",
+											"host": [
+												"{{baseUrl}}"
+											],
+											"path": [
+												"payments",
+												":id",
+												"capture"
+											],
+											"variable": [
+												{
+													"key": "id",
+													"value": "{{payment_id}}",
+													"description": "(Required) unique payment id"
+												}
+											]
+										},
+										"description": "To capture the funds for an uncaptured payment"
+									},
+									"response": []
+								}
+							]
+						}
+					]
+				},
+				{
+					"name": "Refunds",
+					"item": [
+						{
+							"name": "Refunds - Create",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx ",
+											"pm.test(\"[POST]::/refunds - Status code is 2xx\", function () {",
+											"   pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[POST]::/refunds - Content-Type is application/json\", function () {",
+											"   pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {jsonData = pm.response.json();}catch(e){}",
+											"",
+											"// pm.collectionVariables - Set refund_id as variable for jsonData.payment_id",
+											"if (jsonData?.refund_id) {",
+											"   pm.collectionVariables.set(\"refund_id\", jsonData.refund_id);",
+											"   console.log(\"- use {{refund_id}} as collection variable for value\",jsonData.refund_id);",
+											"} else {",
+											"   console.log('INFO - Unable to assign variable {{refund_id}}, as jsonData.refund_id is undefined.');",
+											"};",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n    \"payment_id\": \"{{payment_id}}\",\n    \"amount\": 600,\n    \"reason\": \"Customer returned product\",\n    \"refund_type\": \"instant\",\n    \"metadata\": {\n        \"udf1\": \"value1\",\n        \"new_customer\": \"true\",\n        \"login_date\": \"2019-09-10T10:11:12Z\"\n    }\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/refunds",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"refunds"
+									]
+								},
+								"description": "To create a refund against an already processed payment"
+							},
+							"response": []
+						},
+						{
+							"name": "Refunds - Update",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx ",
+											"pm.test(\"[POST]::/refunds/:id - Status code is 2xx\", function () {",
+											"   pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[POST]::/refunds/:id - Content-Type is application/json\", function () {",
+											"   pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");",
+											"});",
+											"",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {jsonData = pm.response.json();}catch(e){}",
+											"",
+											"// pm.collectionVariables - Set refund_id as variable for jsonData.payment_id",
+											"if (jsonData?.refund_id) {",
+											"   pm.collectionVariables.set(\"refund_id\", jsonData.refund_id);",
+											"   console.log(\"- use {{refund_id}} as collection variable for value\",jsonData.refund_id);",
+											"} else {",
+											"   console.log('INFO - Unable to assign variable {{refund_id}}, as jsonData.refund_id is undefined.');",
+											"};"
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"value": "application/json"
+									},
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n    \"reason\": \"Paid by mistake\",\n    \"metadata\": {\n        \"udf1\": \"value2\",\n        \"new_customer\": \"false\",\n        \"login_date\": \"2019-09-1T10:11:12Z\"\n    }\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseUrl}}/refunds/:id",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"refunds",
+										":id"
+									],
+									"variable": [
+										{
+											"key": "id",
+											"value": "{{refund_id}}",
+											"description": "(Required) unique refund id"
+										}
+									]
+								},
+								"description": "To update the properties of a Refund object. This may include attaching a reason for the refund or metadata fields"
+							},
+							"response": []
+						},
+						{
+							"name": "Refunds - Retrieve",
+							"event": [
+								{
+									"listen": "test",
+									"script": {
+										"exec": [
+											"// Validate status 2xx ",
+											"pm.test(\"[GET]::/refunds/:id - Status code is 2xx\", function () {",
+											"   pm.response.to.be.success;",
+											"});",
+											"",
+											"// Validate if response header has matching content-type",
+											"pm.test(\"[GET]::/refunds/:id - Content-Type is application/json\", function () {",
+											"   pm.expect(pm.response.headers.get(\"Content-Type\")).to.include(\"application/json\");",
+											"});",
+											"",
+											"// Set response object as internal variable",
+											"let jsonData = {};",
+											"try {jsonData = pm.response.json();}catch(e){}",
+											"",
+											"// pm.collectionVariables - Set refund_id as variable for jsonData.payment_id",
+											"if (jsonData?.refund_id) {",
+											"   pm.collectionVariables.set(\"refund_id\", jsonData.refund_id);",
+											"   console.log(\"- use {{refund_id}} as collection variable for value\",jsonData.refund_id);",
+											"} else {",
+											"   console.log('INFO - Unable to assign variable {{refund_id}}, as jsonData.refund_id is undefined.');",
+											"};",
+											""
+										],
+										"type": "text/javascript"
+									}
+								}
+							],
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Accept",
+										"value": "application/json"
+									}
+								],
+								"url": {
+									"raw": "{{baseUrl}}/refunds/:id",
+									"host": [
+										"{{baseUrl}}"
+									],
+									"path": [
+										"refunds",
+										":id"
+									],
+									"variable": [
+										{
+											"key": "id",
+											"value": "{{refund_id}}",
+											"description": "(Required) unique refund id"
+										}
+									]
+								},
+								"description": "To retrieve the properties of a Refund. This may be used to get the status of a previously initiated payment or next action for an ongoing payment"
+							},
+							"response": []
+						}
+					]
+				}
+			]
+		}
+	],
+	"auth": {
+		"type": "apikey",
+		"apikey": [
+			{
+				"key": "value",
+				"value": "{{api_key}}",
+				"type": "string"
+			},
+			{
+				"key": "key",
+				"value": "api-key",
+				"type": "string"
+			},
+			{
+				"key": "in",
+				"value": "header",
+				"type": "string"
+			}
+		]
+	},
+	"event": [
+		{
+			"listen": "prerequest",
+			"script": {
+				"type": "text/javascript",
+				"exec": [
+					""
+				]
+			}
+		},
+		{
+			"listen": "test",
+			"script": {
+				"type": "text/javascript",
+				"exec": [
+					"// Set response object as internal variable",
+					"let jsonData = {};",
+					"try {",
+					"  jsonData = pm.response.json();",
+					"} catch (e) {}",
+					"",
+					"// pm.collectionVariables - Set payment_id as variable for jsonData.payment_id",
+					"if (jsonData?.payment_id) {",
+					"  pm.collectionVariables.set(\"payment_id\", jsonData.payment_id);",
+					"  console.log(\"[LOG]::payment_id - \" + jsonData.payment_id);",
+					"}",
+					"",
+					"console.log(\"[LOG]::x-request-id - \" + pm.response.headers.get(\"x-request-id\"));",
+					""
+				]
+			}
+		}
+	],
+	"variable": [
+		{
+			"key": "baseUrl",
+			"value": "http://localhost:8080",
+			"type": "string"
+		},
+		{
+			"key": "admin_api_key",
+			"value": "test_admin",
+			"type": "string"
+		},
+		{
+			"key": "api_key",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "merchant_id",
+			"value": ""
+		},
+		{
+			"key": "payment_id",
+			"value": ""
+		},
+		{
+			"key": "customer_id",
+			"value": ""
+		},
+		{
+			"key": "mandate_id",
+			"value": ""
+		},
+		{
+			"key": "payment_method_id",
+			"value": ""
+		},
+		{
+			"key": "refund_id",
+			"value": ""
+		},
+		{
+			"key": "merchant_connector_id",
+			"value": ""
+		},
+		{
+			"key": "client_secret",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "publishable_key",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "api_key_id",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "payment_token",
+			"value": ""
+		},
+		{
+			"key": "gateway_merchant_id",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "certificate",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "certificate_keys",
+			"value": "",
+			"type": "string"
+		},
+		{
+			"key": "merchantId",
+			"value": "1110017152",
+			"type": "string"
+		},
+		{
+			"key": "passcode",
+			"value": "CJVCttkfcmB0DZJP",
+			"type": "string"
+		}
+	]
+}
\ No newline at end of file