Issue:
Bug: Rename `PaymentsRequestSyncData` struct to `PaymentsSyncData`.



Rename the struct `PaymentsRequestSyncData` to `PaymentsSyncData`.
Use this pattern `<Feature>Data`.

And rename PaymentsRouterSyncData struct to PaymentsSyncRouterData.
Pattern - `<Feature>RouterData`

And rename the field name called `request` to `data` in `RouterData` struct.

_Originally posted by @jarnura in https://github.com/juspay/orca/pull/7#discussion_r1032366000_
      

Pull request description:
## Type of Change

- [x] Refactoring

## Description
Rename the payment request router data with respective feature data, as suggesed [here](https://github.com/juspay/orca/pull/7#discussion_r1032366000)


### Additional Changes
N.A

## Motivation and Context
This PR closes #21 


## How did you test it?


## Checklist

- [x] I formatted the code `cargo +nightly fmt`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed submitted code
- [ ] I added unit tests for my changes where possible
- [ ] I added a [CHANGELOG](/CHANGELOG.md) entry if applicable


Testing:

Patch:
diff --git a/connector-template/mod.rs b/connector-template/mod.rs
index 5651a6b04c3..c7f3a22094b 100644
--- a/connector-template/mod.rs
+++ b/connector-template/mod.rs
@@ -69,7 +69,7 @@ impl
         types::PaymentsRequestData,
         types::PaymentsResponseData,
     > for {{project-name | downcase | pascal_case}} {
-    fn get_headers(&self, _req: &types::PaymentsRouterData) -> CustomResult<Vec<(String, String)>,errors::ConnectorError> {
+    fn get_headers(&self, _req: &types::PaymentsAuthorizeRouterData) -> CustomResult<Vec<(String, String)>,errors::ConnectorError> {
         todo!()
     }
 
@@ -77,11 +77,11 @@ impl
         todo!()
     }
 
-    fn get_url(&self, _req: &types::PaymentsRouterData) -> CustomResult<String,errors::ConnectorError> {
+    fn get_url(&self, _req: &types::PaymentsAuthorizeRouterData) -> CustomResult<String,errors::ConnectorError> {
         todo!()
     }
 
-    fn get_request_body(&self, req: &types::PaymentsRouterData) -> CustomResult<Option<String>,errors::ConnectorError> {
+    fn get_request_body(&self, req: &types::PaymentsAuthorizeRouterData) -> CustomResult<Option<String>,errors::ConnectorError> {
         let {{project-name | downcase}}_req =
             utils::Encode::<{{project-name | downcase}}::{{project-name | downcase | pascal_case}}PaymentsRequest>::convert_and_url_encode(req).change_context(errors::ConnectorError::RequestEncodingFailed)?;
         Ok(Some({{project-name | downcase}}_req))
@@ -89,9 +89,9 @@ impl
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData,errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData,errors::ConnectorError> {
         let response: {{project-name | downcase}}::{{project-name | downcase | pascal_case}}PaymentsResponse = res.response.parse_struct("PaymentIntentResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         logger::debug!({{project-name | downcase}}payments_create_response=?response);
         types::ResponseRouterData {
@@ -152,7 +152,7 @@ impl
     }
 
     fn handle_response(
-        &self, 
+        &self,
         data: &types::RefundsRouterData,
         res: Response,
     ) -> CustomResult<types::RefundsRouterData,errors::ConnectorError> {
@@ -189,7 +189,7 @@ impl
 
     fn get_url(&self, _req: &types::RefundsRouterData) -> CustomResult<String,errors::ConnectorError> {
         todo!()
-    } 
+    }
 
     fn handle_response(
         &self,
@@ -197,7 +197,7 @@ impl
         res: Response,
     ) -> CustomResult<types::RefundsRouterData,errors::ConnectorError> {
         logger::debug!(target: "router::connector::{{project-name | downcase}}", response=?res);
-        let response: {{project-name | downcase}}::{{project-name | downcase | pascal_case}}RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?; 
+        let response: {{project-name | downcase}}::{{project-name | downcase | pascal_case}}RefundResponse = res.response.parse_struct("{{project-name | downcase}} RefundResponse").change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         types::ResponseRouterData {
             response,
             data: data.clone(),
diff --git a/connector-template/transformers.rs b/connector-template/transformers.rs
index 0af21e5818f..32affb14c60 100644
--- a/connector-template/transformers.rs
+++ b/connector-template/transformers.rs
@@ -5,9 +5,9 @@ use crate::{core::errors,types::{self,storage::enums}};
 #[derive(Default, Debug, Serialize, PartialEq)]
 pub struct {{project-name | downcase | pascal_case}}PaymentsRequest {}
 
-impl TryFrom<&types::PaymentsRouterData> for {{project-name | downcase | pascal_case}}PaymentsRequest  {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for {{project-name | downcase | pascal_case}}PaymentsRequest  {
     type Error = error_stack::Report<errors::ValidateError>;
-    fn try_from(_item: &types::PaymentsRouterData) -> Result<Self,Self::Error> {
+    fn try_from(_item: &types::PaymentsAuthorizeRouterData) -> Result<Self,Self::Error> {
         todo!()
     }
 }
@@ -39,7 +39,7 @@ impl Default for {{project-name | downcase | pascal_case}}PaymentStatus {
     }
 }
 
-impl From<{{project-name | downcase | pascal_case}}PaymentStatus> for enums::AttemptStatus { 
+impl From<{{project-name | downcase | pascal_case}}PaymentStatus> for enums::AttemptStatus {
     fn from(item: {{project-name | downcase | pascal_case}}PaymentStatus) -> Self {
         match item {
             {{project-name | downcase | pascal_case}}PaymentStatus::Succeeded => enums::AttemptStatus::Charged,
@@ -53,7 +53,7 @@ impl From<{{project-name | downcase | pascal_case}}PaymentStatus> for enums::Att
 #[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct {{project-name | downcase | pascal_case}}PaymentsResponse {}
 
-impl TryFrom<types::PaymentsResponseRouterData<{{project-name | downcase | pascal_case}}PaymentsResponse>> for types::PaymentsRouterData {
+impl TryFrom<types::PaymentsResponseRouterData<{{project-name | downcase | pascal_case}}PaymentsResponse>> for types::PaymentsAuthorizeRouterData {
     type Error = error_stack::Report<errors::ParsingError>;
     fn try_from(_item: types::PaymentsResponseRouterData<{{project-name | downcase | pascal_case}}PaymentsResponse>) -> Result<Self,Self::Error> {
         todo!()
diff --git a/crates/router/src/compatibility/stripe/payment_intents.rs b/crates/router/src/compatibility/stripe/payment_intents.rs
index 96a31574bfe..c7ba7dac323 100644
--- a/crates/router/src/compatibility/stripe/payment_intents.rs
+++ b/crates/router/src/compatibility/stripe/payment_intents.rs
@@ -10,7 +10,7 @@ use crate::{
     routes::AppState,
     services::api,
     types::api::{
-        self as api_types, payments::PaymentsCaptureRequest, Authorize, PCapture, PSync,
+        self as api_types, payments::PaymentsCaptureRequest, Authorize, Capture, PSync,
         PaymentListConstraints, PaymentsCancelRequest, PaymentsRequest, PaymentsRetrieveRequest,
         Void,
     },
@@ -251,7 +251,7 @@ pub async fn payment_intents_capture(
         &req,
         capture_payload,
         |state, merchant_account, payload| {
-            payments::payments_core::<PCapture, _, _, _>(
+            payments::payments_core::<Capture, _, _, _>(
                 state,
                 merchant_account,
                 payments::PaymentCapture,
diff --git a/crates/router/src/connector/aci.rs b/crates/router/src/connector/aci.rs
index 34d5b16aa2b..899024f35e4 100644
--- a/crates/router/src/connector/aci.rs
+++ b/crates/router/src/connector/aci.rs
@@ -56,39 +56,26 @@ impl api::PaymentCapture for Aci {}
 
 impl
     services::ConnectorIntegration<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
+        api::Capture,
+        types::PaymentsCaptureData,
         types::PaymentsResponseData,
     > for Aci
 {
     // Not Implemented (R)
 }
 
-type PSync = dyn services::ConnectorIntegration<
-    api::PSync,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
-
 impl
-    services::ConnectorIntegration<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for Aci
+    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Aci
 {
     fn get_headers(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                PSync::get_content_type(self).to_string(),
+                types::PaymentsSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -103,11 +90,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let auth = aci::AciAuthType::try_from(&req.connector_auth_type)?;
@@ -123,34 +106,26 @@ impl
 
     fn build_request(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Get)
-                .url(&PSync::get_url(self, req, connectors)?)
-                .headers(PSync::get_headers(self, req)?)
-                .body(PSync::get_request_body(self, req)?)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsSyncType::get_headers(self, req)?)
+                .body(types::PaymentsSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        data: &types::PaymentsSyncRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterSyncData, errors::ConnectorError>
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError>
     where
-        types::PaymentsRequestData: Clone,
+        types::PaymentsSyncData: Clone,
         types::PaymentsResponseData: Clone,
     {
         let response: aci::AciPaymentsResponse =
@@ -187,27 +162,21 @@ impl
     }
 }
 
-type Authorize = dyn services::ConnectorIntegration<
-    api::Authorize,
-    types::PaymentsRequestData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for Aci
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -222,7 +191,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!("{}{}", self.base_url(connectors), "v1/payments"))
@@ -230,7 +199,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         // encode only for for urlencoded things.
         let aci_req = utils::Encode::<aci::AciPaymentsRequest>::convert_and_url_encode(req)
@@ -243,7 +212,7 @@ impl
         &self,
         req: &types::RouterData<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
         connectors: Connectors,
@@ -251,20 +220,21 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Authorize::get_url(self, req, connectors)?)
-                .headers(Authorize::get_headers(self, req)?)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Authorize::get_request_body(self, req)?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
         let response: aci::AciPaymentsResponse =
             res.response
                 .parse_struct("AciPaymentsResponse")
@@ -299,27 +269,21 @@ impl
     }
 }
 
-type Void = dyn services::ConnectorIntegration<
-    api::Void,
-    types::PaymentRequestCancelData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Void,
-        types::PaymentRequestCancelData,
+        types::PaymentsCancelData,
         types::PaymentsResponseData,
     > for Aci
 {
     fn get_headers(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -334,7 +298,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let id = &req.request.connector_transaction_id;
@@ -343,7 +307,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let aci_req = utils::Encode::<aci::AciCancelRequest>::convert_and_url_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -351,25 +315,25 @@ impl
     }
     fn build_request(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
                 // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Void::get_url(self, req, connectors)?)
-                .headers(Void::get_headers(self, req)?)
-                .body(Void::get_request_body(self, req)?)
+                .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsVoidType::get_headers(self, req)?)
+                .body(types::PaymentsVoidType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentRouterCancelData,
+        data: &types::PaymentsCancelRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentRouterCancelData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
         let response: aci::AciPaymentsResponse =
             res.response
                 .parse_struct("AciPaymentsResponse")
@@ -408,17 +372,8 @@ impl api::Refund for Aci {}
 impl api::RefundExecute for Aci {}
 impl api::RefundSync for Aci {}
 
-type Execute = dyn services::ConnectorIntegration<
-    api::Execute,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::Execute,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Aci
+impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Aci
 {
     fn get_headers(
         &self,
@@ -427,7 +382,7 @@ impl
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Execute::get_content_type(self).to_string(),
+                types::RefundExecuteType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -470,9 +425,9 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                .url(&Execute::get_url(self, req, connectors)?)
-                .headers(Execute::get_headers(self, req)?)
-                .body(Execute::get_request_body(self, req)?)
+                .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+                .headers(types::RefundExecuteType::get_headers(self, req)?)
+                .body(types::RefundExecuteType::get_request_body(self, req)?)
                 .build(),
         ))
     }
@@ -517,12 +472,8 @@ impl
     }
 }
 
-impl
-    services::ConnectorIntegration<
-        api::RSync,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Aci
+impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
+    for Aci
 {
 }
 
diff --git a/crates/router/src/connector/aci/transformers.rs b/crates/router/src/connector/aci/transformers.rs
index a6f2ca30fb8..2344e9a6892 100644
--- a/crates/router/src/connector/aci/transformers.rs
+++ b/crates/router/src/connector/aci/transformers.rs
@@ -97,9 +97,9 @@ pub enum AciPaymentType {
     Refund,
 }
 
-impl TryFrom<&types::PaymentsRouterData> for AciPaymentsRequest {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for AciPaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsRouterData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let payment_details: PaymentDetails = match item.request.payment_method_data {
             api::PaymentMethod::Card(ref ccard) => PaymentDetails::Card(CardDetails {
                 card_number: ccard.card_number.peek().clone(),
@@ -128,9 +128,9 @@ impl TryFrom<&types::PaymentsRouterData> for AciPaymentsRequest {
     }
 }
 
-impl TryFrom<&types::PaymentRouterCancelData> for AciCancelRequest {
+impl TryFrom<&types::PaymentsCancelRouterData> for AciCancelRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentRouterCancelData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
         let auth = AciAuthType::try_from(&item.connector_auth_type)?;
         let aci_payment_request = AciCancelRequest {
             entity_id: auth.entity_id,
diff --git a/crates/router/src/connector/adyen.rs b/crates/router/src/connector/adyen.rs
index b4c3c6f28bc..cce42e2507a 100644
--- a/crates/router/src/connector/adyen.rs
+++ b/crates/router/src/connector/adyen.rs
@@ -54,46 +54,28 @@ impl api::PaymentSync for Adyen {}
 impl api::PaymentVoid for Adyen {}
 impl api::PaymentCapture for Adyen {}
 
-#[allow(dead_code)]
-type PCapture = dyn services::ConnectorIntegration<
-    api::PCapture,
-    types::PaymentsRequestCaptureData,
-    types::PaymentsResponseData,
->;
 impl
     services::ConnectorIntegration<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
+        api::Capture,
+        types::PaymentsCaptureData,
         types::PaymentsResponseData,
     > for Adyen
 {
     // Not Implemented (R)
 }
 
-type PSync = dyn services::ConnectorIntegration<
-    api::PSync,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
 impl
-    services::ConnectorIntegration<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for Adyen
+    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Adyen
 {
     fn get_headers(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                PSync::get_content_type(self).to_string(),
+                types::PaymentsSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -104,11 +86,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let encoded_data = req
             .request
@@ -154,11 +132,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        _req: &types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
@@ -170,33 +144,25 @@ impl
 
     fn build_request(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                .url(&PSync::get_url(self, req, connectors)?)
-                .headers(PSync::get_headers(self, req)?)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsSyncType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(PSync::get_request_body(self, req)?)
+                .body(types::PaymentsSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        data: &types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterSyncData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
         logger::debug!(payment_sync_response=?res);
         let response: adyen::AdyenPaymentResponse = res
             .response
@@ -226,33 +192,28 @@ impl
     }
 }
 
-type Authorize = dyn services::ConnectorIntegration<
-    api::Authorize,
-    types::PaymentsRequestData,
-    types::PaymentsResponseData,
->;
 impl
     services::ConnectorIntegration<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for Adyen
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError>
     where
         Self: services::ConnectorIntegration<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
     {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -263,7 +224,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!("{}{}", self.base_url(connectors), "v68/payments"))
@@ -271,7 +232,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let adyen_req = utils::Encode::<adyen::AdyenPaymentRequest>::convert_and_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -282,7 +243,7 @@ impl
         &self,
         req: &types::RouterData<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
         connectors: Connectors,
@@ -290,20 +251,21 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Authorize::get_url(self, req, connectors)?)
-                .headers(Authorize::get_headers(self, req)?)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Authorize::get_request_body(self, req)?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
         let response: adyen::AdyenPaymentResponse = res
             .response
             .parse_struct("AdyenPaymentResponse")
@@ -332,27 +294,21 @@ impl
     }
 }
 
-type Void = dyn services::ConnectorIntegration<
-    api::Void,
-    types::PaymentRequestCancelData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Void,
-        types::PaymentRequestCancelData,
+        types::PaymentsCancelData,
         types::PaymentsResponseData,
     > for Adyen
 {
     fn get_headers(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -363,7 +319,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!("{}{}", self.base_url(connectors), "v68/cancel"))
@@ -371,7 +327,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let adyen_req = utils::Encode::<adyen::AdyenCancelRequest>::convert_and_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -379,26 +335,26 @@ impl
     }
     fn build_request(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
                 // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Void::get_url(self, req, connectors)?)
-                .headers(Void::get_headers(self, req)?)
+                .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsVoidType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Void::get_request_body(self, req)?)
+                .body(types::PaymentsVoidType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentRouterCancelData,
+        data: &types::PaymentsCancelRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentRouterCancelData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
         let response: adyen::AdyenCancelResponse = res
             .response
             .parse_struct("AdyenCancelResponse")
@@ -431,17 +387,8 @@ impl api::Refund for Adyen {}
 impl api::RefundExecute for Adyen {}
 impl api::RefundSync for Adyen {}
 
-type Execute = dyn services::ConnectorIntegration<
-    api::Execute,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::Execute,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Adyen
+impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Adyen
 {
     fn get_headers(
         &self,
@@ -450,7 +397,7 @@ impl
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Execute::get_content_type(self).to_string(),
+                types::RefundExecuteType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -489,9 +436,9 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                .url(&Execute::get_url(self, req, connectors)?)
-                .headers(Execute::get_headers(self, req)?)
-                .body(Execute::get_request_body(self, req)?)
+                .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+                .headers(types::RefundExecuteType::get_headers(self, req)?)
+                .body(types::RefundExecuteType::get_request_body(self, req)?)
                 .build(),
         ))
     }
@@ -531,12 +478,8 @@ impl
     }
 }
 
-impl
-    services::ConnectorIntegration<
-        api::RSync,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Adyen
+impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
+    for Adyen
 {
 }
 
diff --git a/crates/router/src/connector/adyen/transformers.rs b/crates/router/src/connector/adyen/transformers.rs
index d82bb755b01..f620a50316f 100644
--- a/crates/router/src/connector/adyen/transformers.rs
+++ b/crates/router/src/connector/adyen/transformers.rs
@@ -239,9 +239,9 @@ impl TryFrom<&types::BrowserInformation> for AdyenBrowserInfo {
 }
 
 // Payment Request Transform
-impl TryFrom<&types::PaymentsRouterData> for AdyenPaymentRequest {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for AdyenPaymentRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsRouterData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
         let reference = item.payment_id.to_string();
         let amount = Amount {
@@ -354,9 +354,9 @@ impl TryFrom<&types::PaymentsRouterData> for AdyenPaymentRequest {
     }
 }
 
-impl TryFrom<&types::PaymentRouterCancelData> for AdyenCancelRequest {
+impl TryFrom<&types::PaymentsCancelRouterData> for AdyenCancelRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentRouterCancelData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
         let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
         Ok(AdyenCancelRequest {
             merchant_account: auth_type.merchant_account,
@@ -367,7 +367,7 @@ impl TryFrom<&types::PaymentRouterCancelData> for AdyenCancelRequest {
 }
 
 impl TryFrom<types::PaymentsCancelResponseRouterData<AdyenCancelResponse>>
-    for types::PaymentRouterCancelData
+    for types::PaymentsCancelRouterData
 {
     type Error = error_stack::Report<errors::ParsingError>;
     fn try_from(
diff --git a/crates/router/src/connector/authorizedotnet.rs b/crates/router/src/connector/authorizedotnet.rs
index b66111b407e..8276446bd3b 100644
--- a/crates/router/src/connector/authorizedotnet.rs
+++ b/crates/router/src/connector/authorizedotnet.rs
@@ -44,43 +44,29 @@ impl api::PaymentSync for Authorizedotnet {}
 impl api::PaymentVoid for Authorizedotnet {}
 impl api::PaymentCapture for Authorizedotnet {}
 
-#[allow(dead_code)]
-type PCapture = dyn services::ConnectorIntegration<
-    api::PCapture,
-    types::PaymentsRequestCaptureData,
-    types::PaymentsResponseData,
->;
 impl
     services::ConnectorIntegration<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
+        api::Capture,
+        types::PaymentsCaptureData,
         types::PaymentsResponseData,
     > for Authorizedotnet
 {
     // Not Implemented (R)
 }
 
-type PSync = dyn services::ConnectorIntegration<
-    api::PSync,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
 impl
-    services::ConnectorIntegration<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for Authorizedotnet
+    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Authorizedotnet
 {
     fn get_headers(
         &self,
-        _req: &types::PaymentsRouterSyncData,
+        _req: &types::PaymentsSyncRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         // This connector does not require an auth header, the authentication details are sent in the request body
         Ok(vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                PSync::get_content_type(self).to_string(),
+                types::PaymentsSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ])
@@ -92,7 +78,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterSyncData,
+        _req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(self.base_url(connectors))
@@ -100,7 +86,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterSyncData,
+        req: &types::PaymentsSyncRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let sync_request =
             utils::Encode::<authorizedotnet::AuthorizedotnetCreateSyncRequest>::convert_and_encode(
@@ -112,23 +98,23 @@ impl
 
     fn build_request(
         &self,
-        req: &types::PaymentsRouterSyncData,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&PSync::get_url(self, req, connectors)?)
-            .headers(PSync::get_headers(self, req)?)
-            .body(PSync::get_request_body(self, req)?)
+            .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+            .headers(types::PaymentsSyncType::get_headers(self, req)?)
+            .body(types::PaymentsSyncType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterSyncData,
+        data: &types::PaymentsSyncRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterSyncData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
         use bytes::Buf;
 
         // Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
@@ -177,28 +163,22 @@ impl
     }
 }
 
-type Authorize = dyn services::ConnectorIntegration<
-    api::Authorize,
-    types::PaymentsRequestData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for Authorizedotnet
 {
     fn get_headers(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         // This connector does not require an auth header, the authentication details are sent in the request body
         Ok(vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ])
@@ -210,7 +190,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(self.base_url(connectors))
@@ -218,7 +198,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         logger::debug!(request=?req);
         let authorizedotnet_req =
@@ -231,7 +211,7 @@ impl
         &self,
         req: &types::RouterData<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
         connectors: Connectors,
@@ -239,20 +219,21 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Authorize::get_url(self, req, connectors)?)
-                .headers(Authorize::get_headers(self, req)?)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Authorize::get_request_body(self, req)?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
         use bytes::Buf;
 
         // Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
@@ -302,27 +283,21 @@ impl
     }
 }
 
-type Void = dyn services::ConnectorIntegration<
-    api::Void,
-    types::PaymentRequestCancelData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Void,
-        types::PaymentRequestCancelData,
+        types::PaymentsCancelData,
         types::PaymentsResponseData,
     > for Authorizedotnet
 {
     fn get_headers(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         Ok(vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ])
@@ -334,7 +309,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(self.base_url(connectors))
@@ -342,7 +317,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let authorizedotnet_req =
             utils::Encode::<authorizedotnet::CancelTransactionRequest>::convert_and_encode(req)
@@ -351,26 +326,25 @@ impl
     }
     fn build_request(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Void::get_url(self, req, connectors)?)
-                .headers(Void::get_headers(self, req)?)
+                .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsVoidType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Void::get_request_body(self, req)?)
+                .body(types::PaymentsVoidType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentRouterCancelData,
+        data: &types::PaymentsCancelRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentRouterCancelData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
         use bytes::Buf;
 
         // Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
@@ -424,18 +398,8 @@ impl api::Refund for Authorizedotnet {}
 impl api::RefundExecute for Authorizedotnet {}
 impl api::RefundSync for Authorizedotnet {}
 
-type Execute = dyn services::ConnectorIntegration<
-    api::Execute,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-
-impl
-    services::ConnectorIntegration<
-        api::Execute,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Authorizedotnet
+impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Authorizedotnet
 {
     fn get_headers(
         &self,
@@ -445,7 +409,7 @@ impl
         Ok(vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ])
@@ -481,9 +445,9 @@ impl
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&Execute::get_url(self, req, connectors)?)
-            .headers(Execute::get_headers(self, req)?)
-            .body(Execute::get_request_body(self, req)?)
+            .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+            .headers(types::RefundExecuteType::get_headers(self, req)?)
+            .body(types::RefundExecuteType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
@@ -544,18 +508,8 @@ impl
     }
 }
 
-type RSync = dyn services::ConnectorIntegration<
-    api::RSync,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-
-impl
-    services::ConnectorIntegration<
-        api::RSync,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Authorizedotnet
+impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
+    for Authorizedotnet
 {
     fn get_headers(
         &self,
@@ -565,7 +519,7 @@ impl
         Ok(vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                RSync::get_content_type(self).to_string(),
+                types::RefundSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ])
@@ -602,9 +556,9 @@ impl
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&RSync::get_url(self, req, connectors)?)
-            .headers(RSync::get_headers(self, req)?)
-            .body(RSync::get_request_body(self, req)?)
+            .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+            .headers(types::RefundSyncType::get_headers(self, req)?)
+            .body(types::RefundSyncType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
diff --git a/crates/router/src/connector/authorizedotnet/transformers.rs b/crates/router/src/connector/authorizedotnet/transformers.rs
index 2dc4cb4ad70..34372342fa7 100644
--- a/crates/router/src/connector/authorizedotnet/transformers.rs
+++ b/crates/router/src/connector/authorizedotnet/transformers.rs
@@ -128,9 +128,9 @@ impl From<enums::CaptureMethod> for AuthorizationType {
     }
 }
 
-impl TryFrom<&types::PaymentsRouterData> for CreateTransactionRequest {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for CreateTransactionRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsRouterData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let payment_details = match item.request.payment_method_data {
             api::PaymentMethod::Card(ref ccard) => {
                 let expiry_month = ccard.card_exp_month.peek().clone();
@@ -172,9 +172,9 @@ impl TryFrom<&types::PaymentsRouterData> for CreateTransactionRequest {
     }
 }
 
-impl TryFrom<&types::PaymentRouterCancelData> for CancelTransactionRequest {
+impl TryFrom<&types::PaymentsCancelRouterData> for CancelTransactionRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentRouterCancelData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
         let transaction_request = TransactionVoidRequest {
             transaction_type: TransactionType::Void,
             ref_trans_id: item.request.connector_transaction_id.to_string(),
@@ -461,10 +461,10 @@ impl<F> TryFrom<&types::RefundsRouterData<F>> for AuthorizedotnetCreateSyncReque
     }
 }
 
-impl TryFrom<&types::PaymentsRouterSyncData> for AuthorizedotnetCreateSyncRequest {
+impl TryFrom<&types::PaymentsSyncRouterData> for AuthorizedotnetCreateSyncRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
 
-    fn try_from(item: &types::PaymentsRouterSyncData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
         let transaction_id = item
             .response
             .as_ref()
diff --git a/crates/router/src/connector/checkout.rs b/crates/router/src/connector/checkout.rs
index 1a217797156..23e9442e92e 100644
--- a/crates/router/src/connector/checkout.rs
+++ b/crates/router/src/connector/checkout.rs
@@ -58,44 +58,27 @@ impl api::PaymentSync for Checkout {}
 impl api::PaymentVoid for Checkout {}
 impl api::PaymentCapture for Checkout {}
 
-#[allow(dead_code)]
-type PCapture = dyn services::ConnectorIntegration<
-    api::PCapture,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
+        api::Capture,
+        types::PaymentsCaptureData,
         types::PaymentsResponseData,
     > for Checkout
 {
 }
 
-#[allow(dead_code)]
-type PSync = dyn services::ConnectorIntegration<
-    api::PSync,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
-
 impl
-    services::ConnectorIntegration<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for Checkout
+    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Checkout
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterSyncData,
+        req: &types::PaymentsSyncRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -106,7 +89,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::PaymentsRouterSyncData,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
@@ -119,28 +102,28 @@ impl
 
     fn build_request(
         &self,
-        req: &types::PaymentsRouterSyncData,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Get)
-                .url(&PSync::get_url(self, req, connectors)?)
-                .headers(PSync::get_headers(self, req)?)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsSyncType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(PSync::get_request_body(self, req)?)
+                .body(types::PaymentsSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterSyncData,
+        data: &types::PaymentsSyncRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterSyncData, errors::ConnectorError>
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError>
     where
         api::PSync: Clone,
-        types::PaymentsRequestSyncData: Clone,
+        types::PaymentsSyncData: Clone,
         types::PaymentsResponseData: Clone,
     {
         logger::debug!(raw_response=?res);
@@ -177,27 +160,21 @@ impl
     }
 }
 
-type Authorize = dyn services::ConnectorIntegration<
-    api::Authorize,
-    types::PaymentsRequestData,
-    types::PaymentsResponseData,
->; // why is this named Authorize
-
 impl
     services::ConnectorIntegration<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for Checkout
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -208,7 +185,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!("{}{}", self.base_url(connectors), "payments"))
@@ -216,7 +193,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let checkout_req = utils::Encode::<checkout::PaymentsRequest>::convert_and_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -226,7 +203,7 @@ impl
         &self,
         req: &types::RouterData<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
         connectors: Connectors,
@@ -234,20 +211,21 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Authorize::get_url(self, req, connectors)?)
-                .headers(Authorize::get_headers(self, req)?)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Authorize::get_request_body(self, req)?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
         //TODO: [ORCA-618] If 3ds fails, the response should be a redirect response, to redirect client to success/failed page
         let response: checkout::PaymentsResponse = res
             .response
@@ -284,22 +262,16 @@ impl
     }
 }
 
-type Void = dyn services::ConnectorIntegration<
-    api::Void,
-    types::PaymentRequestCancelData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Void,
-        types::PaymentRequestCancelData,
+        types::PaymentsCancelData,
         types::PaymentsResponseData,
     > for Checkout
 {
     fn get_headers(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         Err(errors::ConnectorError::NotImplemented("checkout".to_string()).into())
     }
@@ -310,7 +282,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
         _connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Err(errors::ConnectorError::NotImplemented("checkout".to_string()).into())
@@ -318,13 +290,13 @@ impl
 
     fn get_request_body(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         Err(errors::ConnectorError::NotImplemented("checkout".to_string()).into())
     }
     fn build_request(
         &self,
-        _req: &types::PaymentRouterCancelData,
+        _req: &types::PaymentsCancelRouterData,
         _connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Err(errors::ConnectorError::NotImplemented("checkout".to_string()).into())
@@ -332,9 +304,9 @@ impl
 
     fn handle_response(
         &self,
-        _data: &types::PaymentRouterCancelData,
+        _data: &types::PaymentsCancelRouterData,
         _res: Response,
-    ) -> CustomResult<types::PaymentRouterCancelData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
         Err(errors::ConnectorError::NotImplemented("checkout".to_string()).into())
     }
 
@@ -350,17 +322,8 @@ impl api::Refund for Checkout {}
 impl api::RefundExecute for Checkout {}
 impl api::RefundSync for Checkout {}
 
-type Execute = dyn services::ConnectorIntegration<
-    api::Execute,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::Execute,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Checkout
+impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Checkout
 {
     fn get_headers(
         &self,
@@ -369,7 +332,7 @@ impl
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Execute::get_content_type(self).to_string(),
+                types::RefundExecuteType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -411,9 +374,9 @@ impl
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&Execute::get_url(self, req, connectors)?)
-            .headers(Execute::get_headers(self, req)?)
-            .body(Execute::get_request_body(self, req)?)
+            .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+            .headers(types::RefundExecuteType::get_headers(self, req)?)
+            .body(types::RefundExecuteType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
@@ -463,17 +426,8 @@ impl
     }
 }
 
-type RSync = dyn services::ConnectorIntegration<
-    api::RSync,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::RSync,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Checkout
+impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
+    for Checkout
 {
     fn get_headers(
         &self,
@@ -482,7 +436,7 @@ impl
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                RSync::get_content_type(self).to_string(),
+                types::RefundSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -512,9 +466,9 @@ impl
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Get)
-                .url(&RSync::get_url(self, req, connectors)?)
-                .headers(RSync::get_headers(self, req)?)
-                .body(RSync::get_request_body(self, req)?)
+                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+                .headers(types::RefundSyncType::get_headers(self, req)?)
+                .body(types::RefundSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
diff --git a/crates/router/src/connector/checkout/transformers.rs b/crates/router/src/connector/checkout/transformers.rs
index 8811d5bd8bf..c7971d426ad 100644
--- a/crates/router/src/connector/checkout/transformers.rs
+++ b/crates/router/src/connector/checkout/transformers.rs
@@ -67,9 +67,9 @@ impl TryFrom<&types::ConnectorAuthType> for CheckoutAuthType {
         }
     }
 }
-impl TryFrom<&types::PaymentsRouterData> for PaymentsRequest {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for PaymentsRequest {
     type Error = error_stack::Report<errors::ValidateError>;
-    fn try_from(item: &types::PaymentsRouterData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let ccard = match item.request.payment_method_data {
             api::PaymentMethod::Card(ref ccard) => Some(ccard),
             api::PaymentMethod::BankTransfer
diff --git a/crates/router/src/connector/stripe.rs b/crates/router/src/connector/stripe.rs
index 88d86840abf..7181b87610a 100644
--- a/crates/router/src/connector/stripe.rs
+++ b/crates/router/src/connector/stripe.rs
@@ -55,22 +55,16 @@ impl api::PaymentSync for Stripe {}
 impl api::PaymentVoid for Stripe {}
 impl api::PaymentCapture for Stripe {}
 
-type PaymentCaptureType = dyn services::ConnectorIntegration<
-    api::PCapture,
-    types::PaymentsRequestCaptureData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
+        api::Capture,
+        types::PaymentsCaptureData,
         types::PaymentsResponseData,
     > for Stripe
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterCaptureData,
+        req: &types::PaymentsCaptureRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
@@ -90,7 +84,8 @@ impl
 
     fn get_url(
         &self,
-        req: &types::PaymentsRouterCaptureData,
+        req: &types::PaymentsCaptureRouterData,
+
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let id = req.request.connector_transaction_id.as_str();
@@ -105,7 +100,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterCaptureData,
+        req: &types::PaymentsCaptureRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let stripe_req = utils::Encode::<stripe::CaptureRequest>::convert_and_url_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -114,26 +109,27 @@ impl
 
     fn build_request(
         &self,
-        req: &types::PaymentsRouterCaptureData,
+        req: &types::PaymentsCaptureRouterData,
+
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                .url(&PaymentCaptureType::get_url(self, req, connectors)?)
-                .headers(PaymentCaptureType::get_headers(self, req)?)
-                .body(PaymentCaptureType::get_request_body(self, req)?)
+                .url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsCaptureType::get_headers(self, req)?)
+                .body(types::PaymentsCaptureType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterCaptureData,
+        data: &types::PaymentsCaptureRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterCaptureData, errors::ConnectorError>
+    ) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError>
     where
-        types::PaymentsRequestCaptureData: Clone,
+        types::PaymentsCaptureData: Clone,
         types::PaymentsResponseData: Clone,
     {
         let response: stripe::PaymentIntentResponse = res
@@ -170,31 +166,18 @@ impl
     }
 }
 
-type PSync = dyn services::ConnectorIntegration<
-    api::PSync,
-    types::PaymentsRequestSyncData,
-    types::PaymentsResponseData,
->;
-
 impl
-    services::ConnectorIntegration<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for Stripe
+    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Stripe
 {
     fn get_headers(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                PSync::get_content_type(self).to_string(),
+                types::PaymentsSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -209,11 +192,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let id = req.request.connector_transaction_id.clone();
@@ -227,34 +206,26 @@ impl
 
     fn build_request(
         &self,
-        req: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsSyncRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Get)
-                .url(&PSync::get_url(self, req, connectors)?)
-                .headers(PSync::get_headers(self, req)?)
-                .body(PSync::get_request_body(self, req)?)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsSyncType::get_headers(self, req)?)
+                .body(types::PaymentsSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::RouterData<
-            api::PSync,
-            types::PaymentsRequestSyncData,
-            types::PaymentsResponseData,
-        >,
+        data: &types::PaymentsSyncRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterSyncData, errors::ConnectorError>
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError>
     where
-        types::PaymentsRequestData: Clone,
+        types::PaymentsAuthorizeData: Clone,
         types::PaymentsResponseData: Clone,
     {
         logger::debug!(payment_sync_response=?res);
@@ -262,7 +233,6 @@ impl
             .response
             .parse_struct("PaymentIntentResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        logger::debug!(res=?response);
         types::RouterData::try_from(types::ResponseRouterData {
             response,
             data: data.clone(),
@@ -293,27 +263,21 @@ impl
     }
 }
 
-type Authorize = dyn services::ConnectorIntegration<
-    api::Authorize,
-    types::PaymentsRequestData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for Stripe
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsAuthorizeType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -328,7 +292,7 @@ impl
 
     fn get_url(
         &self,
-        _req: &types::PaymentsRouterData,
+        _req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
@@ -340,7 +304,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsRouterData,
+        req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let stripe_req = utils::Encode::<stripe::PaymentIntentRequest>::convert_and_url_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -349,30 +313,27 @@ impl
 
     fn build_request(
         &self,
-        req: &types::RouterData<
-            api::Authorize,
-            types::PaymentsRequestData,
-            types::PaymentsResponseData,
-        >,
+        req: &types::PaymentsAuthorizeRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
-                // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&Authorize::get_url(self, req, connectors)?)
-                .headers(Authorize::get_headers(self, req)?)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(Authorize::get_request_body(self, req)?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsRouterData,
+        data: &types::PaymentsAuthorizeRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentsRouterData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
         let response: stripe::PaymentIntentResponse = res
             .response
             .parse_struct("PaymentIntentResponse")
@@ -407,27 +368,21 @@ impl
     }
 }
 
-type Void = dyn services::ConnectorIntegration<
-    api::Void,
-    types::PaymentRequestCancelData,
-    types::PaymentsResponseData,
->;
-
 impl
     services::ConnectorIntegration<
         api::Void,
-        types::PaymentRequestCancelData,
+        types::PaymentsCancelData,
         types::PaymentsResponseData,
     > for Stripe
 {
     fn get_headers(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Authorize::get_content_type(self).to_string(),
+                types::PaymentsVoidType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -442,7 +397,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let payment_id = &req.request.connector_transaction_id;
@@ -455,7 +410,7 @@ impl
 
     fn get_request_body(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let stripe_req = utils::Encode::<stripe::CancelRequest>::convert_and_url_encode(req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
@@ -463,23 +418,23 @@ impl
     }
     fn build_request(
         &self,
-        req: &types::PaymentRouterCancelData,
+        req: &types::PaymentsCancelRouterData,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&Void::get_url(self, req, connectors)?)
-            .headers(Void::get_headers(self, req)?)
-            .body(Void::get_request_body(self, req)?)
+            .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+            .headers(types::PaymentsVoidType::get_headers(self, req)?)
+            .body(types::PaymentsVoidType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentRouterCancelData,
+        data: &types::PaymentsCancelRouterData,
         res: Response,
-    ) -> CustomResult<types::PaymentRouterCancelData, errors::ConnectorError> {
+    ) -> CustomResult<types::PaymentsCancelRouterData, errors::ConnectorError> {
         let response: stripe::PaymentIntentResponse = res
             .response
             .parse_struct("PaymentIntentResponse")
@@ -518,17 +473,8 @@ impl api::Refund for Stripe {}
 impl api::RefundExecute for Stripe {}
 impl api::RefundSync for Stripe {}
 
-type Execute = dyn services::ConnectorIntegration<
-    api::Execute,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::Execute,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Stripe
+impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Stripe
 {
     fn get_headers(
         &self,
@@ -537,7 +483,7 @@ impl
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                Execute::get_content_type(self).to_string(),
+                types::RefundExecuteType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -574,9 +520,9 @@ impl
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         let request = services::RequestBuilder::new()
             .method(services::Method::Post)
-            .url(&Execute::get_url(self, req, connectors)?)
-            .headers(Execute::get_headers(self, req)?)
-            .body(Execute::get_request_body(self, req)?)
+            .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+            .headers(types::RefundExecuteType::get_headers(self, req)?)
+            .body(types::RefundExecuteType::get_request_body(self, req)?)
             .build();
         Ok(Some(request))
     }
@@ -622,26 +568,17 @@ impl
     }
 }
 
-type RSync = dyn services::ConnectorIntegration<
-    api::RSync,
-    types::RefundsRequestData,
-    types::RefundsResponseData,
->;
-impl
-    services::ConnectorIntegration<
-        api::RSync,
-        types::RefundsRequestData,
-        types::RefundsResponseData,
-    > for Stripe
+impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
+    for Stripe
 {
     fn get_headers(
         &self,
-        req: &types::RouterData<api::RSync, types::RefundsRequestData, types::RefundsResponseData>,
+        req: &types::RouterData<api::RSync, types::RefundsData, types::RefundsResponseData>,
     ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
         let mut header = vec![
             (
                 headers::CONTENT_TYPE.to_string(),
-                RSync::get_content_type(self).to_string(),
+                types::RefundSyncType::get_content_type(self).to_string(),
             ),
             (headers::X_ROUTER.to_string(), "test".to_string()),
         ];
@@ -656,7 +593,7 @@ impl
 
     fn get_url(
         &self,
-        req: &types::RouterData<api::RSync, types::RefundsRequestData, types::RefundsResponseData>,
+        req: &types::RefundsRouterData<api::RSync>,
         connectors: Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         let id = req
@@ -672,17 +609,17 @@ impl
 
     fn build_request(
         &self,
-        req: &types::RouterData<api::RSync, types::RefundsRequestData, types::RefundsResponseData>,
+        req: &types::RefundsRouterData<api::RSync>,
         connectors: Connectors,
     ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
         Ok(Some(
             services::RequestBuilder::new()
                 .method(services::Method::Post)
                 // TODO: [ORCA-346] Requestbuilder needs &str migrate get_url to send &str instead of owned string
-                .url(&RSync::get_url(self, req, connectors)?)
-                .headers(RSync::get_headers(self, req)?)
+                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+                .headers(types::RefundSyncType::get_headers(self, req)?)
                 .header(headers::X_ROUTER, "test")
-                .body(RSync::get_request_body(self, req)?)
+                .body(types::RefundSyncType::get_request_body(self, req)?)
                 .build(),
         ))
     }
@@ -690,10 +627,10 @@ impl
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::RouterData<api::RSync, types::RefundsRequestData, types::RefundsResponseData>,
+        data: &types::RefundsRouterData<api::RSync>,
         res: Response,
     ) -> CustomResult<
-        types::RouterData<api::RSync, types::RefundsRequestData, types::RefundsResponseData>,
+        types::RouterData<api::RSync, types::RefundsData, types::RefundsResponseData>,
         errors::ConnectorError,
     > {
         logger::debug!(response=?res);
diff --git a/crates/router/src/connector/stripe/transformers.rs b/crates/router/src/connector/stripe/transformers.rs
index 9722c31b2a9..5bacb47de18 100644
--- a/crates/router/src/connector/stripe/transformers.rs
+++ b/crates/router/src/connector/stripe/transformers.rs
@@ -126,9 +126,9 @@ pub enum StripePaymentMethodData {
     Paypal,
 }
 
-impl TryFrom<&types::PaymentsRouterData> for PaymentIntentRequest {
+impl TryFrom<&types::PaymentsAuthorizeRouterData> for PaymentIntentRequest {
     type Error = error_stack::Report<errors::ParsingError>;
-    fn try_from(item: &types::PaymentsRouterData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let metadata_order_id = item.payment_id.to_string();
         let metadata_txn_id = format!("{}_{}_{}", item.merchant_id, item.payment_id, "1");
         let metadata_txn_uuid = Uuid::new_v4().to_string(); //Fetch autogenrated txn_uuid from Database.
@@ -508,9 +508,9 @@ pub struct CancelRequest {
     cancellation_reason: Option<CancellationReason>,
 }
 
-impl TryFrom<&types::PaymentRouterCancelData> for CancelRequest {
+impl TryFrom<&types::PaymentsCancelRouterData> for CancelRequest {
     type Error = error_stack::Report<errors::ParsingError>;
-    fn try_from(item: &types::PaymentRouterCancelData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
         let cancellation_reason = match &item.request.cancellation_reason {
             Some(c) => Some(
                 CancellationReason::from_str(c)
@@ -546,9 +546,9 @@ pub struct CaptureRequest {
     amount_to_capture: Option<i32>,
 }
 
-impl TryFrom<&types::PaymentsRouterCaptureData> for CaptureRequest {
+impl TryFrom<&types::PaymentsCaptureRouterData> for CaptureRequest {
     type Error = error_stack::Report<errors::ParsingError>;
-    fn try_from(item: &types::PaymentsRouterCaptureData) -> Result<Self, Self::Error> {
+    fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
         Ok(Self {
             amount_to_capture: item.request.amount_to_capture,
         })
diff --git a/crates/router/src/core/payments/flows/authorize_flow.rs b/crates/router/src/core/payments/flows/authorize_flow.rs
index cdac412b785..24b3a02c521 100644
--- a/crates/router/src/core/payments/flows/authorize_flow.rs
+++ b/crates/router/src/core/payments/flows/authorize_flow.rs
@@ -16,7 +16,7 @@ use crate::{
     types::{
         self, api,
         storage::{self, enums},
-        PaymentsRequestData, PaymentsResponseData, PaymentsRouterData,
+        PaymentsAuthorizeData, PaymentsAuthorizeRouterData, PaymentsResponseData,
     },
     utils,
 };
@@ -25,7 +25,7 @@ use crate::{
 impl
     ConstructFlowSpecificData<
         api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > for PaymentData<api::Authorize>
 {
@@ -35,11 +35,15 @@ impl
         connector_id: &str,
         merchant_account: &storage::MerchantAccount,
     ) -> RouterResult<
-        types::RouterData<api::Authorize, types::PaymentsRequestData, types::PaymentsResponseData>,
+        types::RouterData<
+            api::Authorize,
+            types::PaymentsAuthorizeData,
+            types::PaymentsResponseData,
+        >,
     > {
         let output = transformers::construct_payment_router_data::<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
         >(state, self.clone(), connector_id, merchant_account)
         .await?;
         Ok(output.1)
@@ -47,8 +51,8 @@ impl
 }
 
 #[async_trait]
-impl Feature<api::Authorize, types::PaymentsRequestData>
-    for types::RouterData<api::Authorize, types::PaymentsRequestData, types::PaymentsResponseData>
+impl Feature<api::Authorize, types::PaymentsAuthorizeData>
+    for types::RouterData<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
 {
     async fn decide_flows<'a>(
         self,
@@ -61,7 +65,7 @@ impl Feature<api::Authorize, types::PaymentsRequestData>
     where
         dyn api::Connector: services::ConnectorIntegration<
             api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         >,
     {
@@ -81,7 +85,7 @@ impl Feature<api::Authorize, types::PaymentsRequestData>
     }
 }
 
-impl PaymentsRouterData {
+impl PaymentsAuthorizeRouterData {
     pub async fn decide_flow<'a, 'b>(
         &'b self,
         state: &'a AppState,
@@ -89,11 +93,11 @@ impl PaymentsRouterData {
         maybe_customer: &Option<api::CustomerResponse>,
         confirm: Option<bool>,
         call_connector_action: payments::CallConnectorAction,
-    ) -> RouterResult<PaymentsRouterData>
+    ) -> RouterResult<PaymentsAuthorizeRouterData>
     where
         dyn api::Connector + Sync: services::ConnectorIntegration<
             api::Authorize,
-            PaymentsRequestData,
+            PaymentsAuthorizeData,
             PaymentsResponseData,
         >,
     {
@@ -101,7 +105,7 @@ impl PaymentsRouterData {
             Some(true) => {
                 let connector_integration: services::BoxedConnectorIntegration<
                     api::Authorize,
-                    PaymentsRequestData,
+                    PaymentsAuthorizeData,
                     PaymentsResponseData,
                 > = connector.connector.get_connector_integration();
                 let mut resp = services::execute_connector_processing_step(
diff --git a/crates/router/src/core/payments/flows/cancel_flow.rs b/crates/router/src/core/payments/flows/cancel_flow.rs
index 736724f478c..af9344b8936 100644
--- a/crates/router/src/core/payments/flows/cancel_flow.rs
+++ b/crates/router/src/core/payments/flows/cancel_flow.rs
@@ -8,26 +8,22 @@ use crate::{
     },
     routes::AppState,
     services,
-    types::{self, api, storage, PaymentRouterCancelData, PaymentsResponseData},
+    types::{self, api, storage, PaymentsCancelRouterData, PaymentsResponseData},
 };
 
 #[async_trait]
-impl
-    ConstructFlowSpecificData<
-        api::Void,
-        types::PaymentRequestCancelData,
-        types::PaymentsResponseData,
-    > for PaymentData<api::Void>
+impl ConstructFlowSpecificData<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
+    for PaymentData<api::Void>
 {
     async fn construct_r_d<'a>(
         &self,
         state: &AppState,
         connector_id: &str,
         merchant_account: &storage::MerchantAccount,
-    ) -> RouterResult<PaymentRouterCancelData> {
+    ) -> RouterResult<PaymentsCancelRouterData> {
         let output = transformers::construct_payment_router_data::<
             api::Void,
-            types::PaymentRequestCancelData,
+            types::PaymentsCancelData,
         >(state, self.clone(), connector_id, merchant_account)
         .await?;
         Ok(output.1)
@@ -35,8 +31,8 @@ impl
 }
 
 #[async_trait]
-impl Feature<api::Void, types::PaymentRequestCancelData>
-    for types::RouterData<api::Void, types::PaymentRequestCancelData, types::PaymentsResponseData>
+impl Feature<api::Void, types::PaymentsCancelData>
+    for types::RouterData<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
 {
     async fn decide_flows<'a>(
         self,
@@ -49,7 +45,7 @@ impl Feature<api::Void, types::PaymentRequestCancelData>
     where
         dyn api::Connector: services::ConnectorIntegration<
             api::Void,
-            types::PaymentRequestCancelData,
+            types::PaymentsCancelData,
             types::PaymentsResponseData,
         >,
     {
@@ -67,7 +63,7 @@ impl Feature<api::Void, types::PaymentRequestCancelData>
     }
 }
 
-impl PaymentRouterCancelData {
+impl PaymentsCancelRouterData {
     #[allow(clippy::too_many_arguments)]
     pub async fn decide_flow<'a, 'b>(
         &'b self,
@@ -76,18 +72,18 @@ impl PaymentRouterCancelData {
         _maybe_customer: &Option<api::CustomerResponse>,
         _confirm: Option<bool>,
         call_connector_action: payments::CallConnectorAction,
-    ) -> RouterResult<PaymentRouterCancelData>
+    ) -> RouterResult<PaymentsCancelRouterData>
     where
         // P: 'a,
         dyn api::Connector + Sync: services::ConnectorIntegration<
             api::Void,
-            types::PaymentRequestCancelData,
+            types::PaymentsCancelData,
             PaymentsResponseData,
         >,
     {
         let connector_integration: services::BoxedConnectorIntegration<
             api::Void,
-            types::PaymentRequestCancelData,
+            types::PaymentsCancelData,
             PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let resp = services::execute_connector_processing_step(
diff --git a/crates/router/src/core/payments/flows/capture_flow.rs b/crates/router/src/core/payments/flows/capture_flow.rs
index 2877e0afd66..d02cefb4811 100644
--- a/crates/router/src/core/payments/flows/capture_flow.rs
+++ b/crates/router/src/core/payments/flows/capture_flow.rs
@@ -9,28 +9,24 @@ use crate::{
     routes::AppState,
     services,
     types::{
-        self, api, storage, PaymentsRequestCaptureData, PaymentsResponseData,
-        PaymentsRouterCaptureData,
+        self, api, storage, PaymentsCaptureData, PaymentsCaptureRouterData, PaymentsResponseData,
     },
 };
 
 #[async_trait]
 impl
-    ConstructFlowSpecificData<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
-        types::PaymentsResponseData,
-    > for PaymentData<api::PCapture>
+    ConstructFlowSpecificData<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
+    for PaymentData<api::Capture>
 {
     async fn construct_r_d<'a>(
         &self,
         state: &AppState,
         connector_id: &str,
         merchant_account: &storage::MerchantAccount,
-    ) -> RouterResult<PaymentsRouterCaptureData> {
+    ) -> RouterResult<PaymentsCaptureRouterData> {
         let output = transformers::construct_payment_router_data::<
-            api::PCapture,
-            types::PaymentsRequestCaptureData,
+            api::Capture,
+            types::PaymentsCaptureData,
         >(state, self.clone(), connector_id, merchant_account)
         .await?;
         Ok(output.1)
@@ -38,25 +34,21 @@ impl
 }
 
 #[async_trait]
-impl Feature<api::PCapture, types::PaymentsRequestCaptureData>
-    for types::RouterData<
-        api::PCapture,
-        types::PaymentsRequestCaptureData,
-        types::PaymentsResponseData,
-    >
+impl Feature<api::Capture, types::PaymentsCaptureData>
+    for types::RouterData<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
 {
     async fn decide_flows<'a>(
         self,
         state: &AppState,
         connector: api::ConnectorData,
         customer: &Option<api::CustomerResponse>,
-        payment_data: PaymentData<api::PCapture>,
+        payment_data: PaymentData<api::Capture>,
         call_connector_action: payments::CallConnectorAction,
-    ) -> (RouterResult<Self>, PaymentData<api::PCapture>)
+    ) -> (RouterResult<Self>, PaymentData<api::Capture>)
     where
         dyn api::Connector: services::ConnectorIntegration<
-            api::PCapture,
-            types::PaymentsRequestCaptureData,
+            api::Capture,
+            types::PaymentsCaptureData,
             types::PaymentsResponseData,
         >,
     {
@@ -74,7 +66,7 @@ impl Feature<api::PCapture, types::PaymentsRequestCaptureData>
     }
 }
 
-impl PaymentsRouterCaptureData {
+impl PaymentsCaptureRouterData {
     #[allow(clippy::too_many_arguments)]
     pub async fn decide_flow<'a, 'b>(
         &'b self,
@@ -83,17 +75,14 @@ impl PaymentsRouterCaptureData {
         _maybe_customer: &Option<api::CustomerResponse>,
         _confirm: Option<bool>,
         call_connector_action: payments::CallConnectorAction,
-    ) -> RouterResult<PaymentsRouterCaptureData>
+    ) -> RouterResult<PaymentsCaptureRouterData>
     where
-        dyn api::Connector + Sync: services::ConnectorIntegration<
-            api::PCapture,
-            PaymentsRequestCaptureData,
-            PaymentsResponseData,
-        >,
+        dyn api::Connector + Sync:
+            services::ConnectorIntegration<api::Capture, PaymentsCaptureData, PaymentsResponseData>,
     {
         let connector_integration: services::BoxedConnectorIntegration<
-            api::PCapture,
-            PaymentsRequestCaptureData,
+            api::Capture,
+            PaymentsCaptureData,
             PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let resp = services::execute_connector_processing_step(
diff --git a/crates/router/src/core/payments/flows/psync_flow.rs b/crates/router/src/core/payments/flows/psync_flow.rs
index 61aafa7954a..b58a3223a40 100644
--- a/crates/router/src/core/payments/flows/psync_flow.rs
+++ b/crates/router/src/core/payments/flows/psync_flow.rs
@@ -8,18 +8,12 @@ use crate::{
     },
     routes::AppState,
     services,
-    types::{
-        self, api, storage, PaymentsRequestSyncData, PaymentsResponseData, PaymentsRouterSyncData,
-    },
+    types::{self, api, storage, PaymentsResponseData, PaymentsSyncData, PaymentsSyncRouterData},
 };
 
 #[async_trait]
-impl
-    ConstructFlowSpecificData<
-        api::PSync,
-        types::PaymentsRequestSyncData,
-        types::PaymentsResponseData,
-    > for PaymentData<api::PSync>
+impl ConstructFlowSpecificData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for PaymentData<api::PSync>
 {
     async fn construct_r_d<'a>(
         &self,
@@ -27,11 +21,11 @@ impl
         connector_id: &str,
         merchant_account: &storage::MerchantAccount,
     ) -> RouterResult<
-        types::RouterData<api::PSync, types::PaymentsRequestSyncData, types::PaymentsResponseData>,
+        types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>,
     > {
         let output = transformers::construct_payment_router_data::<
             api::PSync,
-            types::PaymentsRequestSyncData,
+            types::PaymentsSyncData,
         >(state, self.clone(), connector_id, merchant_account)
         .await?;
         Ok(output.1)
@@ -39,8 +33,8 @@ impl
 }
 
 #[async_trait]
-impl Feature<api::PSync, types::PaymentsRequestSyncData>
-    for types::RouterData<api::PSync, types::PaymentsRequestSyncData, types::PaymentsResponseData>
+impl Feature<api::PSync, types::PaymentsSyncData>
+    for types::RouterData<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
 {
     async fn decide_flows<'a>(
         self,
@@ -53,7 +47,7 @@ impl Feature<api::PSync, types::PaymentsRequestSyncData>
     where
         dyn api::Connector: services::ConnectorIntegration<
             api::PSync,
-            types::PaymentsRequestSyncData,
+            types::PaymentsSyncData,
             types::PaymentsResponseData,
         >,
     {
@@ -71,7 +65,7 @@ impl Feature<api::PSync, types::PaymentsRequestSyncData>
     }
 }
 
-impl PaymentsRouterSyncData {
+impl PaymentsSyncRouterData {
     pub async fn decide_flow<'a, 'b>(
         &'b self,
         state: &'a AppState,
@@ -79,17 +73,14 @@ impl PaymentsRouterSyncData {
         _maybe_customer: &Option<api::CustomerResponse>,
         _confirm: Option<bool>,
         call_connector_action: payments::CallConnectorAction,
-    ) -> RouterResult<PaymentsRouterSyncData>
+    ) -> RouterResult<PaymentsSyncRouterData>
     where
-        dyn api::Connector + Sync: services::ConnectorIntegration<
-            api::PSync,
-            PaymentsRequestSyncData,
-            PaymentsResponseData,
-        >,
+        dyn api::Connector + Sync:
+            services::ConnectorIntegration<api::PSync, PaymentsSyncData, PaymentsResponseData>,
     {
         let connector_integration: services::BoxedConnectorIntegration<
             api::PSync,
-            PaymentsRequestSyncData,
+            PaymentsSyncData,
             PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let resp = services::execute_connector_processing_step(
diff --git a/crates/router/src/core/payments/operations/payment_response.rs b/crates/router/src/core/payments/operations/payment_response.rs
index dddb863a6a0..6d281dd27b1 100644
--- a/crates/router/src/core/payments/operations/payment_response.rs
+++ b/crates/router/src/core/payments/operations/payment_response.rs
@@ -25,7 +25,7 @@ use crate::{
 pub struct PaymentResponse;
 
 #[async_trait]
-impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestData>
+impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsAuthorizeData>
     for PaymentResponse
 {
     async fn update_tracker<'b>(
@@ -34,7 +34,7 @@ impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestData>
         payment_id: &api::PaymentIdType,
         mut payment_data: PaymentData<F>,
         response: Option<
-            types::RouterData<F, types::PaymentsRequestData, types::PaymentsResponseData>,
+            types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>,
         >,
     ) -> RouterResult<PaymentData<F>>
     where
@@ -49,16 +49,14 @@ impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestData>
 }
 
 #[async_trait]
-impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestSyncData>
-    for PaymentResponse
-{
+impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsSyncData> for PaymentResponse {
     async fn update_tracker<'b>(
         &'b self,
         db: &dyn Db,
         payment_id: &api::PaymentIdType,
         payment_data: PaymentData<F>,
         response: Option<
-            types::RouterData<F, types::PaymentsRequestSyncData, types::PaymentsResponseData>,
+            types::RouterData<F, types::PaymentsSyncData, types::PaymentsResponseData>,
         >,
     ) -> RouterResult<PaymentData<F>>
     where
@@ -69,7 +67,7 @@ impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestSyncDa
 }
 
 #[async_trait]
-impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestCaptureData>
+impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsCaptureData>
     for PaymentResponse
 {
     async fn update_tracker<'b>(
@@ -78,7 +76,7 @@ impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestCaptur
         payment_id: &api::PaymentIdType,
         payment_data: PaymentData<F>,
         response: Option<
-            types::RouterData<F, types::PaymentsRequestCaptureData, types::PaymentsResponseData>,
+            types::RouterData<F, types::PaymentsCaptureData, types::PaymentsResponseData>,
         >,
     ) -> RouterResult<PaymentData<F>>
     where
@@ -89,16 +87,14 @@ impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsRequestCaptur
 }
 
 #[async_trait]
-impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentRequestCancelData>
-    for PaymentResponse
-{
+impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsCancelData> for PaymentResponse {
     async fn update_tracker<'b>(
         &'b self,
         db: &dyn Db,
         payment_id: &api::PaymentIdType,
         payment_data: PaymentData<F>,
         response: Option<
-            types::RouterData<F, types::PaymentRequestCancelData, types::PaymentsResponseData>,
+            types::RouterData<F, types::PaymentsCancelData, types::PaymentsResponseData>,
         >,
     ) -> RouterResult<PaymentData<F>>
     where
diff --git a/crates/router/src/core/payments/transformers.rs b/crates/router/src/core/payments/transformers.rs
index 7b65f321b28..d51028c86ad 100644
--- a/crates/router/src/core/payments/transformers.rs
+++ b/crates/router/src/core/payments/transformers.rs
@@ -246,7 +246,7 @@ where
     })
 }
 
-impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestData {
+impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsAuthorizeData {
     type Error = error_stack::Report<errors::ApiErrorResponse>;
 
     fn try_from(payment_data: PaymentData<F>) -> Result<Self, Self::Error> {
@@ -286,7 +286,7 @@ impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestData {
     }
 }
 
-impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestSyncData {
+impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsSyncData {
     type Error = errors::ApiErrorResponse;
 
     fn try_from(payment_data: PaymentData<F>) -> Result<Self, Self::Error> {
@@ -300,7 +300,7 @@ impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestSyncData {
     }
 }
 
-impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestCaptureData {
+impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsCaptureData {
     type Error = errors::ApiErrorResponse;
 
     fn try_from(payment_data: PaymentData<F>) -> Result<Self, Self::Error> {
@@ -314,7 +314,7 @@ impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsRequestCaptureData {
     }
 }
 
-impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentRequestCancelData {
+impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsCancelData {
     type Error = errors::ApiErrorResponse;
 
     fn try_from(payment_data: PaymentData<F>) -> Result<Self, Self::Error> {
diff --git a/crates/router/src/core/refunds.rs b/crates/router/src/core/refunds.rs
index a93c6a72be7..dd45ce34433 100644
--- a/crates/router/src/core/refunds.rs
+++ b/crates/router/src/core/refunds.rs
@@ -117,7 +117,7 @@ pub async fn trigger_refund_to_gateway(
     logger::debug!(?router_data);
     let connector_integration: services::BoxedConnectorIntegration<
         api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let router_data = services::execute_connector_processing_step(
@@ -226,7 +226,7 @@ pub async fn sync_refund_with_gateway(
 
     let connector_integration: services::BoxedConnectorIntegration<
         api::RSync,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let router_data = services::execute_connector_processing_step(
diff --git a/crates/router/src/core/utils.rs b/crates/router/src/core/utils.rs
index 3538dd7128e..033e8942d4a 100644
--- a/crates/router/src/core/utils.rs
+++ b/crates/router/src/core/utils.rs
@@ -80,7 +80,7 @@ pub async fn construct_refund_router_data<'a, F>(
         address: PaymentAddress::default(),
         auth_type: payment_attempt.authentication_type.unwrap_or_default(),
 
-        request: types::RefundsRequestData {
+        request: types::RefundsData {
             refund_id: refund.refund_id.clone(),
             payment_method_data,
             connector_transaction_id: refund.transaction_id.clone(),
diff --git a/crates/router/src/routes/payments.rs b/crates/router/src/routes/payments.rs
index aca665c3ba7..57d6fbb7cb5 100644
--- a/crates/router/src/routes/payments.rs
+++ b/crates/router/src/routes/payments.rs
@@ -18,7 +18,7 @@ use crate::{
                 PaymentIdType, PaymentListConstraints, PaymentsCancelRequest,
                 PaymentsCaptureRequest, PaymentsRequest, PaymentsRetrieveRequest,
             },
-            Authorize, PCapture, PSync, PaymentRetrieveBody, PaymentsStartRequest, Void,
+            Authorize, Capture, PSync, PaymentRetrieveBody, PaymentsStartRequest, Void,
         },
         storage::enums::CaptureMethod,
     }, // FIXME imports
@@ -234,7 +234,7 @@ pub(crate) async fn payments_capture(
         &req,
         capture_payload,
         |state, merchant_account, payload| {
-            payments::payments_core::<PCapture, _, _, _>(
+            payments::payments_core::<Capture, _, _, _>(
                 state,
                 merchant_account,
                 payments::PaymentCapture,
diff --git a/crates/router/src/types.rs b/crates/router/src/types.rs
index b16be777258..6ea5615485c 100644
--- a/crates/router/src/types.rs
+++ b/crates/router/src/types.rs
@@ -17,21 +17,33 @@ use self::{api::payments, storage::enums};
 pub use crate::core::payments::PaymentAddress;
 use crate::{core::errors::ApiErrorResponse, services};
 
-pub type PaymentsRouterData = RouterData<api::Authorize, PaymentsRequestData, PaymentsResponseData>;
-pub type PaymentsRouterSyncData =
-    RouterData<api::PSync, PaymentsRequestSyncData, PaymentsResponseData>;
-pub type PaymentsRouterCaptureData =
-    RouterData<api::PCapture, PaymentsRequestCaptureData, PaymentsResponseData>;
-
-pub type PaymentRouterCancelData =
-    RouterData<api::Void, PaymentRequestCancelData, PaymentsResponseData>;
-pub type RefundsRouterData<F> = RouterData<F, RefundsRequestData, RefundsResponseData>;
+pub type PaymentsAuthorizeRouterData =
+    RouterData<api::Authorize, PaymentsAuthorizeData, PaymentsResponseData>;
+pub type PaymentsSyncRouterData = RouterData<api::PSync, PaymentsSyncData, PaymentsResponseData>;
+pub type PaymentsCaptureRouterData =
+    RouterData<api::Capture, PaymentsCaptureData, PaymentsResponseData>;
+pub type PaymentsCancelRouterData = RouterData<api::Void, PaymentsCancelData, PaymentsResponseData>;
+pub type RefundsRouterData<F> = RouterData<F, RefundsData, RefundsResponseData>;
+
 pub type PaymentsResponseRouterData<R> =
-    ResponseRouterData<api::Authorize, R, PaymentsRequestData, PaymentsResponseData>;
+    ResponseRouterData<api::Authorize, R, PaymentsAuthorizeData, PaymentsResponseData>;
 pub type PaymentsCancelResponseRouterData<R> =
-    ResponseRouterData<api::Void, R, PaymentRequestCancelData, PaymentsResponseData>;
+    ResponseRouterData<api::Void, R, PaymentsCancelData, PaymentsResponseData>;
 pub type RefundsResponseRouterData<F, R> =
-    ResponseRouterData<F, R, RefundsRequestData, RefundsResponseData>;
+    ResponseRouterData<F, R, RefundsData, RefundsResponseData>;
+
+pub type PaymentsAuthorizeType =
+    dyn services::ConnectorIntegration<api::Authorize, PaymentsAuthorizeData, PaymentsResponseData>;
+pub type PaymentsSyncType =
+    dyn services::ConnectorIntegration<api::PSync, PaymentsSyncData, PaymentsResponseData>;
+pub type PaymentsCaptureType =
+    dyn services::ConnectorIntegration<api::Capture, PaymentsCaptureData, PaymentsResponseData>;
+pub type PaymentsVoidType =
+    dyn services::ConnectorIntegration<api::Void, PaymentsCancelData, PaymentsResponseData>;
+pub type RefundExecuteType =
+    dyn services::ConnectorIntegration<api::Execute, RefundsData, RefundsResponseData>;
+pub type RefundSyncType =
+    dyn services::ConnectorIntegration<api::RSync, RefundsData, RefundsResponseData>;
 
 #[derive(Debug, Clone)]
 pub struct RouterData<Flow, Request, Response> {
@@ -59,7 +71,7 @@ pub struct RouterData<Flow, Request, Response> {
 }
 
 #[derive(Debug, Clone)]
-pub struct PaymentsRequestData {
+pub struct PaymentsAuthorizeData {
     pub payment_method_data: payments::PaymentMethod,
     pub amount: i32,
     pub currency: enums::Currency,
@@ -77,20 +89,20 @@ pub struct PaymentsRequestData {
 }
 
 #[derive(Debug, Clone)]
-pub struct PaymentsRequestCaptureData {
+pub struct PaymentsCaptureData {
     pub amount_to_capture: Option<i32>,
     pub connector_transaction_id: String,
 }
 
 #[derive(Debug, Clone)]
-pub struct PaymentsRequestSyncData {
+pub struct PaymentsSyncData {
     //TODO : add fields based on the connector requirements
     pub connector_transaction_id: String,
     pub encoded_data: Option<String>,
 }
 
 #[derive(Debug, Clone)]
-pub struct PaymentRequestCancelData {
+pub struct PaymentsCancelData {
     pub connector_transaction_id: String,
     pub cancellation_reason: Option<String>,
 }
@@ -103,7 +115,7 @@ pub struct PaymentsResponseData {
 }
 
 #[derive(Debug, Clone)]
-pub struct RefundsRequestData {
+pub struct RefundsData {
     pub refund_id: String,
     pub payment_method_data: payments::PaymentMethod,
     pub connector_transaction_id: String,
diff --git a/crates/router/src/types/api/payments.rs b/crates/router/src/types/api/payments.rs
index 666a622fd46..5807501928a 100644
--- a/crates/router/src/types/api/payments.rs
+++ b/crates/router/src/types/api/payments.rs
@@ -221,7 +221,7 @@ impl Default for PaymentIdType {
 #[derive(Debug, Clone)]
 pub struct Authorize;
 #[derive(Debug, Clone)]
-pub struct PCapture;
+pub struct Capture;
 
 #[derive(Debug, Clone)]
 pub struct PSync;
@@ -593,22 +593,22 @@ impl From<enums::AttemptStatus> for enums::IntentStatus {
 }
 
 pub trait PaymentAuthorize:
-    api::ConnectorIntegration<Authorize, types::PaymentsRequestData, types::PaymentsResponseData>
+    api::ConnectorIntegration<Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
 {
 }
 
 pub trait PaymentSync:
-    api::ConnectorIntegration<PSync, types::PaymentsRequestSyncData, types::PaymentsResponseData>
+    api::ConnectorIntegration<PSync, types::PaymentsSyncData, types::PaymentsResponseData>
 {
 }
 
 pub trait PaymentVoid:
-    api::ConnectorIntegration<Void, types::PaymentRequestCancelData, types::PaymentsResponseData>
+    api::ConnectorIntegration<Void, types::PaymentsCancelData, types::PaymentsResponseData>
 {
 }
 
 pub trait PaymentCapture:
-    api::ConnectorIntegration<PCapture, types::PaymentsRequestCaptureData, types::PaymentsResponseData>
+    api::ConnectorIntegration<Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
 {
 }
 
diff --git a/crates/router/src/types/api/refunds.rs b/crates/router/src/types/api/refunds.rs
index 54e0e2450d0..0cef2c1d6f2 100644
--- a/crates/router/src/types/api/refunds.rs
+++ b/crates/router/src/types/api/refunds.rs
@@ -67,12 +67,12 @@ pub struct Execute;
 pub struct RSync;
 
 pub trait RefundExecute:
-    api::ConnectorIntegration<Execute, types::RefundsRequestData, types::RefundsResponseData>
+    api::ConnectorIntegration<Execute, types::RefundsData, types::RefundsResponseData>
 {
 }
 
 pub trait RefundSync:
-    api::ConnectorIntegration<RSync, types::RefundsRequestData, types::RefundsResponseData>
+    api::ConnectorIntegration<RSync, types::RefundsData, types::RefundsResponseData>
 {
 }
 
diff --git a/crates/router/tests/connectors/aci.rs b/crates/router/tests/connectors/aci.rs
index c7573a55717..e27b9e91ce3 100644
--- a/crates/router/tests/connectors/aci.rs
+++ b/crates/router/tests/connectors/aci.rs
@@ -12,7 +12,7 @@ use router::{
 
 use crate::connector_auth::ConnectorAuthentication;
 
-fn construct_payment_router_data() -> types::PaymentsRouterData {
+fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
     let auth = ConnectorAuthentication::new()
         .aci
         .expect("Missing ACI connector authentication configuration");
@@ -29,7 +29,7 @@ fn construct_payment_router_data() -> types::PaymentsRouterData {
         description: Some("This is a test".to_string()),
         orca_return_url: None,
         return_url: None,
-        request: types::PaymentsRequestData {
+        request: types::PaymentsAuthorizeData {
             amount: 1000,
             currency: enums::Currency::USD,
             payment_method_data: types::api::PaymentMethod::Card(types::api::CCard {
@@ -71,9 +71,10 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
-        request: types::RefundsRequestData {
+        request: types::RefundsData {
             amount: 1000,
             currency: enums::Currency::USD,
+
             refund_id: uuid::Uuid::new_v4().to_string(),
             payment_method_data: types::api::PaymentMethod::Card(types::api::CCard {
                 card_number: Secret::new("4200000000000000".to_string()),
@@ -108,7 +109,7 @@ async fn payments_create_success() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -143,7 +144,7 @@ async fn payments_create_failure() {
         };
         let connector_integration: services::BoxedConnectorIntegration<
             types::api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let mut request = construct_payment_router_data();
@@ -184,7 +185,7 @@ async fn refund_for_successful_payments() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -202,7 +203,7 @@ async fn refund_for_successful_payments() {
     );
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let mut refund_request = construct_refund_router_data();
@@ -239,7 +240,7 @@ async fn refunds_create_failure() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let mut request = construct_refund_router_data();
diff --git a/crates/router/tests/connectors/authorizedotnet.rs b/crates/router/tests/connectors/authorizedotnet.rs
index 22440574fff..33b3ebe07f6 100644
--- a/crates/router/tests/connectors/authorizedotnet.rs
+++ b/crates/router/tests/connectors/authorizedotnet.rs
@@ -12,7 +12,7 @@ use router::{
 
 use crate::connector_auth::ConnectorAuthentication;
 
-fn construct_payment_router_data() -> types::PaymentsRouterData {
+fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
     let auth = ConnectorAuthentication::new()
         .authorizedotnet
         .expect("Missing Authorize.net connector authentication configuration");
@@ -29,7 +29,7 @@ fn construct_payment_router_data() -> types::PaymentsRouterData {
         auth_type: enums::AuthenticationType::NoThreeDs,
         description: Some("This is a test".to_string()),
         return_url: None,
-        request: types::PaymentsRequestData {
+        request: types::PaymentsAuthorizeData {
             amount: 100,
             currency: enums::Currency::USD,
             payment_method_data: types::api::PaymentMethod::Card(types::api::CCard {
@@ -71,7 +71,7 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
-        request: router::types::RefundsRequestData {
+        request: router::types::RefundsData {
             amount: 100,
             currency: enums::Currency::USD,
             refund_id: uuid::Uuid::new_v4().to_string(),
@@ -107,7 +107,7 @@ async fn payments_create_success() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -145,7 +145,7 @@ async fn payments_create_failure() {
         };
         let connector_integration: services::BoxedConnectorIntegration<
             types::api::Authorize,
-            types::PaymentsRequestData,
+            types::PaymentsAuthorizeData,
             types::PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let mut request = construct_payment_router_data();
@@ -192,7 +192,7 @@ async fn refunds_create_success() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
 
@@ -231,7 +231,7 @@ async fn refunds_create_failure() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
 
diff --git a/crates/router/tests/connectors/checkout.rs b/crates/router/tests/connectors/checkout.rs
index 5f084a65909..d6de0f8a857 100644
--- a/crates/router/tests/connectors/checkout.rs
+++ b/crates/router/tests/connectors/checkout.rs
@@ -8,7 +8,7 @@ use router::{
 
 use crate::connector_auth::ConnectorAuthentication;
 
-fn construct_payment_router_data() -> types::PaymentsRouterData {
+fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
     let auth = ConnectorAuthentication::new()
         .checkout
         .expect("Missing Checkout connector authentication configuration");
@@ -25,7 +25,7 @@ fn construct_payment_router_data() -> types::PaymentsRouterData {
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
-        request: types::PaymentsRequestData {
+        request: types::PaymentsAuthorizeData {
             amount: 100,
             currency: enums::Currency::USD,
             payment_method_data: types::api::PaymentMethod::Card(api::CCard {
@@ -67,7 +67,7 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
-        request: types::RefundsRequestData {
+        request: types::RefundsData {
             amount: 100,
             currency: enums::Currency::USD,
             refund_id: uuid::Uuid::new_v4().to_string(),
@@ -104,7 +104,7 @@ async fn test_checkout_payment_success() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -144,7 +144,7 @@ async fn test_checkout_refund_success() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -167,7 +167,7 @@ async fn test_checkout_refund_success() {
     // Successful refund
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let mut refund_request = construct_refund_router_data();
@@ -208,7 +208,7 @@ async fn test_checkout_payment_failure() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let mut request = construct_payment_router_data();
@@ -242,7 +242,7 @@ async fn test_checkout_refund_failure() {
     };
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Authorize,
-        types::PaymentsRequestData,
+        types::PaymentsAuthorizeData,
         types::PaymentsResponseData,
     > = connector.connector.get_connector_integration();
     let request = construct_payment_router_data();
@@ -263,7 +263,7 @@ async fn test_checkout_refund_failure() {
     // Unsuccessful refund
     let connector_integration: services::BoxedConnectorIntegration<
         types::api::Execute,
-        types::RefundsRequestData,
+        types::RefundsData,
         types::RefundsResponseData,
     > = connector.connector.get_connector_integration();
     let mut refund_request = construct_refund_router_data();
diff --git a/crates/router_derive/src/macros/operation.rs b/crates/router_derive/src/macros/operation.rs
index 1a587186901..56a090db3a4 100644
--- a/crates/router_derive/src/macros/operation.rs
+++ b/crates/router_derive/src/macros/operation.rs
@@ -90,15 +90,13 @@ impl Conversion {
     fn get_req_type(ident: Derives) -> syn::Ident {
         match ident {
             Derives::Authorize => syn::Ident::new("PaymentsRequest", Span::call_site()),
-            Derives::Authorizedata => syn::Ident::new("PaymentsRequestData", Span::call_site()),
+            Derives::Authorizedata => syn::Ident::new("PaymentsAuthorizeData", Span::call_site()),
             Derives::Sync => syn::Ident::new("PaymentsRetrieveRequest", Span::call_site()),
-            Derives::Syncdata => syn::Ident::new("PaymentsRequestSyncData", Span::call_site()),
+            Derives::Syncdata => syn::Ident::new("PaymentsSyncData", Span::call_site()),
             Derives::Cancel => syn::Ident::new("PaymentsCancelRequest", Span::call_site()),
-            Derives::Canceldata => syn::Ident::new("PaymentRequestCancelData", Span::call_site()),
+            Derives::Canceldata => syn::Ident::new("PaymentsCancelData", Span::call_site()),
             Derives::Capture => syn::Ident::new("PaymentsCaptureRequest", Span::call_site()),
-            Derives::Capturedata => {
-                syn::Ident::new("PaymentsRequestCaptureData", Span::call_site())
-            }
+            Derives::Capturedata => syn::Ident::new("PaymentsCaptureData", Span::call_site()),
             Derives::Start => syn::Ident::new("PaymentsStartRequest", Span::call_site()),
         }
     }
@@ -276,10 +274,10 @@ pub fn operation_derive_inner(token: proc_macro::TokenStream) -> proc_macro::Tok
                     PaymentData
                 };
                 use crate::types::{
-                    PaymentsRequestSyncData,
-                    PaymentsRequestCaptureData,
-                    PaymentRequestCancelData,
-                    PaymentsRequestData,
+                    PaymentsSyncData,
+                    PaymentsCaptureData,
+                    PaymentsCancelData,
+                    PaymentsAuthorizeData,
 
                     api::{
                         PaymentsCaptureRequest,