Bug: [REFACTOR]: Move Dummy connector



Movement of dummy connector form `router` crate to `hyperswitch_connectors` crate
diff --git a/crates/hyperswitch_connectors/Cargo.toml b/crates/hyperswitch_connectors/Cargo.toml
index 9233aa9bc5f..9e4996d14cd 100644
--- a/crates/hyperswitch_connectors/Cargo.toml
+++ b/crates/hyperswitch_connectors/Cargo.toml
@@ -11,6 +11,11 @@ payouts = ["hyperswitch_domain_models/payouts", "api_models/payouts", "hyperswit
 v1 = ["api_models/v1", "hyperswitch_domain_models/v1", "common_utils/v1"]
 v2 = ["api_models/v2", "hyperswitch_domain_models/v2", "common_utils/v2", "hyperswitch_interfaces/v2"]
 revenue_recovery = ["hyperswitch_interfaces/revenue_recovery", "hyperswitch_domain_models/revenue_recovery"]
+default = ["dummy_connector"]
+dummy_connector = [
+    "hyperswitch_interfaces/dummy_connector",
+    "hyperswitch_domain_models/dummy_connector",
+]
 
 [dependencies]
 actix-web = "4.11.0"
diff --git a/crates/hyperswitch_connectors/src/connectors.rs b/crates/hyperswitch_connectors/src/connectors.rs
index b603923d985..15dc705db50 100644
--- a/crates/hyperswitch_connectors/src/connectors.rs
+++ b/crates/hyperswitch_connectors/src/connectors.rs
@@ -26,6 +26,8 @@ pub mod datatrans;
 pub mod deutschebank;
 pub mod digitalvirgo;
 pub mod dlocal;
+#[cfg(feature = "dummy_connector")]
+pub mod dummyconnector;
 pub mod ebanx;
 pub mod elavon;
 pub mod facilitapay;
@@ -103,6 +105,8 @@ pub mod worldpayxml;
 pub mod xendit;
 pub mod zen;
 pub mod zsl;
+#[cfg(feature = "dummy_connector")]
+pub use self::dummyconnector::DummyConnector;
 pub use self::{
     aci::Aci, adyen::Adyen, adyenplatform::Adyenplatform, airwallex::Airwallex,
     amazonpay::Amazonpay, archipel::Archipel, authorizedotnet::Authorizedotnet, bambora::Bambora,
diff --git a/crates/hyperswitch_connectors/src/connectors/dummyconnector.rs b/crates/hyperswitch_connectors/src/connectors/dummyconnector.rs
new file mode 100644
index 00000000000..c86ca3cb219
--- /dev/null
+++ b/crates/hyperswitch_connectors/src/connectors/dummyconnector.rs
@@ -0,0 +1,627 @@
+pub mod transformers;
+
+use std::fmt::Debug;
+
+use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
+use common_enums::{CaptureMethod, PaymentMethod, PaymentMethodType};
+use common_utils::{
+    consts as common_consts,
+    errors::CustomResult,
+    ext_traits::BytesExt,
+    request::{Method, Request, RequestBuilder, RequestContent},
+};
+use error_stack::{report, ResultExt};
+use hyperswitch_domain_models::{
+    router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
+    router_flow_types::{
+        AccessTokenAuth, Authorize, Capture, Execute, PSync, PaymentMethodToken, RSync, Session,
+        SetupMandate, Void,
+    },
+    router_request_types::{
+        AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
+        PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
+        RefundsData, SetupMandateRequestData,
+    },
+    router_response_types::{PaymentsResponseData, RefundsResponseData},
+    types::{
+        PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
+        RefundSyncRouterData, RefundsRouterData,
+    },
+};
+use hyperswitch_interfaces::{
+    api::{
+        ConnectorAccessToken, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration,
+        ConnectorSpecifications, ConnectorValidation, MandateSetup, Payment, PaymentAuthorize,
+        PaymentCapture, PaymentSession, PaymentSync, PaymentToken, PaymentVoid, Refund,
+        RefundExecute, RefundSync,
+    },
+    configs::Connectors,
+    errors::ConnectorError,
+    events::connector_api_logs::ConnectorEvent,
+    types::{
+        PaymentsAuthorizeType, PaymentsCaptureType, PaymentsSyncType, RefundExecuteType,
+        RefundSyncType, Response,
+    },
+    webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
+};
+use masking::{Mask as _, Maskable};
+
+use crate::{
+    constants::headers,
+    types::ResponseRouterData,
+    utils::{construct_not_supported_error_report, RefundsRequestData as _},
+};
+
+#[derive(Debug, Clone)]
+pub struct DummyConnector<const T: u8>;
+
+impl<const T: u8> Payment for DummyConnector<T> {}
+impl<const T: u8> PaymentSession for DummyConnector<T> {}
+impl<const T: u8> ConnectorAccessToken for DummyConnector<T> {}
+impl<const T: u8> MandateSetup for DummyConnector<T> {}
+impl<const T: u8> PaymentAuthorize for DummyConnector<T> {}
+impl<const T: u8> PaymentSync for DummyConnector<T> {}
+impl<const T: u8> PaymentCapture for DummyConnector<T> {}
+impl<const T: u8> PaymentVoid for DummyConnector<T> {}
+impl<const T: u8> Refund for DummyConnector<T> {}
+impl<const T: u8> RefundExecute for DummyConnector<T> {}
+impl<const T: u8> RefundSync for DummyConnector<T> {}
+impl<const T: u8> PaymentToken for DummyConnector<T> {}
+
+impl<const T: u8>
+    ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    // Not Implemented (R)
+}
+
+impl<const T: u8, Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response>
+    for DummyConnector<T>
+where
+    Self: ConnectorIntegration<Flow, Request, Response>,
+{
+    fn build_headers(
+        &self,
+        req: &RouterData<Flow, Request, Response>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        let mut header = vec![
+            (
+                headers::CONTENT_TYPE.to_string(),
+                PaymentsAuthorizeType::get_content_type(self)
+                    .to_string()
+                    .into(),
+            ),
+            (
+                common_consts::TENANT_HEADER.to_string(),
+                req.tenant_id.get_string_repr().to_string().into(),
+            ),
+        ];
+        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
+        header.append(&mut api_key);
+        Ok(header)
+    }
+}
+
+impl<const T: u8> ConnectorCommon for DummyConnector<T> {
+    fn id(&self) -> &'static str {
+        Into::<transformers::DummyConnectors>::into(T).get_dummy_connector_id()
+    }
+
+    fn common_get_content_type(&self) -> &'static str {
+        "application/json"
+    }
+
+    fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
+        connectors.dummyconnector.base_url.as_ref()
+    }
+
+    fn get_auth_header(
+        &self,
+        auth_type: &ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        let auth = transformers::DummyConnectorAuthType::try_from(auth_type)
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
+        Ok(vec![(
+            headers::AUTHORIZATION.to_string(),
+            auth.api_key.into_masked(),
+        )])
+    }
+
+    fn build_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        let response: transformers::DummyConnectorErrorResponse = res
+            .response
+            .parse_struct("DummyConnectorErrorResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+
+        event_builder.map(|i| i.set_error_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+
+        Ok(ErrorResponse {
+            status_code: res.status_code,
+            code: response.error.code,
+            message: response.error.message,
+            reason: response.error.reason,
+            attempt_status: None,
+            connector_transaction_id: None,
+            network_advice_code: None,
+            network_decline_code: None,
+            network_error_message: None,
+        })
+    }
+}
+
+impl<const T: u8> ConnectorValidation for DummyConnector<T> {
+    fn validate_connector_against_payment_request(
+        &self,
+        capture_method: Option<CaptureMethod>,
+        _payment_method: PaymentMethod,
+        _pmt: Option<PaymentMethodType>,
+    ) -> CustomResult<(), ConnectorError> {
+        let capture_method = capture_method.unwrap_or_default();
+        match capture_method {
+            CaptureMethod::Automatic
+            | CaptureMethod::Manual
+            | CaptureMethod::SequentialAutomatic => Ok(()),
+            CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => Err(
+                construct_not_supported_error_report(capture_method, self.id()),
+            ),
+        }
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    //TODO: implement sessions flow
+}
+
+impl<const T: u8> ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken>
+    for DummyConnector<T>
+{
+}
+
+impl<const T: u8> ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    fn build_request(
+        &self,
+        _req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Err(
+            ConnectorError::NotImplemented("Setup Mandate flow for DummyConnector".to_string())
+                .into(),
+        )
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    fn get_headers(
+        &self,
+        req: &PaymentsAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &PaymentsAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        match req.payment_method {
+            PaymentMethod::Card
+            | PaymentMethod::Upi
+            | PaymentMethod::Wallet
+            | PaymentMethod::PayLater => Ok(format!("{}/payment", self.base_url(connectors))),
+            _ => Err(error_stack::report!(ConnectorError::NotSupported {
+                message: format!("The payment method {} is not supported", req.payment_method),
+                connector: Into::<transformers::DummyConnectors>::into(T).get_dummy_connector_id(),
+            })),
+        }
+    }
+
+    fn get_request_body(
+        &self,
+        req: &PaymentsAuthorizeRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let connector_req = transformers::DummyConnectorPaymentsRequest::<T>::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
+    }
+
+    fn build_request(
+        &self,
+        req: &PaymentsAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
+                .set_body(PaymentsAuthorizeType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PaymentsAuthorizeRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PaymentsAuthorizeRouterData, ConnectorError> {
+        let response: transformers::PaymentsResponse = res
+            .response
+            .parse_struct("DummyConnector PaymentsResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    fn get_headers(
+        &self,
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        match req
+            .request
+            .connector_transaction_id
+            .get_connector_transaction_id()
+        {
+            Ok(transaction_id) => Ok(format!(
+                "{}/payments/{}",
+                self.base_url(connectors),
+                transaction_id
+            )),
+            Err(_) => Err(error_stack::report!(
+                ConnectorError::MissingConnectorTransactionID
+            )),
+        }
+    }
+
+    fn build_request(
+        &self,
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Get)
+                .url(&PaymentsSyncType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(PaymentsSyncType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PaymentsSyncRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PaymentsSyncRouterData, ConnectorError> {
+        let response: transformers::PaymentsResponse = res
+            .response
+            .parse_struct("dummyconnector PaymentsSyncResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+    fn get_headers(
+        &self,
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        _req: &PaymentsCaptureRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_url method".to_string()).into())
+    }
+
+    fn get_request_body(
+        &self,
+        _req: &PaymentsCaptureRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_request_body method".to_string()).into())
+    }
+
+    fn build_request(
+        &self,
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&PaymentsCaptureType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PaymentsCaptureRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PaymentsCaptureRouterData, ConnectorError> {
+        let response: transformers::PaymentsResponse = res
+            .response
+            .parse_struct("transformers PaymentsCaptureResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData>
+    for DummyConnector<T>
+{
+}
+
+impl<const T: u8> ConnectorIntegration<Execute, RefundsData, RefundsResponseData>
+    for DummyConnector<T>
+{
+    fn get_headers(
+        &self,
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}/{}/refund",
+            self.base_url(connectors),
+            req.request.connector_transaction_id
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &RefundsRouterData<Execute>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let connector_req = transformers::DummyConnectorRefundRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(connector_req)))
+    }
+
+    fn build_request(
+        &self,
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&RefundExecuteType::get_url(self, req, connectors)?)
+            .attach_default_headers()
+            .headers(RefundExecuteType::get_headers(self, req, connectors)?)
+            .set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
+            .build();
+        Ok(Some(request))
+    }
+
+    fn handle_response(
+        &self,
+        data: &RefundsRouterData<Execute>,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<RefundsRouterData<Execute>, ConnectorError> {
+        let response: transformers::RefundResponse = res
+            .response
+            .parse_struct("transformers RefundResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl<const T: u8> ConnectorIntegration<RSync, RefundsData, RefundsResponseData>
+    for DummyConnector<T>
+{
+    fn get_headers(
+        &self,
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        let refund_id = req.request.get_connector_refund_id()?;
+        Ok(format!(
+            "{}/refunds/{}",
+            self.base_url(connectors),
+            refund_id
+        ))
+    }
+
+    fn build_request(
+        &self,
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Get)
+                .url(&RefundSyncType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(RefundSyncType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &RefundSyncRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<RefundSyncRouterData, ConnectorError> {
+        let response: transformers::RefundResponse = res
+            .response
+            .parse_struct("transformers RefundSyncResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[async_trait::async_trait]
+impl<const T: u8> IncomingWebhook for DummyConnector<T> {
+    fn get_webhook_object_reference_id(
+        &self,
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<ObjectReferenceId, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
+    }
+
+    fn get_webhook_event_type(
+        &self,
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
+        Ok(IncomingWebhookEvent::EventNotSupported)
+    }
+
+    fn get_webhook_resource_object(
+        &self,
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
+    }
+}
+
+impl<const T: u8> ConnectorSpecifications for DummyConnector<T> {}
diff --git a/crates/router/src/connector/dummyconnector/transformers.rs b/crates/hyperswitch_connectors/src/connectors/dummyconnector/transformers.rs
similarity index 54%
rename from crates/router/src/connector/dummyconnector/transformers.rs
rename to crates/hyperswitch_connectors/src/connectors/dummyconnector/transformers.rs
index 392a2249d92..d0662e8612a 100644
--- a/crates/router/src/connector/dummyconnector/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/dummyconnector/transformers.rs
@@ -1,14 +1,23 @@
-use common_utils::pii;
-use diesel_models::enums::Currency;
+use common_enums::{AttemptStatus, Currency, RefundStatus};
+use common_utils::{pii, request::Method};
+use hyperswitch_domain_models::{
+    payment_method_data::{
+        Card, PayLaterData, PaymentMethodData, UpiCollectData, UpiData, WalletData,
+    },
+    router_data::{ConnectorAuthType, RouterData},
+    router_flow_types::{Execute, RSync},
+    router_request_types::ResponseId,
+    router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
+    types::{PaymentsAuthorizeRouterData, RefundsRouterData},
+};
+use hyperswitch_interfaces::errors::ConnectorError;
 use masking::Secret;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
 use crate::{
-    connector::utils::RouterData,
-    core::errors,
-    services,
-    types::{self, api, domain, storage::enums},
+    types::{RefundsResponseRouterData, ResponseRouterData},
+    utils::RouterData as _,
 };
 
 #[derive(Debug, Serialize, strum::Display, Eq, PartialEq)]
@@ -63,14 +72,14 @@ impl From<u8> for DummyConnectors {
 pub struct DummyConnectorPaymentsRequest<const T: u8> {
     amount: i64,
     currency: Currency,
-    payment_method_data: PaymentMethodData,
+    payment_method_data: DummyPaymentMethodData,
     return_url: Option<String>,
     connector: DummyConnectors,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
 #[serde(rename_all = "lowercase")]
-pub enum PaymentMethodData {
+pub enum DummyPaymentMethodData {
     Card(DummyConnectorCard),
     Wallet(DummyConnectorWallet),
     PayLater(DummyConnectorPayLater),
@@ -88,15 +97,13 @@ pub struct DummyConnectorUpiCollect {
     vpa_id: Secret<String, pii::UpiVpaMaskingStrategy>,
 }
 
-impl TryFrom<domain::UpiCollectData> for DummyConnectorUpi {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(value: domain::UpiCollectData) -> Result<Self, Self::Error> {
+impl TryFrom<UpiCollectData> for DummyConnectorUpi {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(value: UpiCollectData) -> Result<Self, Self::Error> {
         Ok(Self::UpiCollect(DummyConnectorUpiCollect {
-            vpa_id: value
-                .vpa_id
-                .ok_or(errors::ConnectorError::MissingRequiredField {
-                    field_name: "vpa_id",
-                })?,
+            vpa_id: value.vpa_id.ok_or(ConnectorError::MissingRequiredField {
+                field_name: "vpa_id",
+            })?,
         }))
     }
 }
@@ -110,10 +117,10 @@ pub struct DummyConnectorCard {
     cvc: Secret<String>,
 }
 
-impl TryFrom<(domain::Card, Option<Secret<String>>)> for DummyConnectorCard {
-    type Error = error_stack::Report<errors::ConnectorError>;
+impl TryFrom<(Card, Option<Secret<String>>)> for DummyConnectorCard {
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        (value, card_holder_name): (domain::Card, Option<Secret<String>>),
+        (value, card_holder_name): (Card, Option<Secret<String>>),
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             name: card_holder_name.unwrap_or(Secret::new("".to_string())),
@@ -135,17 +142,17 @@ pub enum DummyConnectorWallet {
     AliPayHK,
 }
 
-impl TryFrom<domain::WalletData> for DummyConnectorWallet {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(value: domain::WalletData) -> Result<Self, Self::Error> {
+impl TryFrom<WalletData> for DummyConnectorWallet {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(value: WalletData) -> Result<Self, Self::Error> {
         match value {
-            domain::WalletData::GooglePayRedirect(_) => Ok(Self::GooglePay),
-            domain::WalletData::PaypalRedirect(_) => Ok(Self::Paypal),
-            domain::WalletData::WeChatPayRedirect(_) => Ok(Self::WeChatPay),
-            domain::WalletData::MbWayRedirect(_) => Ok(Self::MbWay),
-            domain::WalletData::AliPayRedirect(_) => Ok(Self::AliPay),
-            domain::WalletData::AliPayHkRedirect(_) => Ok(Self::AliPayHK),
-            _ => Err(errors::ConnectorError::NotImplemented("Dummy wallet".to_string()).into()),
+            WalletData::GooglePayRedirect(_) => Ok(Self::GooglePay),
+            WalletData::PaypalRedirect(_) => Ok(Self::Paypal),
+            WalletData::WeChatPayRedirect(_) => Ok(Self::WeChatPay),
+            WalletData::MbWayRedirect(_) => Ok(Self::MbWay),
+            WalletData::AliPayRedirect(_) => Ok(Self::AliPay),
+            WalletData::AliPayHkRedirect(_) => Ok(Self::AliPayHK),
+            _ => Err(ConnectorError::NotImplemented("Dummy wallet".to_string()).into()),
         }
     }
 }
@@ -157,52 +164,45 @@ pub enum DummyConnectorPayLater {
     AfterPayClearPay,
 }
 
-impl TryFrom<domain::payments::PayLaterData> for DummyConnectorPayLater {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(value: domain::payments::PayLaterData) -> Result<Self, Self::Error> {
+impl TryFrom<PayLaterData> for DummyConnectorPayLater {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(value: PayLaterData) -> Result<Self, Self::Error> {
         match value {
-            domain::payments::PayLaterData::KlarnaRedirect { .. } => Ok(Self::Klarna),
-            domain::payments::PayLaterData::AffirmRedirect {} => Ok(Self::Affirm),
-            domain::payments::PayLaterData::AfterpayClearpayRedirect { .. } => {
-                Ok(Self::AfterPayClearPay)
-            }
-            _ => Err(errors::ConnectorError::NotImplemented("Dummy pay later".to_string()).into()),
+            PayLaterData::KlarnaRedirect { .. } => Ok(Self::Klarna),
+            PayLaterData::AffirmRedirect {} => Ok(Self::Affirm),
+            PayLaterData::AfterpayClearpayRedirect { .. } => Ok(Self::AfterPayClearPay),
+            _ => Err(ConnectorError::NotImplemented("Dummy pay later".to_string()).into()),
         }
     }
 }
 
-impl<const T: u8> TryFrom<&types::PaymentsAuthorizeRouterData>
-    for DummyConnectorPaymentsRequest<T>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
-        let payment_method_data: Result<PaymentMethodData, Self::Error> = match item
-            .request
-            .payment_method_data
-        {
-            domain::PaymentMethodData::Card(ref req_card) => {
-                let card_holder_name = item.get_optional_billing_full_name();
-                Ok(PaymentMethodData::Card(DummyConnectorCard::try_from((
-                    req_card.clone(),
-                    card_holder_name,
-                ))?))
-            }
-            domain::PaymentMethodData::Upi(ref req_upi_data) => match req_upi_data {
-                domain::UpiData::UpiCollect(data) => Ok(PaymentMethodData::Upi(
-                    DummyConnectorUpi::try_from(data.clone())?,
-                )),
-                domain::UpiData::UpiIntent(_) => {
-                    Err(errors::ConnectorError::NotImplemented("UPI Intent".to_string()).into())
+impl<const T: u8> TryFrom<&PaymentsAuthorizeRouterData> for DummyConnectorPaymentsRequest<T> {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
+        let payment_method_data: Result<DummyPaymentMethodData, Self::Error> =
+            match item.request.payment_method_data {
+                PaymentMethodData::Card(ref req_card) => {
+                    let card_holder_name = item.get_optional_billing_full_name();
+                    Ok(DummyPaymentMethodData::Card(DummyConnectorCard::try_from(
+                        (req_card.clone(), card_holder_name),
+                    )?))
                 }
-            },
-            domain::PaymentMethodData::Wallet(ref wallet_data) => {
-                Ok(PaymentMethodData::Wallet(wallet_data.clone().try_into()?))
-            }
-            domain::PaymentMethodData::PayLater(ref pay_later_data) => Ok(
-                PaymentMethodData::PayLater(pay_later_data.clone().try_into()?),
-            ),
-            _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
-        };
+                PaymentMethodData::Upi(ref req_upi_data) => match req_upi_data {
+                    UpiData::UpiCollect(data) => Ok(DummyPaymentMethodData::Upi(
+                        DummyConnectorUpi::try_from(data.clone())?,
+                    )),
+                    UpiData::UpiIntent(_) => {
+                        Err(ConnectorError::NotImplemented("UPI Intent".to_string()).into())
+                    }
+                },
+                PaymentMethodData::Wallet(ref wallet_data) => Ok(DummyPaymentMethodData::Wallet(
+                    wallet_data.clone().try_into()?,
+                )),
+                PaymentMethodData::PayLater(ref pay_later_data) => Ok(
+                    DummyPaymentMethodData::PayLater(pay_later_data.clone().try_into()?),
+                ),
+                _ => Err(ConnectorError::NotImplemented("Payment methods".to_string()).into()),
+            };
         Ok(Self {
             amount: item.request.amount,
             currency: item.request.currency,
@@ -218,14 +218,14 @@ pub struct DummyConnectorAuthType {
     pub(super) api_key: Secret<String>,
 }
 
-impl TryFrom<&types::ConnectorAuthType> for DummyConnectorAuthType {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
+impl TryFrom<&ConnectorAuthType> for DummyConnectorAuthType {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
         match auth_type {
-            types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
+            ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
                 api_key: api_key.to_owned(),
             }),
-            _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
+            _ => Err(ConnectorError::FailedToObtainAuthType.into()),
         }
     }
 }
@@ -240,7 +240,7 @@ pub enum DummyConnectorPaymentStatus {
     Processing,
 }
 
-impl From<DummyConnectorPaymentStatus> for enums::AttemptStatus {
+impl From<DummyConnectorPaymentStatus> for AttemptStatus {
     fn from(item: DummyConnectorPaymentStatus) -> Self {
         match item {
             DummyConnectorPaymentStatus::Succeeded => Self::Charged,
@@ -275,24 +275,22 @@ pub enum DummyConnectorUpiType {
     UpiCollect,
 }
 
-impl<F, T> TryFrom<types::ResponseRouterData<F, PaymentsResponse, T, types::PaymentsResponseData>>
-    for types::RouterData<F, T, types::PaymentsResponseData>
+impl<F, T> TryFrom<ResponseRouterData<F, PaymentsResponse, T, PaymentsResponseData>>
+    for RouterData<F, T, PaymentsResponseData>
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: types::ResponseRouterData<F, PaymentsResponse, T, types::PaymentsResponseData>,
+        item: ResponseRouterData<F, PaymentsResponse, T, PaymentsResponseData>,
     ) -> Result<Self, Self::Error> {
         let redirection_data = item
             .response
             .next_action
             .and_then(|redirection_data| redirection_data.get_url())
-            .map(|redirection_url| {
-                services::RedirectForm::from((redirection_url, services::Method::Get))
-            });
+            .map(|redirection_url| RedirectForm::from((redirection_url, Method::Get)));
         Ok(Self {
-            status: enums::AttemptStatus::from(item.response.status),
-            response: Ok(types::PaymentsResponseData::TransactionResponse {
-                resource_id: types::ResponseId::ConnectorTransactionId(item.response.id),
+            status: AttemptStatus::from(item.response.status),
+            response: Ok(PaymentsResponseData::TransactionResponse {
+                resource_id: ResponseId::ConnectorTransactionId(item.response.id),
                 redirection_data: Box::new(redirection_data),
                 mandate_reference: Box::new(None),
                 connector_metadata: None,
@@ -327,9 +325,9 @@ pub struct DummyConnectorRefundRequest {
     pub amount: i64,
 }
 
-impl<F> TryFrom<&types::RefundsRouterData<F>> for DummyConnectorRefundRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &types::RefundsRouterData<F>) -> Result<Self, Self::Error> {
+impl<F> TryFrom<&RefundsRouterData<F>> for DummyConnectorRefundRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {
         Ok(Self {
             amount: item.request.refund_amount,
         })
@@ -341,19 +339,19 @@ impl<F> TryFrom<&types::RefundsRouterData<F>> for DummyConnectorRefundRequest {
 #[allow(dead_code)]
 #[derive(Debug, Serialize, Default, Deserialize, Clone)]
 #[serde(rename_all = "lowercase")]
-pub enum RefundStatus {
+pub enum DummyRefundStatus {
     Succeeded,
     Failed,
     #[default]
     Processing,
 }
 
-impl From<RefundStatus> for enums::RefundStatus {
-    fn from(item: RefundStatus) -> Self {
+impl From<DummyRefundStatus> for RefundStatus {
+    fn from(item: DummyRefundStatus) -> Self {
         match item {
-            RefundStatus::Succeeded => Self::Success,
-            RefundStatus::Failed => Self::Failure,
-            RefundStatus::Processing => Self::Pending,
+            DummyRefundStatus::Succeeded => Self::Success,
+            DummyRefundStatus::Failed => Self::Failure,
+            DummyRefundStatus::Processing => Self::Pending,
             //TODO: Review mapping
         }
     }
@@ -362,41 +360,37 @@ impl From<RefundStatus> for enums::RefundStatus {
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct RefundResponse {
     id: String,
-    status: RefundStatus,
+    status: DummyRefundStatus,
     currency: Currency,
     created: String,
     payment_amount: i64,
     refund_amount: i64,
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::Execute, RefundResponse>>
-    for types::RefundsRouterData<api::Execute>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
+impl TryFrom<RefundsResponseRouterData<Execute, RefundResponse>> for RefundsRouterData<Execute> {
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: types::RefundsResponseRouterData<api::Execute, RefundResponse>,
+        item: RefundsResponseRouterData<Execute, RefundResponse>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
+            response: Ok(RefundsResponseData {
                 connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
+                refund_status: RefundStatus::from(item.response.status),
             }),
             ..item.data
         })
     }
 }
 
-impl TryFrom<types::RefundsResponseRouterData<api::RSync, RefundResponse>>
-    for types::RefundsRouterData<api::RSync>
-{
-    type Error = error_stack::Report<errors::ConnectorError>;
+impl TryFrom<RefundsResponseRouterData<RSync, RefundResponse>> for RefundsRouterData<RSync> {
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: types::RefundsResponseRouterData<api::RSync, RefundResponse>,
+        item: RefundsResponseRouterData<RSync, RefundResponse>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(types::RefundsResponseData {
+            response: Ok(RefundsResponseData {
                 connector_refund_id: item.response.id.to_string(),
-                refund_status: enums::RefundStatus::from(item.response.status),
+                refund_status: RefundStatus::from(item.response.status),
             }),
             ..item.data
         })
diff --git a/crates/hyperswitch_connectors/src/default_implementations.rs b/crates/hyperswitch_connectors/src/default_implementations.rs
index 7c46a8ffc05..e78067e24e3 100644
--- a/crates/hyperswitch_connectors/src/default_implementations.rs
+++ b/crates/hyperswitch_connectors/src/default_implementations.rs
@@ -1,9 +1,29 @@
+#[cfg(feature = "dummy_connector")]
+use common_enums::{CallConnectorAction, PaymentAction};
 // impl api::PaymentIncrementalAuthorization for Helcim {}
 // impl api::ConnectorCustomer for Helcim {}
 // impl api::PaymentsPreProcessing for Helcim {}
 // impl api::PaymentReject for Helcim {}
 // impl api::PaymentApprove for Helcim {}
 use common_utils::errors::CustomResult;
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+use hyperswitch_domain_models::router_flow_types::{
+    BillingConnectorInvoiceSync, BillingConnectorPaymentsSync, RecoveryRecordBack,
+};
+#[cfg(feature = "dummy_connector")]
+use hyperswitch_domain_models::router_request_types::authentication::{
+    ConnectorAuthenticationRequestData, ConnectorPostAuthenticationRequestData, PreAuthNRequestData,
+};
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+use hyperswitch_domain_models::router_request_types::revenue_recovery::{
+    BillingConnectorInvoiceSyncRequest, BillingConnectorPaymentsSyncRequest,
+    RevenueRecoveryRecordBackRequest,
+};
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+use hyperswitch_domain_models::router_response_types::revenue_recovery::{
+    BillingConnectorInvoiceSyncResponse, BillingConnectorPaymentsSyncResponse,
+    RevenueRecoveryRecordBackResponse,
+};
 #[cfg(feature = "frm")]
 use hyperswitch_domain_models::{
     router_flow_types::fraud_check::{Checkout, Fulfillment, RecordReturn, Sale, Transaction},
@@ -22,12 +42,6 @@ use hyperswitch_domain_models::{
     router_request_types::PayoutsData,
     router_response_types::PayoutsResponseData,
 };
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-use hyperswitch_domain_models::{
-    router_flow_types::revenue_recovery as recovery_router_flows,
-    router_request_types::revenue_recovery as recovery_request,
-    router_response_types::revenue_recovery as recovery_response,
-};
 use hyperswitch_domain_models::{
     router_flow_types::{
         authentication::{
@@ -79,6 +93,12 @@ use hyperswitch_interfaces::api::payouts::{
 };
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
 use hyperswitch_interfaces::api::revenue_recovery as recovery_traits;
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+use hyperswitch_interfaces::api::revenue_recovery::{
+    BillingConnectorInvoiceSyncIntegration, BillingConnectorPaymentsSyncIntegration,
+};
+#[cfg(feature = "dummy_connector")]
+use hyperswitch_interfaces::api::ConnectorVerifyWebhookSource;
 use hyperswitch_interfaces::{
     api::{
         self,
@@ -5144,9 +5164,9 @@ macro_rules! default_imp_for_billing_connector_payment_sync {
         $(  impl recovery_traits::BillingConnectorPaymentsSyncIntegration for $path::$connector {}
             impl
                 ConnectorIntegration<
-                recovery_router_flows::BillingConnectorPaymentsSync,
-                recovery_request::BillingConnectorPaymentsSyncRequest,
-                recovery_response::BillingConnectorPaymentsSyncResponse
+                BillingConnectorPaymentsSync,
+                BillingConnectorPaymentsSyncRequest,
+                BillingConnectorPaymentsSyncResponse
             > for $path::$connector
             {}
         )*
@@ -5267,9 +5287,9 @@ macro_rules! default_imp_for_revenue_recovery_record_back {
         $( impl recovery_traits::RevenueRecoveryRecordBack for $path::$connector {}
             impl
             ConnectorIntegration<
-            recovery_router_flows::RecoveryRecordBack,
-            recovery_request::RevenueRecoveryRecordBackRequest,
-            recovery_response::RevenueRecoveryRecordBackResponse
+            RecoveryRecordBack,
+            RevenueRecoveryRecordBackRequest,
+            RevenueRecoveryRecordBackResponse
             > for $path::$connector
             {}
         )*
@@ -5389,9 +5409,9 @@ macro_rules! default_imp_for_billing_connector_invoice_sync {
         $( impl recovery_traits::BillingConnectorInvoiceSyncIntegration for $path::$connector {}
             impl
             ConnectorIntegration<
-            recovery_router_flows::BillingConnectorInvoiceSync,
-            recovery_request::BillingConnectorInvoiceSyncRequest,
-            recovery_response::BillingConnectorInvoiceSyncResponse
+            BillingConnectorInvoiceSync,
+            BillingConnectorInvoiceSyncRequest,
+            BillingConnectorInvoiceSyncResponse
             > for $path::$connector
             {}
         )*
@@ -6108,3 +6128,506 @@ default_imp_for_external_vault_create!(
     connectors::Zen,
     connectors::Zsl
 );
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentsCompleteAuthorize for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorVerifyWebhookSource for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        VerifyWebhookSource,
+        VerifyWebhookSourceRequestData,
+        VerifyWebhookSourceResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorCustomer for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<CreateConnectorCustomer, ConnectorCustomerData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorRedirectResponse for connectors::DummyConnector<T> {
+    fn get_flow_type(
+        &self,
+        _query_params: &str,
+        _json_payload: Option<serde_json::Value>,
+        _action: PaymentAction,
+    ) -> CustomResult<CallConnectorAction, ConnectorError> {
+        Ok(CallConnectorAction::Trigger)
+    }
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorTransactionId for connectors::DummyConnector<T> {}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> Dispute for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> AcceptDispute for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Accept, AcceptDisputeRequestData, AcceptDisputeResponse>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> FileUpload for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UploadFile for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Upload, UploadFileRequestData, UploadFileResponse>
+    for connectors::DummyConnector<T>
+{
+}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> RetrieveFile for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Retrieve, RetrieveFileRequestData, RetrieveFileResponse>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> SubmitEvidence for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Evidence, SubmitEvidenceRequestData, SubmitEvidenceResponse>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> DefendDispute for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Defend, DefendDisputeRequestData, DefendDisputeResponse>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentsPreProcessing for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<PreProcessing, PaymentsPreProcessingData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentsPostProcessing for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<PostProcessing, PaymentsPostProcessingData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> api::Payouts for connectors::DummyConnector<T> {}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutCreate for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoCreate, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutSync for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoSync, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutEligibility for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoEligibility, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutFulfill for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoFulfill, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutCancel for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoCancel, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutQuote for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoQuote, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutRecipient for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoRecipient, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PayoutRecipientAccount for connectors::DummyConnector<T> {}
+#[cfg(feature = "payouts")]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<PoRecipientAccount, PayoutsData, PayoutsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentApprove for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Approve, PaymentsApproveData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentReject for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<Reject, PaymentsRejectData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheck for connectors::DummyConnector<T> {}
+
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheckSale for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> ConnectorIntegration<Sale, FraudCheckSaleData, FraudCheckResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheckCheckout for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> ConnectorIntegration<Checkout, FraudCheckCheckoutData, FraudCheckResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheckTransaction for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8>
+    ConnectorIntegration<Transaction, FraudCheckTransactionData, FraudCheckResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheckFulfillment for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8>
+    ConnectorIntegration<Fulfillment, FraudCheckFulfillmentData, FraudCheckResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8> FraudCheckRecordReturn for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "frm", feature = "dummy_connector"))]
+impl<const T: u8>
+    ConnectorIntegration<RecordReturn, FraudCheckRecordReturnData, FraudCheckResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentIncrementalAuthorization for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        IncrementalAuthorization,
+        PaymentsIncrementalAuthorizationData,
+        PaymentsResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorMandateRevoke for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<MandateRevoke, MandateRevokeRequestData, MandateRevokeResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorPreAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorPreAuthenticationVersionCall for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorPostAuthentication for connectors::DummyConnector<T> {}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        Authentication,
+        ConnectorAuthenticationRequestData,
+        AuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<PreAuthentication, PreAuthNRequestData, AuthenticationResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        PreAuthenticationVersionCall,
+        PreAuthNRequestData,
+        AuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        PostAuthentication,
+        ConnectorPostAuthenticationRequestData,
+        AuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentAuthorizeSessionToken for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<AuthorizeSessionToken, AuthorizeSessionTokenData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> TaxCalculation for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<CalculateTax, PaymentsTaxCalculationData, TaxCalculationResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentSessionUpdate for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<SdkSessionUpdate, SdkPaymentsSessionUpdateData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentPostSessionTokens for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<PostSessionTokens, PaymentsPostSessionTokensData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentsCreateOrder for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<CreateOrder, CreateOrderRequestData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> PaymentUpdateMetadata for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<UpdateMetadata, PaymentsUpdateMetadataData, PaymentsResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UasPreAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UnifiedAuthenticationService for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        PreAuthenticate,
+        UasPreAuthenticationRequestData,
+        UasAuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UasPostAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        PostAuthenticate,
+        UasPostAuthenticationRequestData,
+        UasAuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UasAuthenticationConfirmation for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        AuthenticationConfirmation,
+        UasConfirmationRequestData,
+        UasAuthenticationResponseData,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> UasAuthentication for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<Authenticate, UasAuthenticationRequestData, UasAuthenticationResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> RevenueRecovery for connectors::DummyConnector<T> {}
+
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> api::revenue_recovery::BillingConnectorPaymentsSyncIntegration
+    for connectors::DummyConnector<T>
+{
+}
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        BillingConnectorPaymentsSync,
+        BillingConnectorPaymentsSyncRequest,
+        BillingConnectorPaymentsSyncResponse,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> api::revenue_recovery::RevenueRecoveryRecordBack
+    for connectors::DummyConnector<T>
+{
+}
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        RecoveryRecordBack,
+        RevenueRecoveryRecordBackRequest,
+        RevenueRecoveryRecordBackResponse,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> BillingConnectorInvoiceSyncIntegration for connectors::DummyConnector<T> {}
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<
+        BillingConnectorInvoiceSync,
+        BillingConnectorInvoiceSyncRequest,
+        BillingConnectorInvoiceSyncResponse,
+    > for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalVault for connectors::DummyConnector<T> {}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalVaultInsert for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<ExternalVaultInsertFlow, VaultRequestData, VaultResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalVaultRetrieve for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8>
+    ConnectorIntegration<ExternalVaultRetrieveFlow, VaultRequestData, VaultResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalVaultDelete for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<ExternalVaultDeleteFlow, VaultRequestData, VaultResponseData>
+    for connectors::DummyConnector<T>
+{
+}
+
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ExternalVaultCreate for connectors::DummyConnector<T> {}
+#[cfg(feature = "dummy_connector")]
+impl<const T: u8> ConnectorIntegration<ExternalVaultCreateFlow, VaultRequestData, VaultResponseData>
+    for connectors::DummyConnector<T>
+{
+}
diff --git a/crates/router/Cargo.toml b/crates/router/Cargo.toml
index 82ea4945942..e0ae9fe8782 100644
--- a/crates/router/Cargo.toml
+++ b/crates/router/Cargo.toml
@@ -26,7 +26,7 @@ oltp = ["storage_impl/oltp"]
 kv_store = ["scheduler/kv_store"]
 accounts_cache = []
 vergen = ["router_env/vergen"]
-dummy_connector = ["api_models/dummy_connector", "euclid/dummy_connector", "hyperswitch_interfaces/dummy_connector", "kgraph_utils/dummy_connector", "payment_methods/dummy_connector", "hyperswitch_domain_models/dummy_connector"]
+dummy_connector = ["api_models/dummy_connector", "euclid/dummy_connector", "hyperswitch_interfaces/dummy_connector", "kgraph_utils/dummy_connector", "payment_methods/dummy_connector", "hyperswitch_domain_models/dummy_connector","hyperswitch_connectors/dummy_connector"]
 external_access_dc = ["dummy_connector"]
 detailed_errors = ["api_models/detailed_errors", "error-stack/serde"]
 payouts = ["api_models/payouts", "common_enums/payouts", "hyperswitch_connectors/payouts", "hyperswitch_domain_models/payouts", "storage_impl/payouts", "payment_methods/payouts"]
diff --git a/crates/router/src/connector.rs b/crates/router/src/connector.rs
index a5af15325fc..4a6ae9b6680 100644
--- a/crates/router/src/connector.rs
+++ b/crates/router/src/connector.rs
@@ -1,7 +1,7 @@
-#[cfg(feature = "dummy_connector")]
-pub mod dummyconnector;
 pub mod utils;
 
+#[cfg(feature = "dummy_connector")]
+pub use hyperswitch_connectors::connectors::DummyConnector;
 pub use hyperswitch_connectors::connectors::{
     aci, aci::Aci, adyen, adyen::Adyen, adyenplatform, adyenplatform::Adyenplatform, airwallex,
     airwallex::Airwallex, amazonpay, amazonpay::Amazonpay, archipel, archipel::Archipel,
@@ -41,6 +41,3 @@ pub use hyperswitch_connectors::connectors::{
     worldpayvantiv::Worldpayvantiv, worldpayxml, worldpayxml::Worldpayxml, xendit, xendit::Xendit,
     zen, zen::Zen, zsl, zsl::Zsl,
 };
-
-#[cfg(feature = "dummy_connector")]
-pub use self::dummyconnector::DummyConnector;
diff --git a/crates/router/src/connector/dummyconnector.rs b/crates/router/src/connector/dummyconnector.rs
deleted file mode 100644
index ea63a27102c..00000000000
--- a/crates/router/src/connector/dummyconnector.rs
+++ /dev/null
@@ -1,630 +0,0 @@
-pub mod transformers;
-
-use std::fmt::Debug;
-
-use common_utils::{consts as common_consts, request::RequestContent};
-use diesel_models::enums;
-use error_stack::{report, ResultExt};
-
-use super::utils::RefundsRequestData;
-use crate::{
-    configs::settings,
-    connector::utils as connector_utils,
-    core::errors::{self, CustomResult},
-    events::connector_api_logs::ConnectorEvent,
-    headers,
-    services::{
-        self,
-        request::{self, Mask},
-        ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
-    },
-    types::{
-        self,
-        api::{self, ConnectorCommon, ConnectorCommonExt},
-        ErrorResponse, Response,
-    },
-    utils::BytesExt,
-};
-
-#[derive(Debug, Clone)]
-pub struct DummyConnector<const T: u8>;
-
-impl<const T: u8> api::Payment for DummyConnector<T> {}
-impl<const T: u8> api::PaymentSession for DummyConnector<T> {}
-impl<const T: u8> api::ConnectorAccessToken for DummyConnector<T> {}
-impl<const T: u8> api::MandateSetup for DummyConnector<T> {}
-impl<const T: u8> api::PaymentAuthorize for DummyConnector<T> {}
-impl<const T: u8> api::PaymentSync for DummyConnector<T> {}
-impl<const T: u8> api::PaymentCapture for DummyConnector<T> {}
-impl<const T: u8> api::PaymentVoid for DummyConnector<T> {}
-impl<const T: u8> api::Refund for DummyConnector<T> {}
-impl<const T: u8> api::RefundExecute for DummyConnector<T> {}
-impl<const T: u8> api::RefundSync for DummyConnector<T> {}
-impl<const T: u8> api::PaymentToken for DummyConnector<T> {}
-
-impl<const T: u8>
-    ConnectorIntegration<
-        api::PaymentMethodToken,
-        types::PaymentMethodTokenizationData,
-        types::PaymentsResponseData,
-    > for DummyConnector<T>
-{
-    // Not Implemented (R)
-}
-
-impl<const T: u8, Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response>
-    for DummyConnector<T>
-where
-    Self: ConnectorIntegration<Flow, Request, Response>,
-{
-    fn build_headers(
-        &self,
-        req: &types::RouterData<Flow, Request, Response>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let mut header = vec![
-            (
-                headers::CONTENT_TYPE.to_string(),
-                types::PaymentsAuthorizeType::get_content_type(self)
-                    .to_string()
-                    .into(),
-            ),
-            (
-                common_consts::TENANT_HEADER.to_string(),
-                req.tenant_id.get_string_repr().to_string().into(),
-            ),
-        ];
-        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-        header.append(&mut api_key);
-        Ok(header)
-    }
-}
-
-impl<const T: u8> ConnectorCommon for DummyConnector<T> {
-    fn id(&self) -> &'static str {
-        Into::<transformers::DummyConnectors>::into(T).get_dummy_connector_id()
-    }
-
-    fn common_get_content_type(&self) -> &'static str {
-        "application/json"
-    }
-
-    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
-        connectors.dummyconnector.base_url.as_ref()
-    }
-
-    fn get_auth_header(
-        &self,
-        auth_type: &types::ConnectorAuthType,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let auth = transformers::DummyConnectorAuthType::try_from(auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-        Ok(vec![(
-            headers::AUTHORIZATION.to_string(),
-            auth.api_key.into_masked(),
-        )])
-    }
-
-    fn build_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        let response: transformers::DummyConnectorErrorResponse = res
-            .response
-            .parse_struct("DummyConnectorErrorResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-
-        event_builder.map(|i| i.set_error_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-
-        Ok(ErrorResponse {
-            status_code: res.status_code,
-            code: response.error.code,
-            message: response.error.message,
-            reason: response.error.reason,
-            attempt_status: None,
-            connector_transaction_id: None,
-            network_advice_code: None,
-            network_decline_code: None,
-            network_error_message: None,
-        })
-    }
-}
-
-impl<const T: u8> ConnectorValidation for DummyConnector<T> {
-    fn validate_connector_against_payment_request(
-        &self,
-        capture_method: Option<enums::CaptureMethod>,
-        _payment_method: enums::PaymentMethod,
-        _pmt: Option<enums::PaymentMethodType>,
-    ) -> CustomResult<(), errors::ConnectorError> {
-        let capture_method = capture_method.unwrap_or_default();
-        match capture_method {
-            enums::CaptureMethod::Automatic
-            | enums::CaptureMethod::Manual
-            | enums::CaptureMethod::SequentialAutomatic => Ok(()),
-            enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => Err(
-                connector_utils::construct_not_supported_error_report(capture_method, self.id()),
-            ),
-        }
-    }
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
-    for DummyConnector<T>
-{
-    //TODO: implement sessions flow
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
-    for DummyConnector<T>
-{
-}
-
-impl<const T: u8>
-    ConnectorIntegration<
-        api::SetupMandate,
-        types::SetupMandateRequestData,
-        types::PaymentsResponseData,
-    > for DummyConnector<T>
-{
-    fn build_request(
-        &self,
-        _req: &types::RouterData<
-            api::SetupMandate,
-            types::SetupMandateRequestData,
-            types::PaymentsResponseData,
-        >,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented(
-            "Setup Mandate flow for DummyConnector".to_string(),
-        )
-        .into())
-    }
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
-    for DummyConnector<T>
-{
-    fn get_headers(
-        &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        self.build_headers(req, connectors)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        self.common_get_content_type()
-    }
-
-    fn get_url(
-        &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        match req.payment_method {
-            enums::PaymentMethod::Card
-            | enums::PaymentMethod::Upi
-            | enums::PaymentMethod::Wallet
-            | enums::PaymentMethod::PayLater => {
-                Ok(format!("{}/payment", self.base_url(connectors)))
-            }
-            _ => Err(error_stack::report!(errors::ConnectorError::NotSupported {
-                message: format!("The payment method {} is not supported", req.payment_method),
-                connector: Into::<transformers::DummyConnectors>::into(T).get_dummy_connector_id(),
-            })),
-        }
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_req = transformers::DummyConnectorPaymentsRequest::<T>::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(connector_req)))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&types::PaymentsAuthorizeType::get_url(
-                    self, req, connectors,
-                )?)
-                .attach_default_headers()
-                .headers(types::PaymentsAuthorizeType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(types::PaymentsAuthorizeType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::PaymentsAuthorizeRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
-        let response: transformers::PaymentsResponse = res
-            .response
-            .parse_struct("DummyConnector PaymentsResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
-    for DummyConnector<T>
-{
-    fn get_headers(
-        &self,
-        req: &types::PaymentsSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        self.build_headers(req, connectors)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        self.common_get_content_type()
-    }
-
-    fn get_url(
-        &self,
-        req: &types::PaymentsSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        match req
-            .request
-            .connector_transaction_id
-            .get_connector_transaction_id()
-        {
-            Ok(transaction_id) => Ok(format!(
-                "{}/payments/{}",
-                self.base_url(connectors),
-                transaction_id
-            )),
-            Err(_) => Err(error_stack::report!(
-                errors::ConnectorError::MissingConnectorTransactionID
-            )),
-        }
-    }
-
-    fn build_request(
-        &self,
-        req: &types::PaymentsSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Get)
-                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
-                .attach_default_headers()
-                .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::PaymentsSyncRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
-        let response: transformers::PaymentsResponse = res
-            .response
-            .parse_struct("dummyconnector PaymentsSyncResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
-    for DummyConnector<T>
-{
-    fn get_headers(
-        &self,
-        req: &types::PaymentsCaptureRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        self.build_headers(req, connectors)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        self.common_get_content_type()
-    }
-
-    fn get_url(
-        &self,
-        _req: &types::PaymentsCaptureRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
-    }
-
-    fn get_request_body(
-        &self,
-        _req: &types::PaymentsCaptureRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_request_body method".to_string()).into())
-    }
-
-    fn build_request(
-        &self,
-        req: &types::PaymentsCaptureRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
-                .attach_default_headers()
-                .headers(types::PaymentsCaptureType::get_headers(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::PaymentsCaptureRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError> {
-        let response: transformers::PaymentsResponse = res
-            .response
-            .parse_struct("transformers PaymentsCaptureResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl<const T: u8>
-    ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
-    for DummyConnector<T>
-{
-}
-
-impl<const T: u8> ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
-    for DummyConnector<T>
-{
-    fn get_headers(
-        &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        self.build_headers(req, connectors)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        self.common_get_content_type()
-    }
-
-    fn get_url(
-        &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}/{}/refund",
-            self.base_url(connectors),
-            req.request.connector_transaction_id
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_req = transformers::DummyConnectorRefundRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(connector_req)))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Post)
-            .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
-            .attach_default_headers()
-            .headers(types::RefundExecuteType::get_headers(
-                self, req, connectors,
-            )?)
-            .set_body(types::RefundExecuteType::get_request_body(
-                self, req, connectors,
-            )?)
-            .build();
-        Ok(Some(request))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::RefundsRouterData<api::Execute>,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
-        let response: transformers::RefundResponse = res
-            .response
-            .parse_struct("transformers RefundResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl<const T: u8> ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
-    for DummyConnector<T>
-{
-    fn get_headers(
-        &self,
-        req: &types::RefundSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        self.build_headers(req, connectors)
-    }
-
-    fn get_content_type(&self) -> &'static str {
-        self.common_get_content_type()
-    }
-
-    fn get_url(
-        &self,
-        req: &types::RefundSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        let refund_id = req.request.get_connector_refund_id()?;
-        Ok(format!(
-            "{}/refunds/{}",
-            self.base_url(connectors),
-            refund_id
-        ))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::RefundSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Get)
-                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
-                .attach_default_headers()
-                .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::RefundSyncRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::RefundSyncRouterData, errors::ConnectorError> {
-        let response: transformers::RefundResponse = res
-            .response
-            .parse_struct("transformers RefundSyncResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[async_trait::async_trait]
-impl<const T: u8> api::IncomingWebhook for DummyConnector<T> {
-    fn get_webhook_object_reference_id(
-        &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
-    }
-
-    fn get_webhook_event_type(
-        &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
-        Ok(api::IncomingWebhookEvent::EventNotSupported)
-    }
-
-    fn get_webhook_resource_object(
-        &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
-    }
-}
-
-impl<const T: u8> ConnectorSpecifications for DummyConnector<T> {}
diff --git a/crates/router/src/connector/utils.rs b/crates/router/src/connector/utils.rs
index 2a7026dd265..c518c42ad1c 100644
--- a/crates/router/src/connector/utils.rs
+++ b/crates/router/src/connector/utils.rs
@@ -1959,17 +1959,6 @@ where
     json.parse_value(std::any::type_name::<T>()).switch()
 }
 
-pub fn construct_not_supported_error_report(
-    capture_method: enums::CaptureMethod,
-    connector_name: &'static str,
-) -> error_stack::Report<errors::ConnectorError> {
-    errors::ConnectorError::NotSupported {
-        message: capture_method.to_string(),
-        connector: connector_name,
-    }
-    .into()
-}
-
 impl ForeignTryFrom<String> for UsStatesAbbreviation {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn foreign_try_from(value: String) -> Result<Self, Self::Error> {
diff --git a/crates/router/src/core/admin.rs b/crates/router/src/core/admin.rs
index be009c127df..ae4da756d7f 100644
--- a/crates/router/src/core/admin.rs
+++ b/crates/router/src/core/admin.rs
@@ -1383,7 +1383,7 @@ impl ConnectorAuthTypeAndMetadataValidation<'_> {
             | api_enums::Connector::DummyConnector5
             | api_enums::Connector::DummyConnector6
             | api_enums::Connector::DummyConnector7 => {
-                dummyconnector::transformers::DummyConnectorAuthType::try_from(self.auth_type)?;
+                hyperswitch_connectors::connectors::dummyconnector::transformers::DummyConnectorAuthType::try_from(self.auth_type)?;
                 Ok(())
             }
             api_enums::Connector::Aci => {
diff --git a/crates/router/src/core/payments/flows.rs b/crates/router/src/core/payments/flows.rs
index 212aab98261..fa951af010d 100644
--- a/crates/router/src/core/payments/flows.rs
+++ b/crates/router/src/core/payments/flows.rs
@@ -17,34 +17,13 @@ use async_trait::async_trait;
 use hyperswitch_domain_models::router_flow_types::{
     BillingConnectorInvoiceSync, BillingConnectorPaymentsSync, RecoveryRecordBack,
 };
-#[cfg(feature = "dummy_connector")]
-use hyperswitch_domain_models::router_flow_types::{
-    ExternalVaultCreateFlow, ExternalVaultDeleteFlow, ExternalVaultInsertFlow,
-    ExternalVaultRetrieveFlow,
-};
 use hyperswitch_domain_models::{
-    mandates::CustomerAcceptance,
-    router_flow_types::{
-        Authenticate, AuthenticationConfirmation, PostAuthenticate, PreAuthenticate,
-    },
-    router_request_types::PaymentsCaptureData,
-};
-#[cfg(feature = "dummy_connector")]
-use hyperswitch_interfaces::api::vault::{
-    ExternalVault, ExternalVaultCreate, ExternalVaultDelete, ExternalVaultInsert,
-    ExternalVaultRetrieve,
-};
-use hyperswitch_interfaces::api::{
-    payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
-    UasPreAuthentication, UnifiedAuthenticationService,
+    mandates::CustomerAcceptance, router_request_types::PaymentsCaptureData,
 };
 
-#[cfg(feature = "frm")]
-use crate::types::fraud_check as frm_types;
 use crate::{
-    connector,
     core::{
-        errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
+        errors::{ApiErrorResponse, RouterResult},
         payments::{self, helpers},
     },
     logger,
@@ -215,522 +194,6 @@ pub trait Feature<F, T> {
     }
 }
 
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentsCompleteAuthorize for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::CompleteAuthorize,
-        types::CompleteAuthorizeData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorVerifyWebhookSource for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::VerifyWebhookSource,
-        types::VerifyWebhookSourceRequestData,
-        types::VerifyWebhookSourceResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorCustomer for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::CreateConnectorCustomer,
-        types::ConnectorCustomerData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> services::ConnectorRedirectResponse for connector::DummyConnector<T> {
-    fn get_flow_type(
-        &self,
-        _query_params: &str,
-        _json_payload: Option<serde_json::Value>,
-        _action: services::PaymentAction,
-    ) -> CustomResult<payments::CallConnectorAction, ConnectorError> {
-        Ok(payments::CallConnectorAction::Trigger)
-    }
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorTransactionId for connector::DummyConnector<T> {}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::Dispute for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::AcceptDispute for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Accept,
-        types::AcceptDisputeRequestData,
-        types::AcceptDisputeResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::FileUpload for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::UploadFile for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Upload,
-        types::UploadFileRequestData,
-        types::UploadFileResponse,
-    > for connector::DummyConnector<T>
-{
-}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::RetrieveFile for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Retrieve,
-        types::RetrieveFileRequestData,
-        types::RetrieveFileResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::SubmitEvidence for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Evidence,
-        types::SubmitEvidenceRequestData,
-        types::SubmitEvidenceResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::DefendDispute for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Defend,
-        types::DefendDisputeRequestData,
-        types::DefendDisputeResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentsPreProcessing for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PreProcessing,
-        types::PaymentsPreProcessingData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentsPostProcessing for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PostProcessing,
-        types::PaymentsPostProcessingData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> Payouts for connector::DummyConnector<T> {}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutCreate for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoCreate, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutSync for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoSync, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutEligibility for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PoEligibility,
-        types::PayoutsData,
-        types::PayoutsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutFulfill for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoFulfill, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutCancel for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutQuote for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutRecipient for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<api::PoRecipient, types::PayoutsData, types::PayoutsResponseData>
-    for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PayoutRecipientAccount for connector::DummyConnector<T> {}
-#[cfg(feature = "payouts")]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PoRecipientAccount,
-        types::PayoutsData,
-        types::PayoutsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentApprove for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Approve,
-        types::PaymentsApproveData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentReject for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Reject,
-        types::PaymentsRejectData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::FraudCheck for connector::DummyConnector<T> {}
-
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8> api::FraudCheckSale for connector::DummyConnector<T> {}
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Sale,
-        frm_types::FraudCheckSaleData,
-        frm_types::FraudCheckResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8> api::FraudCheckCheckout for connector::DummyConnector<T> {}
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Checkout,
-        frm_types::FraudCheckCheckoutData,
-        frm_types::FraudCheckResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8> api::FraudCheckTransaction for connector::DummyConnector<T> {}
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Transaction,
-        frm_types::FraudCheckTransactionData,
-        frm_types::FraudCheckResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8> api::FraudCheckFulfillment for connector::DummyConnector<T> {}
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Fulfillment,
-        frm_types::FraudCheckFulfillmentData,
-        frm_types::FraudCheckResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8> api::FraudCheckRecordReturn for connector::DummyConnector<T> {}
-#[cfg(all(feature = "frm", feature = "dummy_connector"))]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::RecordReturn,
-        frm_types::FraudCheckRecordReturnData,
-        frm_types::FraudCheckResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentIncrementalAuthorization for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::IncrementalAuthorization,
-        types::PaymentsIncrementalAuthorizationData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorMandateRevoke for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::MandateRevoke,
-        types::MandateRevokeRequestData,
-        types::MandateRevokeResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ExternalAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorPreAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorPreAuthenticationVersionCall for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::ConnectorPostAuthentication for connector::DummyConnector<T> {}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::Authentication,
-        types::authentication::ConnectorAuthenticationRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PreAuthentication,
-        types::authentication::PreAuthNRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PreAuthenticationVersionCall,
-        types::authentication::PreAuthNRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PostAuthentication,
-        types::authentication::ConnectorPostAuthenticationRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentAuthorizeSessionToken for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::AuthorizeSessionToken,
-        types::AuthorizeSessionTokenData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::TaxCalculation for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::CalculateTax,
-        types::PaymentsTaxCalculationData,
-        types::TaxCalculationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentSessionUpdate for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::SdkSessionUpdate,
-        types::SdkPaymentsSessionUpdateData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentPostSessionTokens for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::PostSessionTokens,
-        types::PaymentsPostSessionTokensData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentsCreateOrder for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::CreateOrder,
-        types::CreateOrderRequestData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::PaymentUpdateMetadata for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        api::UpdateMetadata,
-        types::PaymentsUpdateMetadataData,
-        types::PaymentsResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> UasPreAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> UnifiedAuthenticationService for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        PreAuthenticate,
-        types::UasPreAuthenticationRequestData,
-        types::UasAuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> UasPostAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        PostAuthenticate,
-        types::UasPostAuthenticationRequestData,
-        types::UasAuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> UasAuthenticationConfirmation for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        AuthenticationConfirmation,
-        types::UasConfirmationRequestData,
-        types::UasAuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> UasAuthentication for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        Authenticate,
-        types::UasAuthenticationRequestData,
-        types::UasAuthenticationResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
 /// Determines whether a capture API call should be made for a payment attempt
 /// This function evaluates whether an authorized payment should proceed with a capture API call
 /// based on various payment parameters. It's primarily used in two-step (auth + capture) payment flows for CaptureMethod SequentialAutomatic
@@ -841,99 +304,3 @@ fn handle_post_capture_response(
         }
     }
 }
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::RevenueRecovery for connector::DummyConnector<T> {}
-
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::BillingConnectorPaymentsSyncIntegration for connector::DummyConnector<T> {}
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        BillingConnectorPaymentsSync,
-        types::BillingConnectorPaymentsSyncRequest,
-        types::BillingConnectorPaymentsSyncResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::RevenueRecoveryRecordBack for connector::DummyConnector<T> {}
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        RecoveryRecordBack,
-        types::RevenueRecoveryRecordBackRequest,
-        types::RevenueRecoveryRecordBackResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> api::BillingConnectorInvoiceSyncIntegration for connector::DummyConnector<T> {}
-#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        BillingConnectorInvoiceSync,
-        types::BillingConnectorInvoiceSyncRequest,
-        types::BillingConnectorInvoiceSyncResponse,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> ExternalVault for connector::DummyConnector<T> {}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> ExternalVaultInsert for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        ExternalVaultInsertFlow,
-        types::VaultRequestData,
-        types::VaultResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> ExternalVaultRetrieve for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        ExternalVaultRetrieveFlow,
-        types::VaultRequestData,
-        types::VaultResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> ExternalVaultDelete for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        ExternalVaultDeleteFlow,
-        types::VaultRequestData,
-        types::VaultResponseData,
-    > for connector::DummyConnector<T>
-{
-}
-
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8> ExternalVaultCreate for connector::DummyConnector<T> {}
-#[cfg(feature = "dummy_connector")]
-impl<const T: u8>
-    services::ConnectorIntegration<
-        ExternalVaultCreateFlow,
-        types::VaultRequestData,
-        types::VaultResponseData,
-    > for connector::DummyConnector<T>
-{
-}

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

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

## Description
<!-- Describe your changes in detail -->
Movement of dummy connector form `router` crate to `hyperswitch_connectors` crate

### Additional Changes

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

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

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


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

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

## How did you test it?
<!--
Did you write an integration/unit/API test to verify the code changes?
Or did you test this change manually (provide relevant screenshots)?
-->
Only dummy connector moved to crate hyoerswitch_connectors hence no testing required.

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

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