Issue:
Bug: refactor(Connector): [signifyd,threedsecureio,wellsfargopayout,wise] move from routers to hyperswitch_connectors



Move the following connectors from crates/router to crates/hyperswitch_connectors

    signifyd
    threedsecureio
    wellsfargopayout
    wise


Pull request description:
## 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 -->
Move the following connectors from `crates/router` to `crates/hyperswitch_connectors`
- signifyd
- threedsecureio
- wellsfargopayout
- wise

### 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).
-->


## 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)?
-->

### WISE

```sh
curl --location 'http://localhost:8080/account/merchant_1746603147/connectors' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'x-feature: integ-custom' \
--header 'api-key: dev_vE5MxDUUu9eQJ7AMwI4vD9nVj3IlxZy1qdpct9JB7Mt3j2mbYF7jLyjMz8KvAq94' \
--data '{
    "connector_type": "payout_processor",
    "connector_name": "wise",
    "connector_account_details": {
        "api_key": "***",
        "auth_type": "BodyKey",
        "key1": "2***3"
    },
    "test_mode": false,
    "disabled": false,
    "payment_methods_enabled": [
        {
            "payment_method": "card",
            "payment_method_types": [
                {
                    "payment_method_type": "credit",
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "debit",
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        },
        {
            "payment_method": "pay_later",
            "payment_method_types": [
                {
                    "payment_method_type": "klarna",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "affirm",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "afterpay_clearpay",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        }
    ],
    "metadata": {
        "city": "NY",
        "unit": "245"
    },
    "connector_webhook_details": {
        "merchant_secret": "MyWebhookSecret"
    },
    "business_country": "US",
    "business_label": "default"
}'
```
Response

```json
{
    "connector_type": "payout_processor",
    "connector_name": "wise",
    "connector_label": "wise_US_default",
    "merchant_connector_id": "mca_w92QHyUrQYCIrMmO4Lzp",
    "profile_id": "pro_SRkbVeuCZykOW6G2bCTL",
    "connector_account_details": {
        "auth_type": "BodyKey",
        "api_key": "Be***************************************d4",
        "key1": "28****33"
    },
    "payment_methods_enabled": [
        {
            "payment_method": "card",
            "payment_method_types": [
                {
                    "payment_method_type": "credit",
                    "payment_experience": null,
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "debit",
                    "payment_experience": null,
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        },
        {
            "payment_method": "pay_later",
            "payment_method_types": [
                {
                    "payment_method_type": "klarna",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "affirm",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "afterpay_clearpay",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        }
    ],
    "connector_webhook_details": {
        "merchant_secret": "MyWebhookSecret",
        "additional_secret": null
    },
    "metadata": {
        "city": "NY",
        "unit": "245"
    },
    "test_mode": false,
    "disabled": false,
    "frm_configs": null,
    "business_country": "US",
    "business_label": "default",
    "business_sub_label": null,
    "applepay_verified_domains": null,
    "pm_auth_config": null,
    "status": "active",
    "additional_merchant_data": null,
    "connector_wallets_details": null
}
```
Create payout
```sh
curl --location 'http://localhost:8080/payouts/create' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'x-feature: integ-custom' \
--header 'api-key: dev_vE5MxDUUu9eQJ7AMwI4vD9nVj3IlxZy1qdpct9JB7Mt3j2mbYF7jLyjMz8KvAq94' \
--data-raw '{
    "amount": 100,
    "currency": "EUR",
    "customer": {
        "id": "new_id",
        "email": "new_cust@example.com",
        "name": "John Doe",
        "phone": "999999999",
        "phone_country_code": "+65"
    },
    
    "connector": [
        "wise"
    ],
    "description": "Its my first payout request",
     "payout_type": "card",
    
    "payout_method_data": {
          "card": {
            "card_number": "4000000000002503",
            "expiry_month": "08",
            "expiry_year": "25",
            "card_holder_name": "joseph Doe",
            "card_cvc": "999"
        }
    },
    "billing": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "city": "San Fransico",
            "zip": "94122",
            "country": "CH",
            "first_name": "John",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    },
    "entity_type": "Individual",
    "recurring": true,
    "metadata": {
        "city": "NY",
        "unit": "245",
        "source_balance_account": "BA32CNH223227G5KQKQDJ48HB"
    },
    "confirm": true,
    "auto_fulfill": true
}'
```

response -- LOOKS like card payment 

```json
{
    "error": {
        "type": "invalid_request",
        "message": "Payout Eligibility for Wise is not implemented",
        "code": "IR_00"
    }
}
```

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [ ] I formatted the code `cargo +nightly fmt --all`
- [ ] I addressed lints thrown by `cargo clippy`
- [ ] I reviewed the submitted code
- [ ] I added unit tests for my changes where possible


Testing:


### WISE

```sh
curl --location 'http://localhost:8080/account/merchant_1746603147/connectors' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'x-feature: integ-custom' \
--header 'api-key: dev_vE5MxDUUu9eQJ7AMwI4vD9nVj3IlxZy1qdpct9JB7Mt3j2mbYF7jLyjMz8KvAq94' \
--data '{
    "connector_type": "payout_processor",
    "connector_name": "wise",
    "connector_account_details": {
        "api_key": "***",
        "auth_type": "BodyKey",
        "key1": "2***3"
    },
    "test_mode": false,
    "disabled": false,
    "payment_methods_enabled": [
        {
            "payment_method": "card",
            "payment_method_types": [
                {
                    "payment_method_type": "credit",
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "debit",
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        },
        {
            "payment_method": "pay_later",
            "payment_method_types": [
                {
                    "payment_method_type": "klarna",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "affirm",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "afterpay_clearpay",
                    "payment_experience": "redirect_to_url",
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        }
    ],
    "metadata": {
        "city": "NY",
        "unit": "245"
    },
    "connector_webhook_details": {
        "merchant_secret": "MyWebhookSecret"
    },
    "business_country": "US",
    "business_label": "default"
}'
```
Response

```json
{
    "connector_type": "payout_processor",
    "connector_name": "wise",
    "connector_label": "wise_US_default",
    "merchant_connector_id": "mca_w92QHyUrQYCIrMmO4Lzp",
    "profile_id": "pro_SRkbVeuCZykOW6G2bCTL",
    "connector_account_details": {
        "auth_type": "BodyKey",
        "api_key": "Be***************************************d4",
        "key1": "28****33"
    },
    "payment_methods_enabled": [
        {
            "payment_method": "card",
            "payment_method_types": [
                {
                    "payment_method_type": "credit",
                    "payment_experience": null,
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "debit",
                    "payment_experience": null,
                    "card_networks": [
                        "Visa",
                        "Mastercard"
                    ],
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        },
        {
            "payment_method": "pay_later",
            "payment_method_types": [
                {
                    "payment_method_type": "klarna",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "affirm",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                },
                {
                    "payment_method_type": "afterpay_clearpay",
                    "payment_experience": "redirect_to_url",
                    "card_networks": null,
                    "accepted_currencies": null,
                    "accepted_countries": null,
                    "minimum_amount": 1,
                    "maximum_amount": 68607706,
                    "recurring_enabled": true,
                    "installment_payment_enabled": true
                }
            ]
        }
    ],
    "connector_webhook_details": {
        "merchant_secret": "MyWebhookSecret",
        "additional_secret": null
    },
    "metadata": {
        "city": "NY",
        "unit": "245"
    },
    "test_mode": false,
    "disabled": false,
    "frm_configs": null,
    "business_country": "US",
    "business_label": "default",
    "business_sub_label": null,
    "applepay_verified_domains": null,
    "pm_auth_config": null,
    "status": "active",
    "additional_merchant_data": null,
    "connector_wallets_details": null
}
```
Create payout
```sh
curl --location 'http://localhost:8080/payouts/create' \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--header 'x-feature: integ-custom' \
--header 'api-key: dev_vE5MxDUUu9eQJ7AMwI4vD9nVj3IlxZy1qdpct9JB7Mt3j2mbYF7jLyjMz8KvAq94' \
--data-raw '{
    "amount": 100,
    "currency": "EUR",
    "customer": {
        "id": "new_id",
        "email": "new_cust@example.com",
        "name": "John Doe",
        "phone": "999999999",
        "phone_country_code": "+65"
    },
    
    "connector": [
        "wise"
    ],
    "description": "Its my first payout request",
     "payout_type": "card",
    
    "payout_method_data": {
          "card": {
            "card_number": "4000000000002503",
            "expiry_month": "08",
            "expiry_year": "25",
            "card_holder_name": "joseph Doe",
            "card_cvc": "999"
        }
    },
    "billing": {
        "address": {
            "line1": "1467",
            "line2": "Harrison Street",
            "city": "San Fransico",
            "zip": "94122",
            "country": "CH",
            "first_name": "John",
            "last_name": "Doe"
        },
        "phone": {
            "number": "8056594427",
            "country_code": "+91"
        }
    },
    "entity_type": "Individual",
    "recurring": true,
    "metadata": {
        "city": "NY",
        "unit": "245",
        "source_balance_account": "BA32CNH223227G5KQKQDJ48HB"
    },
    "confirm": true,
    "auto_fulfill": true
}'
```

response -- LOOKS like card payment 

```json
{
    "error": {
        "type": "invalid_request",
        "message": "Payout Eligibility for Wise is not implemented",
        "code": "IR_00"
    }
}
```

Patch:
diff --git a/Cargo.lock b/Cargo.lock
index 39154406f6e..1c2f7d2c22e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3854,10 +3854,13 @@ dependencies = [
  "hyperswitch_domain_models",
  "hyperswitch_interfaces",
  "image",
+ "iso_currency",
+ "isocountry",
  "josekit 0.8.6",
  "lazy_static",
  "masking",
  "mime",
+ "num-traits",
  "once_cell",
  "qrcode",
  "quick-xml",
@@ -3880,6 +3883,7 @@ dependencies = [
  "unidecode",
  "url",
  "urlencoding",
+ "utoipa",
  "uuid",
 ]
 
@@ -6500,8 +6504,6 @@ dependencies = [
  "hyperswitch_domain_models",
  "hyperswitch_interfaces",
  "infer",
- "iso_currency",
- "isocountry",
  "josekit 0.8.7",
  "jsonwebtoken",
  "kgraph_utils",
diff --git a/crates/hyperswitch_connectors/Cargo.toml b/crates/hyperswitch_connectors/Cargo.toml
index d3372b79411..38647cc14a2 100644
--- a/crates/hyperswitch_connectors/Cargo.toml
+++ b/crates/hyperswitch_connectors/Cargo.toml
@@ -22,9 +22,12 @@ encoding_rs = "0.8.33"
 error-stack = "0.4.1"
 hex = "0.4.3"
 http = "0.2.12"
+iso_currency = "0.4.4"
+isocountry = "0.3.2"
 image = { version = "0.25.1", default-features = false, features = ["png"] }
 josekit = { git = "https://github.com/sumanmaji4/josekit-rs.git", rev = "5ab54876c29a84f86aef8c169413a46026883efe", features = ["support-empty-payload"]}
 mime = "0.3.17"
+num-traits = "0.2.19"
 once_cell = "1.19.0"
 qrcode = "0.14.0"
 quick-xml = { version = "0.31.0", features = ["serialize"] }
@@ -43,6 +46,7 @@ serde_with = "3.7.0"
 sha1 = { version = "0.10.6" }
 strum = { version = "0.26", features = ["derive"] }
 time = "0.3.35"
+utoipa = { version = "4.2.0", features = ["preserve_order", "preserve_path_order", "time"] }
 url = "2.5.0"
 urlencoding = "2.1.3"
 uuid = { version = "1.8.0", features = ["v4"] }
diff --git a/crates/hyperswitch_connectors/src/connectors.rs b/crates/hyperswitch_connectors/src/connectors.rs
index 0679e873d40..99e83b1374e 100644
--- a/crates/hyperswitch_connectors/src/connectors.rs
+++ b/crates/hyperswitch_connectors/src/connectors.rs
@@ -75,16 +75,20 @@ pub mod recurly;
 pub mod redsys;
 pub mod riskified;
 pub mod shift4;
+pub mod signifyd;
 pub mod square;
 pub mod stax;
 pub mod stripebilling;
 pub mod taxjar;
+pub mod threedsecureio;
 pub mod thunes;
 pub mod trustpay;
 pub mod tsys;
 pub mod unified_authentication_service;
 pub mod volt;
 pub mod wellsfargo;
+pub mod wellsfargopayout;
+pub mod wise;
 pub mod worldline;
 pub mod worldpay;
 pub mod worldpayxml;
@@ -109,9 +113,10 @@ pub use self::{
     opayo::Opayo, opennode::Opennode, paybox::Paybox, payeezy::Payeezy, payme::Payme,
     payone::Payone, paypal::Paypal, paystack::Paystack, payu::Payu, placetopay::Placetopay,
     plaid::Plaid, powertranz::Powertranz, prophetpay::Prophetpay, rapyd::Rapyd, razorpay::Razorpay,
-    recurly::Recurly, redsys::Redsys, riskified::Riskified, shift4::Shift4, square::Square,
-    stax::Stax, stripebilling::Stripebilling, taxjar::Taxjar, thunes::Thunes, trustpay::Trustpay,
-    tsys::Tsys, unified_authentication_service::UnifiedAuthenticationService, volt::Volt,
-    wellsfargo::Wellsfargo, worldline::Worldline, worldpay::Worldpay, worldpayxml::Worldpayxml,
-    xendit::Xendit, zen::Zen, zsl::Zsl,
+    recurly::Recurly, redsys::Redsys, riskified::Riskified, shift4::Shift4, signifyd::Signifyd,
+    square::Square, stax::Stax, stripebilling::Stripebilling, taxjar::Taxjar,
+    threedsecureio::Threedsecureio, thunes::Thunes, trustpay::Trustpay, tsys::Tsys,
+    unified_authentication_service::UnifiedAuthenticationService, volt::Volt,
+    wellsfargo::Wellsfargo, wellsfargopayout::Wellsfargopayout, wise::Wise, worldline::Worldline,
+    worldpay::Worldpay, worldpayxml::Worldpayxml, xendit::Xendit, zen::Zen, zsl::Zsl,
 };
diff --git a/crates/hyperswitch_connectors/src/connectors/signifyd.rs b/crates/hyperswitch_connectors/src/connectors/signifyd.rs
new file mode 100644
index 00000000000..ce744b8d682
--- /dev/null
+++ b/crates/hyperswitch_connectors/src/connectors/signifyd.rs
@@ -0,0 +1,724 @@
+pub mod transformers;
+use std::fmt::Debug;
+
+#[cfg(feature = "frm")]
+use api_models::webhooks::IncomingWebhookEvent;
+#[cfg(feature = "frm")]
+use base64::Engine;
+#[cfg(feature = "frm")]
+use common_utils::{
+    consts,
+    request::{Method, RequestBuilder},
+};
+#[cfg(feature = "frm")]
+use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
+use common_utils::{errors::CustomResult, request::Request};
+#[cfg(feature = "frm")]
+use error_stack::ResultExt;
+use hyperswitch_domain_models::{
+    router_data::{AccessToken, 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},
+};
+#[cfg(feature = "frm")]
+use hyperswitch_domain_models::{
+    router_data::{ConnectorAuthType, ErrorResponse},
+    router_flow_types::{Checkout, Fulfillment, RecordReturn, Sale, Transaction},
+    router_request_types::fraud_check::{
+        FraudCheckCheckoutData, FraudCheckFulfillmentData, FraudCheckRecordReturnData,
+        FraudCheckSaleData, FraudCheckTransactionData,
+    },
+    router_response_types::fraud_check::FraudCheckResponseData,
+};
+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,
+};
+#[cfg(feature = "frm")]
+use hyperswitch_interfaces::{
+    api::{
+        FraudCheck, FraudCheckCheckout, FraudCheckFulfillment, FraudCheckRecordReturn,
+        FraudCheckSale, FraudCheckTransaction,
+    },
+    consts::NO_ERROR_CODE,
+    events::connector_api_logs::ConnectorEvent,
+    types::Response,
+    webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
+};
+#[cfg(feature = "frm")]
+use masking::Mask;
+use masking::Maskable;
+#[cfg(feature = "frm")]
+use masking::{PeekInterface, Secret};
+#[cfg(feature = "frm")]
+use ring::hmac;
+#[cfg(feature = "frm")]
+use transformers as signifyd;
+
+use crate::constants::headers;
+#[cfg(feature = "frm")]
+use crate::{
+    types::{
+        FrmCheckoutRouterData, FrmCheckoutType, FrmFulfillmentRouterData, FrmFulfillmentType,
+        FrmRecordReturnRouterData, FrmRecordReturnType, FrmSaleRouterData, FrmSaleType,
+        FrmTransactionRouterData, FrmTransactionType, ResponseRouterData,
+    },
+    utils::get_header_key_value,
+};
+
+#[derive(Debug, Clone)]
+pub struct Signifyd;
+
+impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Signifyd
+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(),
+            self.get_content_type().to_string().into(),
+        )];
+
+        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
+        header.append(&mut api_key);
+        Ok(header)
+    }
+}
+
+impl ConnectorCommon for Signifyd {
+    fn id(&self) -> &'static str {
+        "signifyd"
+    }
+
+    fn common_get_content_type(&self) -> &'static str {
+        "application/json"
+    }
+    fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
+        connectors.signifyd.base_url.as_ref()
+    }
+
+    #[cfg(feature = "frm")]
+    fn get_auth_header(
+        &self,
+        auth_type: &ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        let auth = signifyd::SignifydAuthType::try_from(auth_type)
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
+        let auth_api_key = format!(
+            "Basic {}",
+            consts::BASE64_ENGINE.encode(auth.api_key.peek())
+        );
+
+        Ok(vec![(
+            headers::AUTHORIZATION.to_string(),
+            Mask::into_masked(auth_api_key),
+        )])
+    }
+
+    #[cfg(feature = "frm")]
+    fn build_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        let response: signifyd::SignifydErrorResponse = res
+            .response
+            .parse_struct("SignifydErrorResponse")
+            .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: NO_ERROR_CODE.to_string(),
+            message: response.messages.join(" &"),
+            reason: Some(response.errors.to_string()),
+            attempt_status: None,
+            connector_transaction_id: None,
+            network_advice_code: None,
+            network_decline_code: None,
+            network_error_message: None,
+        })
+    }
+}
+
+impl Payment for Signifyd {}
+impl PaymentAuthorize for Signifyd {}
+impl PaymentSync for Signifyd {}
+impl PaymentVoid for Signifyd {}
+impl PaymentCapture for Signifyd {}
+impl MandateSetup for Signifyd {}
+impl ConnectorAccessToken for Signifyd {}
+impl PaymentToken for Signifyd {}
+impl Refund for Signifyd {}
+impl RefundExecute for Signifyd {}
+impl RefundSync for Signifyd {}
+impl ConnectorValidation for Signifyd {}
+
+impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
+    for Signifyd
+{
+}
+
+impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Signifyd {}
+
+impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
+    for Signifyd
+{
+    fn build_request(
+        &self,
+        _req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Err(ConnectorError::NotImplemented("Setup Mandate flow for Signifyd".to_string()).into())
+    }
+}
+
+impl PaymentSession for Signifyd {}
+
+impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Signifyd {}
+
+impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Signifyd {}
+
+#[cfg(feature = "frm")]
+impl FraudCheck for Signifyd {}
+#[cfg(feature = "frm")]
+impl FraudCheckSale for Signifyd {}
+#[cfg(feature = "frm")]
+impl FraudCheckCheckout for Signifyd {}
+#[cfg(feature = "frm")]
+impl FraudCheckTransaction for Signifyd {}
+#[cfg(feature = "frm")]
+impl FraudCheckFulfillment for Signifyd {}
+#[cfg(feature = "frm")]
+impl FraudCheckRecordReturn for Signifyd {}
+
+#[cfg(feature = "frm")]
+impl ConnectorIntegration<Sale, FraudCheckSaleData, FraudCheckResponseData> for Signifyd {
+    fn get_headers(
+        &self,
+        req: &FrmSaleRouterData,
+        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: &FrmSaleRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            self.base_url(connectors),
+            "v3/orders/events/sales"
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &FrmSaleRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = signifyd::SignifydPaymentsSaleRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &FrmSaleRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&FrmSaleType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(FrmSaleType::get_headers(self, req, connectors)?)
+                .set_body(FrmSaleType::get_request_body(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &FrmSaleRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<FrmSaleRouterData, ConnectorError> {
+        let response: signifyd::SignifydPaymentsResponse = res
+            .response
+            .parse_struct("SignifydPaymentsResponse Sale")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+
+        <FrmSaleRouterData>::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[cfg(feature = "frm")]
+impl ConnectorIntegration<Checkout, FraudCheckCheckoutData, FraudCheckResponseData> for Signifyd {
+    fn get_headers(
+        &self,
+        req: &FrmCheckoutRouterData,
+        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: &FrmCheckoutRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            self.base_url(connectors),
+            "v3/orders/events/checkouts"
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &FrmCheckoutRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = signifyd::SignifydPaymentsCheckoutRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &FrmCheckoutRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&FrmCheckoutType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(FrmCheckoutType::get_headers(self, req, connectors)?)
+                .set_body(FrmCheckoutType::get_request_body(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &FrmCheckoutRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<FrmCheckoutRouterData, ConnectorError> {
+        let response: signifyd::SignifydPaymentsResponse = res
+            .response
+            .parse_struct("SignifydPaymentsResponse Checkout")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        <FrmCheckoutRouterData>::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[cfg(feature = "frm")]
+impl ConnectorIntegration<Transaction, FraudCheckTransactionData, FraudCheckResponseData>
+    for Signifyd
+{
+    fn get_headers(
+        &self,
+        req: &FrmTransactionRouterData,
+        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: &FrmTransactionRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            self.base_url(connectors),
+            "v3/orders/events/transactions"
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &FrmTransactionRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = signifyd::SignifydPaymentsTransactionRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &FrmTransactionRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&FrmTransactionType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(FrmTransactionType::get_headers(self, req, connectors)?)
+                .set_body(FrmTransactionType::get_request_body(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &FrmTransactionRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<FrmTransactionRouterData, ConnectorError> {
+        let response: signifyd::SignifydPaymentsResponse = res
+            .response
+            .parse_struct("SignifydPaymentsResponse Transaction")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        <FrmTransactionRouterData>::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[cfg(feature = "frm")]
+impl ConnectorIntegration<Fulfillment, FraudCheckFulfillmentData, FraudCheckResponseData>
+    for Signifyd
+{
+    fn get_headers(
+        &self,
+        req: &FrmFulfillmentRouterData,
+        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: &FrmFulfillmentRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            self.base_url(connectors),
+            "v3/orders/events/fulfillments"
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &FrmFulfillmentRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = signifyd::FrmFulfillmentSignifydRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(req_obj.clone())))
+    }
+
+    fn build_request(
+        &self,
+        req: &FrmFulfillmentRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&FrmFulfillmentType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(FrmFulfillmentType::get_headers(self, req, connectors)?)
+                .set_body(FrmFulfillmentType::get_request_body(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &FrmFulfillmentRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<FrmFulfillmentRouterData, ConnectorError> {
+        let response: signifyd::FrmFulfillmentSignifydApiResponse = res
+            .response
+            .parse_struct("FrmFulfillmentSignifydApiResponse Sale")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        FrmFulfillmentRouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[cfg(feature = "frm")]
+impl ConnectorIntegration<RecordReturn, FraudCheckRecordReturnData, FraudCheckResponseData>
+    for Signifyd
+{
+    fn get_headers(
+        &self,
+        req: &FrmRecordReturnRouterData,
+        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: &FrmRecordReturnRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            self.base_url(connectors),
+            "v3/orders/events/returns/records"
+        ))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &FrmRecordReturnRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = signifyd::SignifydPaymentsRecordReturnRequest::try_from(req)?;
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &FrmRecordReturnRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&FrmRecordReturnType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(FrmRecordReturnType::get_headers(self, req, connectors)?)
+                .set_body(FrmRecordReturnType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &FrmRecordReturnRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<FrmRecordReturnRouterData, ConnectorError> {
+        let response: signifyd::SignifydPaymentsRecordReturnResponse = res
+            .response
+            .parse_struct("SignifydPaymentsResponse Transaction")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        <FrmRecordReturnRouterData>::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+#[cfg(feature = "frm")]
+#[async_trait::async_trait]
+impl IncomingWebhook for Signifyd {
+    fn get_webhook_source_verification_algorithm(
+        &self,
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, ConnectorError> {
+        Ok(Box::new(crypto::HmacSha256))
+    }
+
+    fn get_webhook_source_verification_signature(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
+    ) -> CustomResult<Vec<u8>, ConnectorError> {
+        let header_value = get_header_key_value("x-signifyd-sec-hmac-sha256", request.headers)?;
+        Ok(header_value.as_bytes().to_vec())
+    }
+
+    fn get_webhook_source_verification_message(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+        _merchant_id: &common_utils::id_type::MerchantId,
+        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
+    ) -> CustomResult<Vec<u8>, ConnectorError> {
+        Ok(request.body.to_vec())
+    }
+
+    async fn verify_webhook_source(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+        merchant_id: &common_utils::id_type::MerchantId,
+        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
+        _connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
+        connector_label: &str,
+    ) -> CustomResult<bool, ConnectorError> {
+        let connector_webhook_secrets = self
+            .get_webhook_source_verification_merchant_secret(
+                merchant_id,
+                connector_label,
+                connector_webhook_details,
+            )
+            .await
+            .change_context(ConnectorError::WebhookSourceVerificationFailed)?;
+
+        let signature = self
+            .get_webhook_source_verification_signature(request, &connector_webhook_secrets)
+            .change_context(ConnectorError::WebhookSourceVerificationFailed)?;
+
+        let message = self
+            .get_webhook_source_verification_message(
+                request,
+                merchant_id,
+                &connector_webhook_secrets,
+            )
+            .change_context(ConnectorError::WebhookSourceVerificationFailed)?;
+
+        let signing_key = hmac::Key::new(hmac::HMAC_SHA256, &connector_webhook_secrets.secret);
+        let signed_message = hmac::sign(&signing_key, &message);
+        let payload_sign = consts::BASE64_ENGINE.encode(signed_message.as_ref());
+        Ok(payload_sign.as_bytes().eq(&signature))
+    }
+
+    fn get_webhook_object_reference_id(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, ConnectorError> {
+        let resource: signifyd::SignifydWebhookBody = request
+            .body
+            .parse_struct("SignifydWebhookBody")
+            .change_context(ConnectorError::WebhookReferenceIdNotFound)?;
+        Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
+            api_models::payments::PaymentIdType::PaymentAttemptId(resource.order_id),
+        ))
+    }
+
+    fn get_webhook_event_type(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
+        let resource: signifyd::SignifydWebhookBody = request
+            .body
+            .parse_struct("SignifydWebhookBody")
+            .change_context(ConnectorError::WebhookEventTypeNotFound)?;
+        Ok(IncomingWebhookEvent::from(resource.review_disposition))
+    }
+
+    fn get_webhook_resource_object(
+        &self,
+        request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
+        let resource: signifyd::SignifydWebhookBody = request
+            .body
+            .parse_struct("SignifydWebhookBody")
+            .change_context(ConnectorError::WebhookResourceObjectNotFound)?;
+        Ok(Box::new(resource))
+    }
+}
+
+impl ConnectorSpecifications for Signifyd {}
diff --git a/crates/router/src/connector/signifyd/transformers.rs b/crates/hyperswitch_connectors/src/connectors/signifyd/transformers.rs
similarity index 100%
rename from crates/router/src/connector/signifyd/transformers.rs
rename to crates/hyperswitch_connectors/src/connectors/signifyd/transformers.rs
diff --git a/crates/router/src/connector/signifyd/transformers/api.rs b/crates/hyperswitch_connectors/src/connectors/signifyd/transformers/api.rs
similarity index 77%
rename from crates/router/src/connector/signifyd/transformers/api.rs
rename to crates/hyperswitch_connectors/src/connectors/signifyd/transformers/api.rs
index 028c0e82518..4df231a918e 100644
--- a/crates/router/src/connector/signifyd/transformers/api.rs
+++ b/crates/hyperswitch_connectors/src/connectors/signifyd/transformers/api.rs
@@ -1,6 +1,18 @@
+use api_models::webhooks::IncomingWebhookEvent;
+use common_enums::{AttemptStatus, Currency, FraudCheckStatus, PaymentMethod};
 use common_utils::{ext_traits::ValueExt, pii::Email};
 use error_stack::{self, ResultExt};
 pub use hyperswitch_domain_models::router_request_types::fraud_check::RefundMethod;
+use hyperswitch_domain_models::{
+    router_data::RouterData,
+    router_flow_types::Fulfillment,
+    router_request_types::{
+        fraud_check::{self, FraudCheckFulfillmentData, FrmFulfillmentRequest},
+        ResponseId,
+    },
+    router_response_types::fraud_check::FraudCheckResponseData,
+};
+use hyperswitch_interfaces::errors::ConnectorError;
 use masking::Secret;
 use num_traits::ToPrimitive;
 use serde::{Deserialize, Serialize};
@@ -8,17 +20,15 @@ use time::PrimitiveDateTime;
 use utoipa::ToSchema;
 
 use crate::{
-    connector::utils::{
-        AddressDetailsData, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest,
-        FraudCheckSaleRequest, FraudCheckTransactionRequest, RouterData,
-    },
-    core::{errors, fraud_check::types as core_types},
     types::{
-        self, api, api::Fulfillment, fraud_check as frm_types, storage::enums as storage_enums,
-        transformers::ForeignFrom, ResponseId, ResponseRouterData,
+        FrmCheckoutRouterData, FrmFulfillmentRouterData, FrmRecordReturnRouterData,
+        FrmSaleRouterData, FrmTransactionRouterData, ResponseRouterData,
+    },
+    utils::{
+        AddressDetailsData as _, FraudCheckCheckoutRequest, FraudCheckRecordReturnRequest as _,
+        FraudCheckSaleRequest as _, FraudCheckTransactionRequest as _, RouterData as _,
     },
 };
-
 #[allow(dead_code)]
 #[derive(Debug, Serialize, Eq, PartialEq, Deserialize, Clone)]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
@@ -36,7 +46,7 @@ pub struct Purchase {
     total_price: i64,
     products: Vec<Products>,
     shipments: Shipments,
-    currency: Option<common_enums::Currency>,
+    currency: Option<Currency>,
     total_shipping_cost: Option<i64>,
     confirmation_email: Option<Email>,
     confirmation_phone: Option<Secret<String>>,
@@ -136,9 +146,9 @@ pub struct SignifydFrmMetadata {
     pub order_channel: OrderChannel,
 }
 
-impl TryFrom<&frm_types::FrmSaleRouterData> for SignifydPaymentsSaleRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &frm_types::FrmSaleRouterData) -> Result<Self, Self::Error> {
+impl TryFrom<&FrmSaleRouterData> for SignifydPaymentsSaleRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &FrmSaleRouterData) -> Result<Self, Self::Error> {
         let products = item
             .request
             .get_order_details()?
@@ -159,11 +169,11 @@ impl TryFrom<&frm_types::FrmSaleRouterData> for SignifydPaymentsSaleRequest {
         let metadata: SignifydFrmMetadata = item
             .frm_metadata
             .clone()
-            .ok_or(errors::ConnectorError::MissingRequiredField {
+            .ok_or(ConnectorError::MissingRequiredField {
                 field_name: "frm_metadata",
             })?
             .parse_value("Signifyd Frm Metadata")
-            .change_context(errors::ConnectorError::InvalidDataFormat {
+            .change_context(ConnectorError::InvalidDataFormat {
                 field_name: "frm_metadata",
             })?;
         let ship_address = item.get_shipping_address()?;
@@ -239,7 +249,7 @@ pub enum SignifydPaymentStatus {
     Reject,
 }
 
-impl From<SignifydPaymentStatus> for storage_enums::FraudCheckStatus {
+impl From<SignifydPaymentStatus> for FraudCheckStatus {
     fn from(item: SignifydPaymentStatus) -> Self {
         match item {
             SignifydPaymentStatus::Accept => Self::Legit,
@@ -257,20 +267,17 @@ pub struct SignifydPaymentsResponse {
     decision: Decision,
 }
 
-impl<F, T>
-    TryFrom<ResponseRouterData<F, SignifydPaymentsResponse, T, frm_types::FraudCheckResponseData>>
-    for types::RouterData<F, T, frm_types::FraudCheckResponseData>
+impl<F, T> TryFrom<ResponseRouterData<F, SignifydPaymentsResponse, T, FraudCheckResponseData>>
+    for RouterData<F, T, FraudCheckResponseData>
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: ResponseRouterData<F, SignifydPaymentsResponse, T, frm_types::FraudCheckResponseData>,
+        item: ResponseRouterData<F, SignifydPaymentsResponse, T, FraudCheckResponseData>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(frm_types::FraudCheckResponseData::TransactionResponse {
+            response: Ok(FraudCheckResponseData::TransactionResponse {
                 resource_id: ResponseId::ConnectorTransactionId(item.response.order_id),
-                status: storage_enums::FraudCheckStatus::from(
-                    item.response.decision.checkpoint_action,
-                ),
+                status: FraudCheckStatus::from(item.response.decision.checkpoint_action),
                 connector_metadata: None,
                 score: item.response.decision.score.and_then(|data| data.to_i32()),
                 reason: item
@@ -295,9 +302,9 @@ pub struct SignifydErrorResponse {
 pub struct Transactions {
     transaction_id: String,
     gateway_status_code: String,
-    payment_method: storage_enums::PaymentMethod,
+    payment_method: PaymentMethod,
     amount: i64,
-    currency: storage_enums::Currency,
+    currency: Currency,
     gateway: Option<String>,
 }
 
@@ -309,20 +316,20 @@ pub struct SignifydPaymentsTransactionRequest {
     transactions: Transactions,
 }
 
-impl From<storage_enums::AttemptStatus> for GatewayStatusCode {
-    fn from(item: storage_enums::AttemptStatus) -> Self {
+impl From<AttemptStatus> for GatewayStatusCode {
+    fn from(item: AttemptStatus) -> Self {
         match item {
-            storage_enums::AttemptStatus::Pending => Self::Pending,
-            storage_enums::AttemptStatus::Failure => Self::Failure,
-            storage_enums::AttemptStatus::Charged => Self::Success,
+            AttemptStatus::Pending => Self::Pending,
+            AttemptStatus::Failure => Self::Failure,
+            AttemptStatus::Charged => Self::Success,
             _ => Self::Pending,
         }
     }
 }
 
-impl TryFrom<&frm_types::FrmTransactionRouterData> for SignifydPaymentsTransactionRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &frm_types::FrmTransactionRouterData) -> Result<Self, Self::Error> {
+impl TryFrom<&FrmTransactionRouterData> for SignifydPaymentsTransactionRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &FrmTransactionRouterData) -> Result<Self, Self::Error> {
         let currency = item.request.get_currency()?;
         let transactions = Transactions {
             amount: item.request.amount,
@@ -373,9 +380,9 @@ pub struct SignifydPaymentsCheckoutRequest {
     coverage_requests: Option<CoverageRequests>,
 }
 
-impl TryFrom<&frm_types::FrmCheckoutRouterData> for SignifydPaymentsCheckoutRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &frm_types::FrmCheckoutRouterData) -> Result<Self, Self::Error> {
+impl TryFrom<&FrmCheckoutRouterData> for SignifydPaymentsCheckoutRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &FrmCheckoutRouterData) -> Result<Self, Self::Error> {
         let products = item
             .request
             .get_order_details()?
@@ -396,11 +403,11 @@ impl TryFrom<&frm_types::FrmCheckoutRouterData> for SignifydPaymentsCheckoutRequ
         let metadata: SignifydFrmMetadata = item
             .frm_metadata
             .clone()
-            .ok_or(errors::ConnectorError::MissingRequiredField {
+            .ok_or(ConnectorError::MissingRequiredField {
                 field_name: "frm_metadata",
             })?
             .parse_value("Signifyd Frm Metadata")
-            .change_context(errors::ConnectorError::InvalidDataFormat {
+            .change_context(ConnectorError::InvalidDataFormat {
                 field_name: "frm_metadata",
             })?;
         let ship_address = item.get_shipping_address()?;
@@ -499,9 +506,9 @@ pub struct Product {
     pub item_id: String,
 }
 
-impl TryFrom<&frm_types::FrmFulfillmentRouterData> for FrmFulfillmentSignifydRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &frm_types::FrmFulfillmentRouterData) -> Result<Self, Self::Error> {
+impl TryFrom<&FrmFulfillmentRouterData> for FrmFulfillmentSignifydRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &FrmFulfillmentRouterData) -> Result<Self, Self::Error> {
         Ok(Self {
             order_id: item.request.fulfillment_req.order_id.clone(),
             fulfillment_status: item
@@ -510,47 +517,48 @@ impl TryFrom<&frm_types::FrmFulfillmentRouterData> for FrmFulfillmentSignifydReq
                 .fulfillment_status
                 .as_ref()
                 .map(|fulfillment_status| FulfillmentStatus::from(&fulfillment_status.clone())),
-            fulfillments: Vec::<Fulfillments>::foreign_from(&item.request.fulfillment_req),
+            fulfillments: get_signifyd_fulfillments_from_frm_fulfillment_request(
+                &item.request.fulfillment_req,
+            ),
         })
     }
 }
 
-impl From<&core_types::FulfillmentStatus> for FulfillmentStatus {
-    fn from(status: &core_types::FulfillmentStatus) -> Self {
+impl From<&fraud_check::FulfillmentStatus> for FulfillmentStatus {
+    fn from(status: &fraud_check::FulfillmentStatus) -> Self {
         match status {
-            core_types::FulfillmentStatus::PARTIAL => Self::PARTIAL,
-            core_types::FulfillmentStatus::COMPLETE => Self::COMPLETE,
-            core_types::FulfillmentStatus::REPLACEMENT => Self::REPLACEMENT,
-            core_types::FulfillmentStatus::CANCELED => Self::CANCELED,
+            fraud_check::FulfillmentStatus::PARTIAL => Self::PARTIAL,
+            fraud_check::FulfillmentStatus::COMPLETE => Self::COMPLETE,
+            fraud_check::FulfillmentStatus::REPLACEMENT => Self::REPLACEMENT,
+            fraud_check::FulfillmentStatus::CANCELED => Self::CANCELED,
         }
     }
 }
-
-impl ForeignFrom<&core_types::FrmFulfillmentRequest> for Vec<Fulfillments> {
-    fn foreign_from(fulfillment_req: &core_types::FrmFulfillmentRequest) -> Self {
-        fulfillment_req
-            .fulfillments
-            .iter()
-            .map(|fulfillment| Fulfillments {
-                shipment_id: fulfillment.shipment_id.clone(),
-                products: fulfillment
-                    .products
-                    .as_ref()
-                    .map(|products| products.iter().map(|p| Product::from(p.clone())).collect()),
-                destination: Destination::from(fulfillment.destination.clone()),
-                tracking_urls: fulfillment_req.tracking_urls.clone(),
-                tracking_numbers: fulfillment_req.tracking_numbers.clone(),
-                fulfillment_method: fulfillment_req.fulfillment_method.clone(),
-                carrier: fulfillment_req.carrier.clone(),
-                shipment_status: fulfillment_req.shipment_status.clone(),
-                shipped_at: fulfillment_req.shipped_at.clone(),
-            })
-            .collect()
-    }
+pub(crate) fn get_signifyd_fulfillments_from_frm_fulfillment_request(
+    fulfillment_req: &FrmFulfillmentRequest,
+) -> Vec<Fulfillments> {
+    fulfillment_req
+        .fulfillments
+        .iter()
+        .map(|fulfillment| Fulfillments {
+            shipment_id: fulfillment.shipment_id.clone(),
+            products: fulfillment
+                .products
+                .as_ref()
+                .map(|products| products.iter().map(|p| Product::from(p.clone())).collect()),
+            destination: Destination::from(fulfillment.destination.clone()),
+            tracking_urls: fulfillment_req.tracking_urls.clone(),
+            tracking_numbers: fulfillment_req.tracking_numbers.clone(),
+            fulfillment_method: fulfillment_req.fulfillment_method.clone(),
+            carrier: fulfillment_req.carrier.clone(),
+            shipment_status: fulfillment_req.shipment_status.clone(),
+            shipped_at: fulfillment_req.shipped_at.clone(),
+        })
+        .collect()
 }
 
-impl From<core_types::Product> for Product {
-    fn from(product: core_types::Product) -> Self {
+impl From<fraud_check::Product> for Product {
+    fn from(product: fraud_check::Product) -> Self {
         Self {
             item_name: product.item_name,
             item_quantity: product.item_quantity,
@@ -559,8 +567,8 @@ impl From<core_types::Product> for Product {
     }
 }
 
-impl From<core_types::Destination> for Destination {
-    fn from(destination: core_types::Destination) -> Self {
+impl From<fraud_check::Destination> for Destination {
+    fn from(destination: fraud_check::Destination) -> Self {
         Self {
             full_name: destination.full_name,
             organization: destination.organization,
@@ -570,8 +578,8 @@ impl From<core_types::Destination> for Destination {
     }
 }
 
-impl From<core_types::Address> for Address {
-    fn from(address: core_types::Address) -> Self {
+impl From<fraud_check::Address> for Address {
+    fn from(address: fraud_check::Address) -> Self {
         Self {
             street_address: address.street_address,
             unit: address.unit,
@@ -596,27 +604,22 @@ impl
         ResponseRouterData<
             Fulfillment,
             FrmFulfillmentSignifydApiResponse,
-            frm_types::FraudCheckFulfillmentData,
-            frm_types::FraudCheckResponseData,
+            FraudCheckFulfillmentData,
+            FraudCheckResponseData,
         >,
-    >
-    for types::RouterData<
-        Fulfillment,
-        frm_types::FraudCheckFulfillmentData,
-        frm_types::FraudCheckResponseData,
-    >
+    > for RouterData<Fulfillment, FraudCheckFulfillmentData, FraudCheckResponseData>
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
         item: ResponseRouterData<
             Fulfillment,
             FrmFulfillmentSignifydApiResponse,
-            frm_types::FraudCheckFulfillmentData,
-            frm_types::FraudCheckResponseData,
+            FraudCheckFulfillmentData,
+            FraudCheckResponseData,
         >,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(frm_types::FraudCheckResponseData::FulfillmentResponse {
+            response: Ok(FraudCheckResponseData::FulfillmentResponse {
                 order_id: item.response.order_id,
                 shipment_ids: item.response.shipment_ids,
             }),
@@ -631,7 +634,7 @@ impl
 pub struct SignifydRefund {
     method: RefundMethod,
     amount: String,
-    currency: storage_enums::Currency,
+    currency: Currency,
 }
 
 #[derive(Debug, Serialize, Eq, PartialEq)]
@@ -653,26 +656,20 @@ pub struct SignifydPaymentsRecordReturnResponse {
 }
 
 impl<F, T>
-    TryFrom<
-        ResponseRouterData<
-            F,
-            SignifydPaymentsRecordReturnResponse,
-            T,
-            frm_types::FraudCheckResponseData,
-        >,
-    > for types::RouterData<F, T, frm_types::FraudCheckResponseData>
+    TryFrom<ResponseRouterData<F, SignifydPaymentsRecordReturnResponse, T, FraudCheckResponseData>>
+    for RouterData<F, T, FraudCheckResponseData>
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
         item: ResponseRouterData<
             F,
             SignifydPaymentsRecordReturnResponse,
             T,
-            frm_types::FraudCheckResponseData,
+            FraudCheckResponseData,
         >,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            response: Ok(frm_types::FraudCheckResponseData::RecordReturnResponse {
+            response: Ok(FraudCheckResponseData::RecordReturnResponse {
                 resource_id: ResponseId::ConnectorTransactionId(item.response.order_id),
                 return_id: Some(item.response.return_id.to_string()),
                 connector_metadata: None,
@@ -682,9 +679,9 @@ impl<F, T>
     }
 }
 
-impl TryFrom<&frm_types::FrmRecordReturnRouterData> for SignifydPaymentsRecordReturnRequest {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(item: &frm_types::FrmRecordReturnRouterData) -> Result<Self, Self::Error> {
+impl TryFrom<&FrmRecordReturnRouterData> for SignifydPaymentsRecordReturnRequest {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(item: &FrmRecordReturnRouterData) -> Result<Self, Self::Error> {
         let currency = item.request.get_currency()?;
         let refund = SignifydRefund {
             method: item.request.refund_method.clone(),
@@ -714,7 +711,7 @@ pub enum ReviewDisposition {
     Good,
 }
 
-impl From<ReviewDisposition> for api::IncomingWebhookEvent {
+impl From<ReviewDisposition> for IncomingWebhookEvent {
     fn from(value: ReviewDisposition) -> Self {
         match value {
             ReviewDisposition::Fraudulent => Self::FrmRejected,
diff --git a/crates/hyperswitch_connectors/src/connectors/signifyd/transformers/auth.rs b/crates/hyperswitch_connectors/src/connectors/signifyd/transformers/auth.rs
new file mode 100644
index 00000000000..1462e2e7297
--- /dev/null
+++ b/crates/hyperswitch_connectors/src/connectors/signifyd/transformers/auth.rs
@@ -0,0 +1,20 @@
+use error_stack;
+use hyperswitch_domain_models::router_data::ConnectorAuthType;
+use hyperswitch_interfaces::errors::ConnectorError;
+use masking::Secret;
+
+pub struct SignifydAuthType {
+    pub api_key: Secret<String>,
+}
+
+impl TryFrom<&ConnectorAuthType> for SignifydAuthType {
+    type Error = error_stack::Report<ConnectorError>;
+    fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
+        match auth_type {
+            ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
+                api_key: api_key.to_owned(),
+            }),
+            _ => Err(ConnectorError::FailedToObtainAuthType.into()),
+        }
+    }
+}
diff --git a/crates/hyperswitch_connectors/src/connectors/threedsecureio.rs b/crates/hyperswitch_connectors/src/connectors/threedsecureio.rs
new file mode 100644
index 00000000000..7f98cf9d958
--- /dev/null
+++ b/crates/hyperswitch_connectors/src/connectors/threedsecureio.rs
@@ -0,0 +1,512 @@
+pub mod transformers;
+
+use std::fmt::Debug;
+
+use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
+use common_utils::{
+    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::{
+        authentication::{
+            Authentication, PostAuthentication, PreAuthentication, PreAuthenticationVersionCall,
+        },
+        AccessTokenAuth, Authorize, Capture, Execute, PSync, PaymentMethodToken, RSync, Session,
+        SetupMandate, Void,
+    },
+    router_request_types::{
+        authentication::{
+            ConnectorAuthenticationRequestData, ConnectorPostAuthenticationRequestData,
+            PreAuthNRequestData,
+        },
+        AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
+        PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
+        RefundsData, SetupMandateRequestData,
+    },
+    router_response_types::{
+        AuthenticationResponseData, PaymentsResponseData, RefundsResponseData,
+    },
+};
+use hyperswitch_interfaces::{
+    api::{
+        authentication::{
+            ConnectorAuthentication, ConnectorPostAuthentication, ConnectorPreAuthentication,
+            ConnectorPreAuthenticationVersionCall, ExternalAuthentication,
+        },
+        ConnectorAccessToken, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration,
+        ConnectorSpecifications, ConnectorValidation, CurrencyUnit, MandateSetup, Payment,
+        PaymentAuthorize, PaymentCapture, PaymentSession, PaymentSync, PaymentToken, PaymentVoid,
+        Refund, RefundExecute, RefundSync,
+    },
+    configs::Connectors,
+    consts::NO_ERROR_MESSAGE,
+    errors::ConnectorError,
+    events::connector_api_logs::ConnectorEvent,
+    types::Response,
+    webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
+};
+use masking::{ExposeInterface, Mask as _, Maskable};
+use transformers as threedsecureio;
+
+use crate::{
+    constants::headers,
+    types::{
+        ConnectorAuthenticationRouterData, ConnectorAuthenticationType,
+        ConnectorPostAuthenticationRouterData, ConnectorPostAuthenticationType,
+        ConnectorPreAuthenticationType, PreAuthNRouterData, ResponseRouterData,
+    },
+    utils::handle_json_response_deserialization_failure,
+};
+#[derive(Debug, Clone)]
+pub struct Threedsecureio;
+
+impl Payment for Threedsecureio {}
+impl PaymentSession for Threedsecureio {}
+impl ConnectorAccessToken for Threedsecureio {}
+impl MandateSetup for Threedsecureio {}
+impl PaymentAuthorize for Threedsecureio {}
+impl PaymentSync for Threedsecureio {}
+impl PaymentCapture for Threedsecureio {}
+impl PaymentVoid for Threedsecureio {}
+impl Refund for Threedsecureio {}
+impl RefundExecute for Threedsecureio {}
+impl RefundSync for Threedsecureio {}
+impl PaymentToken for Threedsecureio {}
+
+impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
+    for Threedsecureio
+{
+}
+
+impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Threedsecureio
+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(),
+            "application/json; charset=utf-8".to_string().into(),
+        )];
+        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
+        header.append(&mut api_key);
+        Ok(header)
+    }
+}
+
+impl ConnectorCommon for Threedsecureio {
+    fn id(&self) -> &'static str {
+        "threedsecureio"
+    }
+
+    fn get_currency_unit(&self) -> CurrencyUnit {
+        CurrencyUnit::Minor
+    }
+
+    fn common_get_content_type(&self) -> &'static str {
+        "application/json"
+    }
+
+    fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
+        connectors.threedsecureio.base_url.as_ref()
+    }
+
+    fn get_auth_header(
+        &self,
+        auth_type: &ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        let auth = threedsecureio::ThreedsecureioAuthType::try_from(auth_type)
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
+        Ok(vec![(
+            headers::APIKEY.to_string(),
+            auth.api_key.expose().into_masked(),
+        )])
+    }
+
+    fn build_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        let response_result: Result<
+            threedsecureio::ThreedsecureioErrorResponse,
+            error_stack::Report<common_utils::errors::ParsingError>,
+        > = res.response.parse_struct("ThreedsecureioErrorResponse");
+
+        match response_result {
+            Ok(response) => {
+                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_description
+                        .clone()
+                        .unwrap_or(NO_ERROR_MESSAGE.to_owned()),
+                    reason: response.error_description,
+                    attempt_status: None,
+                    connector_transaction_id: None,
+                    network_advice_code: None,
+                    network_decline_code: None,
+                    network_error_message: None,
+                })
+            }
+            Err(err) => {
+                router_env::logger::error!(deserialization_error =? err);
+                handle_json_response_deserialization_failure(res, "threedsecureio")
+            }
+        }
+    }
+}
+
+impl ConnectorValidation for Threedsecureio {}
+
+impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Threedsecureio {}
+
+impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Threedsecureio {}
+
+impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
+    for Threedsecureio
+{
+}
+
+impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
+    for Threedsecureio
+{
+}
+
+impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Threedsecureio {}
+
+impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Threedsecureio {}
+
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Threedsecureio {}
+
+impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Threedsecureio {}
+
+impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Threedsecureio {}
+
+#[async_trait::async_trait]
+impl IncomingWebhook for Threedsecureio {
+    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> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
+    }
+
+    fn get_webhook_resource_object(
+        &self,
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
+    }
+}
+
+impl ConnectorPreAuthentication for Threedsecureio {}
+impl ConnectorPreAuthenticationVersionCall for Threedsecureio {}
+impl ExternalAuthentication for Threedsecureio {}
+impl ConnectorAuthentication for Threedsecureio {}
+impl ConnectorPostAuthentication for Threedsecureio {}
+
+impl
+    ConnectorIntegration<
+        Authentication,
+        ConnectorAuthenticationRequestData,
+        AuthenticationResponseData,
+    > for Threedsecureio
+{
+    fn get_headers(
+        &self,
+        req: &ConnectorAuthenticationRouterData,
+        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: &ConnectorAuthenticationRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!("{}/auth", self.base_url(connectors),))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &ConnectorAuthenticationRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((
+            &self.get_currency_unit(),
+            req.request
+                .currency
+                .ok_or(ConnectorError::MissingRequiredField {
+                    field_name: "currency",
+                })?,
+            req.request
+                .amount
+                .ok_or(ConnectorError::MissingRequiredField {
+                    field_name: "amount",
+                })?,
+            req,
+        ))?;
+        let req_obj =
+            threedsecureio::ThreedsecureioAuthenticationRequest::try_from(&connector_router_data);
+        Ok(RequestContent::Json(Box::new(req_obj?)))
+    }
+
+    fn build_request(
+        &self,
+        req: &ConnectorAuthenticationRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&ConnectorAuthenticationType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(ConnectorAuthenticationType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(ConnectorAuthenticationType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &ConnectorAuthenticationRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<ConnectorAuthenticationRouterData, ConnectorError> {
+        let response: threedsecureio::ThreedsecureioAuthenticationResponse = res
+            .response
+            .parse_struct("ThreedsecureioAuthenticationResponse")
+            .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,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl ConnectorIntegration<PreAuthentication, PreAuthNRequestData, AuthenticationResponseData>
+    for Threedsecureio
+{
+    fn get_headers(
+        &self,
+        req: &PreAuthNRouterData,
+        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: &PreAuthNRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!("{}/preauth", self.base_url(connectors),))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &PreAuthNRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((0, req))?;
+        let req_obj = threedsecureio::ThreedsecureioPreAuthenticationRequest::try_from(
+            &connector_router_data,
+        )?;
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &PreAuthNRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&ConnectorPreAuthenticationType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(ConnectorPreAuthenticationType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(ConnectorPreAuthenticationType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &PreAuthNRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<PreAuthNRouterData, ConnectorError> {
+        let response: threedsecureio::ThreedsecureioPreAuthenticationResponse = res
+            .response
+            .parse_struct("threedsecureio ThreedsecureioPreAuthenticationResponse")
+            .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,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl
+    ConnectorIntegration<
+        PostAuthentication,
+        ConnectorPostAuthenticationRequestData,
+        AuthenticationResponseData,
+    > for Threedsecureio
+{
+    fn get_headers(
+        &self,
+        req: &ConnectorPostAuthenticationRouterData,
+        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: &ConnectorPostAuthenticationRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Ok(format!("{}/postauth", self.base_url(connectors),))
+    }
+
+    fn get_request_body(
+        &self,
+        req: &ConnectorPostAuthenticationRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let req_obj = threedsecureio::ThreedsecureioPostAuthenticationRequest {
+            three_ds_server_trans_id: req.request.threeds_server_transaction_id.clone(),
+        };
+        Ok(RequestContent::Json(Box::new(req_obj)))
+    }
+
+    fn build_request(
+        &self,
+        req: &ConnectorPostAuthenticationRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&ConnectorPostAuthenticationType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(ConnectorPostAuthenticationType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(ConnectorPostAuthenticationType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &ConnectorPostAuthenticationRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<ConnectorPostAuthenticationRouterData, ConnectorError> {
+        let response: threedsecureio::ThreedsecureioPostAuthenticationResponse = res
+            .response
+            .parse_struct("threedsecureio PaymentsSyncResponse")
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        Ok(ConnectorPostAuthenticationRouterData {
+            response: Ok(AuthenticationResponseData::PostAuthNResponse {
+                trans_status: response.trans_status.into(),
+                authentication_value: response.authentication_value,
+                eci: response.eci,
+            }),
+            ..data.clone()
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
+impl
+    ConnectorIntegration<
+        PreAuthenticationVersionCall,
+        PreAuthNRequestData,
+        AuthenticationResponseData,
+    > for Threedsecureio
+{
+}
+
+impl ConnectorSpecifications for Threedsecureio {}
diff --git a/crates/router/src/connector/threedsecureio/transformers.rs b/crates/hyperswitch_connectors/src/connectors/threedsecureio/transformers.rs
similarity index 78%
rename from crates/router/src/connector/threedsecureio/transformers.rs
rename to crates/hyperswitch_connectors/src/connectors/threedsecureio/transformers.rs
index e6d608b68d3..d74d667b087 100644
--- a/crates/router/src/connector/threedsecureio/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/threedsecureio/transformers.rs
@@ -2,25 +2,30 @@ use std::str::FromStr;
 
 use api_models::payments::{DeviceChannel, ThreeDsCompletionIndicator};
 use base64::Engine;
-use common_utils::date_time;
+use common_enums::enums;
+use common_utils::{consts::BASE64_ENGINE, date_time, ext_traits::OptionExt as _};
 use error_stack::ResultExt;
-use hyperswitch_connectors::utils::AddressDetailsData;
+use hyperswitch_domain_models::{
+    router_data::{ConnectorAuthType, ErrorResponse},
+    router_flow_types::authentication::{Authentication, PreAuthentication},
+    router_request_types::{
+        authentication::{
+            AuthNFlowType, ChallengeParams, ConnectorAuthenticationRequestData, MessageCategory,
+            PreAuthNRequestData,
+        },
+        BrowserInformation,
+    },
+    router_response_types::AuthenticationResponseData,
+};
+use hyperswitch_interfaces::{api::CurrencyUnit, consts::NO_ERROR_MESSAGE, errors};
 use iso_currency::Currency;
-use isocountry;
 use masking::{ExposeInterface, Secret};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, to_string};
 
 use crate::{
-    connector::utils::{get_card_details, to_connector_meta, CardData},
-    consts::{BASE64_ENGINE, NO_ERROR_MESSAGE},
-    core::errors,
-    types::{
-        self,
-        api::{self, MessageCategory},
-        authentication::ChallengeParams,
-    },
-    utils::OptionExt,
+    types::{ConnectorAuthenticationRouterData, PreAuthNRouterData, ResponseRouterData},
+    utils::{get_card_details, to_connector_meta, AddressDetailsData, CardData as _},
 };
 
 pub struct ThreedsecureioRouterData<T> {
@@ -28,17 +33,10 @@ pub struct ThreedsecureioRouterData<T> {
     pub router_data: T,
 }
 
-impl<T> TryFrom<(&api::CurrencyUnit, types::storage::enums::Currency, i64, T)>
-    for ThreedsecureioRouterData<T>
-{
+impl<T> TryFrom<(&CurrencyUnit, enums::Currency, i64, T)> for ThreedsecureioRouterData<T> {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        (_currency_unit, _currency, amount, item): (
-            &api::CurrencyUnit,
-            types::storage::enums::Currency,
-            i64,
-            T,
-        ),
+        (_currency_unit, _currency, amount, item): (&CurrencyUnit, enums::Currency, i64, T),
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             amount: amount.to_string(),
@@ -59,21 +57,21 @@ impl<T> TryFrom<(i64, T)> for ThreedsecureioRouterData<T> {
 
 impl
     TryFrom<
-        types::ResponseRouterData<
-            api::PreAuthentication,
+        ResponseRouterData<
+            PreAuthentication,
             ThreedsecureioPreAuthenticationResponse,
-            types::authentication::PreAuthNRequestData,
-            types::authentication::AuthenticationResponseData,
+            PreAuthNRequestData,
+            AuthenticationResponseData,
         >,
-    > for types::authentication::PreAuthNRouterData
+    > for PreAuthNRouterData
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: types::ResponseRouterData<
-            api::PreAuthentication,
+        item: ResponseRouterData<
+            PreAuthentication,
             ThreedsecureioPreAuthenticationResponse,
-            types::authentication::PreAuthNRequestData,
-            types::authentication::AuthenticationResponseData,
+            PreAuthNRequestData,
+            AuthenticationResponseData,
         >,
     ) -> Result<Self, Self::Error> {
         let response = match item.response {
@@ -91,30 +89,27 @@ impl
                     acs_start_protocol_version: pre_authn_response.acs_start_protocol_version,
                     acs_end_protocol_version: pre_authn_response.acs_end_protocol_version.clone(),
                 });
-                Ok(
-                    types::authentication::AuthenticationResponseData::PreAuthNResponse {
-                        threeds_server_transaction_id: pre_authn_response
-                            .threeds_server_trans_id
-                            .clone(),
-                        maximum_supported_3ds_version:
-                            common_utils::types::SemanticVersion::from_str(
-                                &pre_authn_response.acs_end_protocol_version,
-                            )
-                            .change_context(errors::ConnectorError::ParsingFailed)?,
-                        connector_authentication_id: pre_authn_response.threeds_server_trans_id,
-                        three_ds_method_data: Some(three_ds_method_data_base64),
-                        three_ds_method_url: pre_authn_response.threeds_method_url,
-                        message_version: common_utils::types::SemanticVersion::from_str(
-                            &pre_authn_response.acs_end_protocol_version,
-                        )
-                        .change_context(errors::ConnectorError::ParsingFailed)?,
-                        connector_metadata: Some(connector_metadata),
-                        directory_server_id: None,
-                    },
-                )
+                Ok(AuthenticationResponseData::PreAuthNResponse {
+                    threeds_server_transaction_id: pre_authn_response
+                        .threeds_server_trans_id
+                        .clone(),
+                    maximum_supported_3ds_version: common_utils::types::SemanticVersion::from_str(
+                        &pre_authn_response.acs_end_protocol_version,
+                    )
+                    .change_context(errors::ConnectorError::ParsingFailed)?,
+                    connector_authentication_id: pre_authn_response.threeds_server_trans_id,
+                    three_ds_method_data: Some(three_ds_method_data_base64),
+                    three_ds_method_url: pre_authn_response.threeds_method_url,
+                    message_version: common_utils::types::SemanticVersion::from_str(
+                        &pre_authn_response.acs_end_protocol_version,
+                    )
+                    .change_context(errors::ConnectorError::ParsingFailed)?,
+                    connector_metadata: Some(connector_metadata),
+                    directory_server_id: None,
+                })
             }
             ThreedsecureioPreAuthenticationResponse::Failure(error_response) => {
-                Err(types::ErrorResponse {
+                Err(ErrorResponse {
                     code: error_response.error_code,
                     message: error_response
                         .error_description
@@ -139,21 +134,21 @@ impl
 
 impl
     TryFrom<
-        types::ResponseRouterData<
-            api::Authentication,
+        ResponseRouterData<
+            Authentication,
             ThreedsecureioAuthenticationResponse,
-            types::authentication::ConnectorAuthenticationRequestData,
-            types::authentication::AuthenticationResponseData,
+            ConnectorAuthenticationRequestData,
+            AuthenticationResponseData,
         >,
-    > for types::authentication::ConnectorAuthenticationRouterData
+    > for ConnectorAuthenticationRouterData
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: types::ResponseRouterData<
-            api::Authentication,
+        item: ResponseRouterData<
+            Authentication,
             ThreedsecureioAuthenticationResponse,
-            types::authentication::ConnectorAuthenticationRequestData,
-            types::authentication::AuthenticationResponseData,
+            ConnectorAuthenticationRequestData,
+            AuthenticationResponseData,
         >,
     ) -> Result<Self, Self::Error> {
         let response = match item.response {
@@ -171,61 +166,51 @@ impl
                 let creq_base64 = Engine::encode(&BASE64_ENGINE, creq_str)
                     .trim_end_matches('=')
                     .to_owned();
-                Ok(
-                    types::authentication::AuthenticationResponseData::AuthNResponse {
-                        trans_status: response.trans_status.clone().into(),
-                        authn_flow_type: if response.trans_status == ThreedsecureioTransStatus::C {
-                            types::authentication::AuthNFlowType::Challenge(Box::new(
-                                ChallengeParams {
-                                    acs_url: response.acs_url,
-                                    challenge_request: Some(creq_base64),
-                                    acs_reference_number: Some(
-                                        response.acs_reference_number.clone(),
-                                    ),
-                                    acs_trans_id: Some(response.acs_trans_id.clone()),
-                                    three_dsserver_trans_id: Some(response.three_dsserver_trans_id),
-                                    acs_signed_content: response.acs_signed_content,
-                                },
-                            ))
-                        } else {
-                            types::authentication::AuthNFlowType::Frictionless
-                        },
-                        authentication_value: response.authentication_value,
-                        connector_metadata: None,
-                        ds_trans_id: Some(response.ds_trans_id),
+                Ok(AuthenticationResponseData::AuthNResponse {
+                    trans_status: response.trans_status.clone().into(),
+                    authn_flow_type: if response.trans_status == ThreedsecureioTransStatus::C {
+                        AuthNFlowType::Challenge(Box::new(ChallengeParams {
+                            acs_url: response.acs_url,
+                            challenge_request: Some(creq_base64),
+                            acs_reference_number: Some(response.acs_reference_number.clone()),
+                            acs_trans_id: Some(response.acs_trans_id.clone()),
+                            three_dsserver_trans_id: Some(response.three_dsserver_trans_id),
+                            acs_signed_content: response.acs_signed_content,
+                        }))
+                    } else {
+                        AuthNFlowType::Frictionless
                     },
-                )
+                    authentication_value: response.authentication_value,
+                    connector_metadata: None,
+                    ds_trans_id: Some(response.ds_trans_id),
+                })
             }
             ThreedsecureioAuthenticationResponse::Error(err_response) => match *err_response {
-                ThreedsecureioErrorResponseWrapper::ErrorResponse(resp) => {
-                    Err(types::ErrorResponse {
-                        code: resp.error_code,
-                        message: resp
-                            .error_description
-                            .clone()
-                            .unwrap_or(NO_ERROR_MESSAGE.to_owned()),
-                        reason: resp.error_description,
-                        status_code: item.http_code,
-                        attempt_status: None,
-                        connector_transaction_id: None,
-                        network_advice_code: None,
-                        network_decline_code: None,
-                        network_error_message: None,
-                    })
-                }
-                ThreedsecureioErrorResponseWrapper::ErrorString(error) => {
-                    Err(types::ErrorResponse {
-                        code: error.clone(),
-                        message: error.clone(),
-                        reason: Some(error),
-                        status_code: item.http_code,
-                        attempt_status: None,
-                        connector_transaction_id: None,
-                        network_advice_code: None,
-                        network_decline_code: None,
-                        network_error_message: None,
-                    })
-                }
+                ThreedsecureioErrorResponseWrapper::ErrorResponse(resp) => Err(ErrorResponse {
+                    code: resp.error_code,
+                    message: resp
+                        .error_description
+                        .clone()
+                        .unwrap_or(NO_ERROR_MESSAGE.to_owned()),
+                    reason: resp.error_description,
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: None,
+                    network_advice_code: None,
+                    network_decline_code: None,
+                    network_error_message: None,
+                }),
+                ThreedsecureioErrorResponseWrapper::ErrorString(error) => Err(ErrorResponse {
+                    code: error.clone(),
+                    message: error.clone(),
+                    reason: Some(error),
+                    status_code: item.http_code,
+                    attempt_status: None,
+                    connector_transaction_id: None,
+                    network_advice_code: None,
+                    network_decline_code: None,
+                    network_error_message: None,
+                }),
             },
         };
         Ok(Self {
@@ -239,11 +224,11 @@ pub struct ThreedsecureioAuthType {
     pub(super) api_key: Secret<String>,
 }
 
-impl TryFrom<&types::ConnectorAuthType> for ThreedsecureioAuthType {
+impl TryFrom<&ConnectorAuthType> for ThreedsecureioAuthType {
     type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
+    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()),
@@ -251,17 +236,17 @@ impl TryFrom<&types::ConnectorAuthType> for ThreedsecureioAuthType {
     }
 }
 
-impl TryFrom<&ThreedsecureioRouterData<&types::authentication::ConnectorAuthenticationRouterData>>
+impl TryFrom<&ThreedsecureioRouterData<&ConnectorAuthenticationRouterData>>
     for ThreedsecureioAuthenticationRequest
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: &ThreedsecureioRouterData<&types::authentication::ConnectorAuthenticationRouterData>,
+        item: &ThreedsecureioRouterData<&ConnectorAuthenticationRouterData>,
     ) -> Result<Self, Self::Error> {
         let request = &item.router_data.request;
         //browser_details are mandatory for Browser flows
         let browser_details = match request.browser_details.clone() {
-            Some(details) => Ok::<Option<types::BrowserInformation>, Self::Error>(Some(details)),
+            Some(details) => Ok::<Option<BrowserInformation>, Self::Error>(Some(details)),
             None => {
                 if request.device_channel == DeviceChannel::Browser {
                     Err(errors::ConnectorError::MissingRequiredField {
@@ -693,13 +678,13 @@ pub struct ThreedsecureioPreAuthenticationResponseData {
     pub message_type: Option<String>,
 }
 
-impl TryFrom<&ThreedsecureioRouterData<&types::authentication::PreAuthNRouterData>>
+impl TryFrom<&ThreedsecureioRouterData<&PreAuthNRouterData>>
     for ThreedsecureioPreAuthenticationRequest
 {
     type Error = error_stack::Report<errors::ConnectorError>;
 
     fn try_from(
-        value: &ThreedsecureioRouterData<&types::authentication::PreAuthNRouterData>,
+        value: &ThreedsecureioRouterData<&PreAuthNRouterData>,
     ) -> Result<Self, Self::Error> {
         let router_data = value.router_data;
         Ok(Self {
diff --git a/crates/router/src/connector/wellsfargopayout.rs b/crates/hyperswitch_connectors/src/connectors/wellsfargopayout.rs
similarity index 50%
rename from crates/router/src/connector/wellsfargopayout.rs
rename to crates/hyperswitch_connectors/src/connectors/wellsfargopayout.rs
index 8ed0c1dbd3b..d76bf386877 100644
--- a/crates/router/src/connector/wellsfargopayout.rs
+++ b/crates/hyperswitch_connectors/src/connectors/wellsfargopayout.rs
@@ -1,28 +1,48 @@
 pub mod transformers;
 
-use common_utils::types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector};
+use api_models::webhooks::{IncomingWebhookEvent, ObjectReferenceId};
+use common_utils::{
+    errors::CustomResult,
+    ext_traits::BytesExt,
+    request::{Method, Request, RequestBuilder, RequestContent},
+    types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
+};
 use error_stack::{report, ResultExt};
-use masking::ExposeInterface;
-
-use self::transformers as wellsfargopayout;
-use super::utils as connector_utils;
-use crate::{
-    configs::settings,
-    core::errors::{self, CustomResult},
-    events::connector_api_logs::ConnectorEvent,
-    headers,
-    services::{
-        self,
-        request::{self, Mask},
-        ConnectorIntegration, ConnectorSpecifications, ConnectorValidation,
+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::{
+        self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
+        ConnectorValidation,
     },
+    configs::Connectors,
+    errors::ConnectorError,
+    events::connector_api_logs::ConnectorEvent,
     types::{
-        self,
-        api::{self, ConnectorCommon, ConnectorCommonExt},
-        ErrorResponse, RequestContent, Response,
+        PaymentsAuthorizeType, PaymentsCaptureType, PaymentsSyncType, RefundExecuteType,
+        RefundSyncType, Response,
     },
-    utils::BytesExt,
+    webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
 };
+use masking::{ExposeInterface, Mask as _, Maskable};
+
+use self::transformers as wellsfargopayout;
+use crate::{constants::headers, types::ResponseRouterData, utils::convert_amount};
 
 #[derive(Clone)]
 pub struct Wellsfargopayout {
@@ -50,12 +70,8 @@ impl api::RefundExecute for Wellsfargopayout {}
 impl api::RefundSync for Wellsfargopayout {}
 impl api::PaymentToken for Wellsfargopayout {}
 
-impl
-    ConnectorIntegration<
-        api::PaymentMethodToken,
-        types::PaymentMethodTokenizationData,
-        types::PaymentsResponseData,
-    > for Wellsfargopayout
+impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
+    for Wellsfargopayout
 {
     // Not Implemented (R)
 }
@@ -66,9 +82,9 @@ where
 {
     fn build_headers(
         &self,
-        req: &types::RouterData<Flow, Request, Response>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &RouterData<Flow, Request, Response>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         let mut header = vec![(
             headers::CONTENT_TYPE.to_string(),
             self.get_content_type().to_string().into(),
@@ -96,16 +112,16 @@ impl ConnectorCommon for Wellsfargopayout {
         "application/json"
     }
 
-    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
+    fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
         connectors.wellsfargopayout.base_url.as_ref()
     }
 
     fn get_auth_header(
         &self,
-        auth_type: &types::ConnectorAuthType,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        auth_type: &ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         let auth = wellsfargopayout::WellsfargopayoutAuthType::try_from(auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
         Ok(vec![(
             headers::AUTHORIZATION.to_string(),
             auth.api_key.expose().into_masked(),
@@ -116,11 +132,11 @@ impl ConnectorCommon for Wellsfargopayout {
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         let response: wellsfargopayout::WellsfargopayoutErrorResponse = res
             .response
             .parse_struct("WellsfargopayoutErrorResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -143,34 +159,28 @@ impl ConnectorValidation for Wellsfargopayout {
     //TODO: implement functions when support enabled
 }
 
-impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
-    for Wellsfargopayout
-{
+impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Wellsfargopayout {
     //TODO: implement sessions flow
 }
 
-impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
+impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken>
     for Wellsfargopayout
 {
 }
 
-impl
-    ConnectorIntegration<
-        api::SetupMandate,
-        types::SetupMandateRequestData,
-        types::PaymentsResponseData,
-    > for Wellsfargopayout
+impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData>
+    for Wellsfargopayout
 {
 }
 
-impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
+impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData>
     for Wellsfargopayout
 {
     fn get_headers(
         &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PaymentsAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
@@ -180,18 +190,18 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
 
     fn get_url(
         &self,
-        _req: &types::PaymentsAuthorizeRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        _req: &PaymentsAuthorizeRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_url method".to_string()).into())
     }
 
     fn get_request_body(
         &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let amount = connector_utils::convert_amount(
+        req: &PaymentsAuthorizeRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let amount = convert_amount(
             self.amount_converter,
             req.request.minor_amount,
             req.request.currency,
@@ -206,20 +216,16 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
 
     fn build_request(
         &self,
-        req: &types::PaymentsAuthorizeRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        req: &PaymentsAuthorizeRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
         Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&types::PaymentsAuthorizeType::get_url(
-                    self, req, connectors,
-                )?)
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
                 .attach_default_headers()
-                .headers(types::PaymentsAuthorizeType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(types::PaymentsAuthorizeType::get_request_body(
+                .headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
+                .set_body(PaymentsAuthorizeType::get_request_body(
                     self, req, connectors,
                 )?)
                 .build(),
@@ -228,17 +234,17 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
 
     fn handle_response(
         &self,
-        data: &types::PaymentsAuthorizeRouterData,
+        data: &PaymentsAuthorizeRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
+    ) -> CustomResult<PaymentsAuthorizeRouterData, ConnectorError> {
         let response: wellsfargopayout::WellsfargopayoutPaymentsResponse = res
             .response
             .parse_struct("Wellsfargopayout PaymentsAuthorizeResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -249,19 +255,17 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
-impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
-    for Wellsfargopayout
-{
+impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Wellsfargopayout {
     fn get_headers(
         &self,
-        req: &types::PaymentsSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
@@ -271,40 +275,40 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
 
     fn get_url(
         &self,
-        _req: &types::PaymentsSyncRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        _req: &PaymentsSyncRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_url method".to_string()).into())
     }
 
     fn build_request(
         &self,
-        req: &types::PaymentsSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        req: &PaymentsSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
         Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Get)
-                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+            RequestBuilder::new()
+                .method(Method::Get)
+                .url(&PaymentsSyncType::get_url(self, req, connectors)?)
                 .attach_default_headers()
-                .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
+                .headers(PaymentsSyncType::get_headers(self, req, connectors)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::PaymentsSyncRouterData,
+        data: &PaymentsSyncRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
+    ) -> CustomResult<PaymentsSyncRouterData, ConnectorError> {
         let response: wellsfargopayout::WellsfargopayoutPaymentsResponse = res
             .response
             .parse_struct("wellsfargopayout PaymentsSyncResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -315,19 +319,17 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
-impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
-    for Wellsfargopayout
-{
+impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Wellsfargopayout {
     fn get_headers(
         &self,
-        req: &types::PaymentsCaptureRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
@@ -337,34 +339,32 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
 
     fn get_url(
         &self,
-        _req: &types::PaymentsCaptureRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        _req: &PaymentsCaptureRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(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())
+        _req: &PaymentsCaptureRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        Err(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> {
+        req: &PaymentsCaptureRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
         Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&PaymentsCaptureType::get_url(self, req, connectors)?)
                 .attach_default_headers()
-                .headers(types::PaymentsCaptureType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(types::PaymentsCaptureType::get_request_body(
+                .headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
+                .set_body(PaymentsCaptureType::get_request_body(
                     self, req, connectors,
                 )?)
                 .build(),
@@ -373,17 +373,17 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
 
     fn handle_response(
         &self,
-        data: &types::PaymentsCaptureRouterData,
+        data: &PaymentsCaptureRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<types::PaymentsCaptureRouterData, errors::ConnectorError> {
+    ) -> CustomResult<PaymentsCaptureRouterData, ConnectorError> {
         let response: wellsfargopayout::WellsfargopayoutPaymentsResponse = res
             .response
             .parse_struct("Wellsfargopayout PaymentsCaptureResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -394,24 +394,19 @@ impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::Payme
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
-impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
-    for Wellsfargopayout
-{
-}
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Wellsfargopayout {}
 
-impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
-    for Wellsfargopayout
-{
+impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Wellsfargopayout {
     fn get_headers(
         &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &RefundsRouterData<Execute>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
@@ -421,18 +416,18 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
 
     fn get_url(
         &self,
-        _req: &types::RefundsRouterData<api::Execute>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        _req: &RefundsRouterData<Execute>,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_url method".to_string()).into())
     }
 
     fn get_request_body(
         &self,
-        req: &types::RefundsRouterData<api::Execute>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let refund_amount = connector_utils::convert_amount(
+        req: &RefundsRouterData<Execute>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
+        let refund_amount = convert_amount(
             self.amount_converter,
             req.request.minor_refund_amount,
             req.request.currency,
@@ -447,36 +442,32 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
 
     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)?)
+        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(types::RefundExecuteType::get_headers(
-                self, req, connectors,
-            )?)
-            .set_body(types::RefundExecuteType::get_request_body(
-                self, req, connectors,
-            )?)
+            .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: &types::RefundsRouterData<api::Execute>,
+        data: &RefundsRouterData<Execute>,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
+    ) -> CustomResult<RefundsRouterData<Execute>, ConnectorError> {
         let response: wellsfargopayout::RefundResponse = res
             .response
             .parse_struct("wellsfargopayout RefundResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -487,19 +478,17 @@ impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsRespon
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
-impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
-    for Wellsfargopayout
-{
+impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Wellsfargopayout {
     fn get_headers(
         &self,
-        req: &types::RefundSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
@@ -509,43 +498,41 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
 
     fn get_url(
         &self,
-        _req: &types::RefundSyncRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented("get_url method".to_string()).into())
+        _req: &RefundSyncRouterData,
+        _connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
+        Err(ConnectorError::NotImplemented("get_url method".to_string()).into())
     }
 
     fn build_request(
         &self,
-        req: &types::RefundSyncRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        req: &RefundSyncRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
         Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Get)
-                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+            RequestBuilder::new()
+                .method(Method::Get)
+                .url(&RefundSyncType::get_url(self, req, connectors)?)
                 .attach_default_headers()
-                .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
-                .set_body(types::RefundSyncType::get_request_body(
-                    self, req, connectors,
-                )?)
+                .headers(RefundSyncType::get_headers(self, req, connectors)?)
+                .set_body(RefundSyncType::get_request_body(self, req, connectors)?)
                 .build(),
         ))
     }
 
     fn handle_response(
         &self,
-        data: &types::RefundSyncRouterData,
+        data: &RefundSyncRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<types::RefundSyncRouterData, errors::ConnectorError> {
+    ) -> CustomResult<RefundSyncRouterData, ConnectorError> {
         let response: wellsfargopayout::RefundResponse = res
             .response
             .parse_struct("wellsfargopayout RefundSyncResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -556,32 +543,32 @@ impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponse
         &self,
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
 #[async_trait::async_trait]
-impl api::IncomingWebhook for Wellsfargopayout {
+impl IncomingWebhook for Wellsfargopayout {
     fn get_webhook_object_reference_id(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<ObjectReferenceId, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 
     fn get_webhook_event_type(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 
     fn get_webhook_resource_object(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 }
 
diff --git a/crates/router/src/connector/wellsfargopayout/transformers.rs b/crates/hyperswitch_connectors/src/connectors/wellsfargopayout/transformers.rs
similarity index 60%
rename from crates/router/src/connector/wellsfargopayout/transformers.rs
rename to crates/hyperswitch_connectors/src/connectors/wellsfargopayout/transformers.rs
index 3a194550dfd..ebe3a3fd1b9 100644
--- a/crates/router/src/connector/wellsfargopayout/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/wellsfargopayout/transformers.rs
@@ -1,11 +1,20 @@
+use common_enums::{AttemptStatus, RefundStatus};
 use common_utils::types::StringMinorUnit;
+use hyperswitch_domain_models::{
+    payment_method_data::PaymentMethodData,
+    router_data::{ConnectorAuthType, RouterData},
+    router_flow_types::{Execute, RSync},
+    router_request_types::ResponseId,
+    router_response_types::{PaymentsResponseData, RefundsResponseData},
+    types::{PaymentsAuthorizeRouterData, RefundsRouterData},
+};
+use hyperswitch_interfaces::errors::ConnectorError;
 use masking::Secret;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    connector::utils::PaymentsAuthorizeRequestData,
-    core::errors,
-    types::{self, api, domain, storage::enums},
+    types::{RefundsResponseRouterData, ResponseRouterData},
+    utils::PaymentsAuthorizeRequestData as _,
 };
 
 //TODO: Fill the struct with respective fields
@@ -40,15 +49,15 @@ pub struct WellsfargopayoutCard {
     complete: bool,
 }
 
-impl TryFrom<&WellsfargopayoutRouterData<&types::PaymentsAuthorizeRouterData>>
+impl TryFrom<&WellsfargopayoutRouterData<&PaymentsAuthorizeRouterData>>
     for WellsfargopayoutPaymentsRequest
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: &WellsfargopayoutRouterData<&types::PaymentsAuthorizeRouterData>,
+        item: &WellsfargopayoutRouterData<&PaymentsAuthorizeRouterData>,
     ) -> Result<Self, Self::Error> {
         match item.router_data.request.payment_method_data.clone() {
-            domain::PaymentMethodData::Card(req_card) => {
+            PaymentMethodData::Card(req_card) => {
                 let card = WellsfargopayoutCard {
                     number: req_card.card_number,
                     expiry_month: req_card.card_exp_month,
@@ -61,7 +70,7 @@ impl TryFrom<&WellsfargopayoutRouterData<&types::PaymentsAuthorizeRouterData>>
                     card,
                 })
             }
-            _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
+            _ => Err(ConnectorError::NotImplemented("Payment methods".to_string()).into()),
         }
     }
 }
@@ -72,14 +81,14 @@ pub struct WellsfargopayoutAuthType {
     pub(super) api_key: Secret<String>,
 }
 
-impl TryFrom<&types::ConnectorAuthType> for WellsfargopayoutAuthType {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
+impl TryFrom<&ConnectorAuthType> for WellsfargopayoutAuthType {
+    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()),
         }
     }
 }
@@ -94,7 +103,7 @@ pub enum WellsfargopayoutPaymentStatus {
     Processing,
 }
 
-impl From<WellsfargopayoutPaymentStatus> for enums::AttemptStatus {
+impl From<WellsfargopayoutPaymentStatus> for AttemptStatus {
     fn from(item: WellsfargopayoutPaymentStatus) -> Self {
         match item {
             WellsfargopayoutPaymentStatus::Succeeded => Self::Charged,
@@ -111,29 +120,17 @@ pub struct WellsfargopayoutPaymentsResponse {
     id: String,
 }
 
-impl<F, T>
-    TryFrom<
-        types::ResponseRouterData<
-            F,
-            WellsfargopayoutPaymentsResponse,
-            T,
-            types::PaymentsResponseData,
-        >,
-    > for types::RouterData<F, T, types::PaymentsResponseData>
+impl<F, T> TryFrom<ResponseRouterData<F, WellsfargopayoutPaymentsResponse, 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,
-            WellsfargopayoutPaymentsResponse,
-            T,
-            types::PaymentsResponseData,
-        >,
+        item: ResponseRouterData<F, WellsfargopayoutPaymentsResponse, T, PaymentsResponseData>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
-            status: enums::AttemptStatus::from(item.response.status),
-            response: Ok(types::PaymentsResponseData::TransactionResponse {
-                resource_id: types::ResponseId::ConnectorTransactionId(item.response.id),
+            status: AttemptStatus::from(item.response.status),
+            response: Ok(PaymentsResponseData::TransactionResponse {
+                resource_id: ResponseId::ConnectorTransactionId(item.response.id),
                 redirection_data: Box::new(None),
                 mandate_reference: Box::new(None),
                 connector_metadata: None,
@@ -155,12 +152,12 @@ pub struct WellsfargopayoutRefundRequest {
     pub amount: StringMinorUnit,
 }
 
-impl<F> TryFrom<&WellsfargopayoutRouterData<&types::RefundsRouterData<F>>>
+impl<F> TryFrom<&WellsfargopayoutRouterData<&RefundsRouterData<F>>>
     for WellsfargopayoutRefundRequest
 {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(
-        item: &WellsfargopayoutRouterData<&types::RefundsRouterData<F>>,
+        item: &WellsfargopayoutRouterData<&RefundsRouterData<F>>,
     ) -> Result<Self, Self::Error> {
         Ok(Self {
             amount: item.amount.to_owned(),
@@ -172,19 +169,19 @@ impl<F> TryFrom<&WellsfargopayoutRouterData<&types::RefundsRouterData<F>>>
 
 #[allow(dead_code)]
 #[derive(Debug, Serialize, Default, Deserialize, Clone)]
-pub enum RefundStatus {
+pub enum WellsfargopayoutRefundStatus {
     Succeeded,
     Failed,
     #[default]
     Processing,
 }
 
-impl From<RefundStatus> for enums::RefundStatus {
-    fn from(item: RefundStatus) -> Self {
+impl From<WellsfargopayoutRefundStatus> for RefundStatus {
+    fn from(item: WellsfargopayoutRefundStatus) -> Self {
         match item {
-            RefundStatus::Succeeded => Self::Success,
-            RefundStatus::Failed => Self::Failure,
-            RefundStatus::Processing => Self::Pending,
+            WellsfargopayoutRefundStatus::Succeeded => Self::Success,
+            WellsfargopayoutRefundStatus::Failed => Self::Failure,
+            WellsfargopayoutRefundStatus::Processing => Self::Pending,
             //TODO: Review mapping
         }
     }
@@ -194,37 +191,33 @@ impl From<RefundStatus> for enums::RefundStatus {
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct RefundResponse {
     id: String,
-    status: RefundStatus,
+    status: WellsfargopayoutRefundStatus,
 }
 
-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/router/src/connector/wise.rs b/crates/hyperswitch_connectors/src/connectors/wise.rs
similarity index 50%
rename from crates/router/src/connector/wise.rs
rename to crates/hyperswitch_connectors/src/connectors/wise.rs
index 0ee45b22f9f..1041a6e7b2b 100644
--- a/crates/router/src/connector/wise.rs
+++ b/crates/hyperswitch_connectors/src/connectors/wise.rs
@@ -1,41 +1,68 @@
 pub mod transformers;
 
+use api_models::webhooks::IncomingWebhookEvent;
+#[cfg(feature = "payouts")]
+use common_utils::request::{Method, RequestBuilder, RequestContent};
 #[cfg(feature = "payouts")]
-use common_utils::request::RequestContent;
 use common_utils::types::{AmountConvertor, MinorUnit, MinorUnitForConnector};
+use common_utils::{errors::CustomResult, ext_traits::ByteSliceExt, request::Request};
 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},
+};
+#[cfg(feature = "payouts")]
+use hyperswitch_domain_models::{
+    router_flow_types::{PoCancel, PoCreate, PoEligibility, PoFulfill, PoQuote, PoRecipient},
+    types::{PayoutsData, PayoutsResponseData, PayoutsRouterData},
+};
+#[cfg(feature = "payouts")]
+use hyperswitch_interfaces::types::PayoutQuoteType;
+#[cfg(feature = "payouts")]
+use hyperswitch_interfaces::types::{
+    PayoutCancelType, PayoutCreateType, PayoutFulfillType, PayoutRecipientType,
+};
+use hyperswitch_interfaces::{
+    api::{
+        self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
+        Refund, RefundExecute, RefundSync,
+    },
+    configs::Connectors,
+    errors::ConnectorError,
+    events::connector_api_logs::ConnectorEvent,
+    types::Response,
+    webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
+};
 #[cfg(feature = "payouts")]
 use masking::PeekInterface;
+use masking::{Mask as _, Maskable};
 #[cfg(feature = "payouts")]
 use router_env::{instrument, tracing};
 
 use self::transformers as wise;
-use super::utils::convert_amount;
-use crate::{
-    configs::settings,
-    core::errors::{self, CustomResult},
-    events::connector_api_logs::ConnectorEvent,
-    headers,
-    services::{
-        self,
-        request::{self, Mask},
-        ConnectorSpecifications, ConnectorValidation,
-    },
-    types::{
-        self,
-        api::{self, ConnectorCommon, ConnectorCommonExt},
-    },
-    utils::BytesExt,
-};
+use crate::constants::headers;
+#[cfg(feature = "payouts")]
+use crate::{types::ResponseRouterData, utils::convert_amount};
 
 #[derive(Clone)]
 pub struct Wise {
+    #[cfg(feature = "payouts")]
     amount_converter: &'static (dyn AmountConvertor<Output = MinorUnit> + Sync),
 }
 
 impl Wise {
     pub fn new() -> &'static Self {
         &Self {
+            #[cfg(feature = "payouts")]
             amount_converter: &MinorUnitForConnector,
         }
     }
@@ -43,22 +70,22 @@ impl Wise {
 
 impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Wise
 where
-    Self: services::ConnectorIntegration<Flow, Request, Response>,
+    Self: ConnectorIntegration<Flow, Request, Response>,
 {
     #[cfg(feature = "payouts")]
     fn build_headers(
         &self,
-        req: &types::RouterData<Flow, Request, Response>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &RouterData<Flow, Request, Response>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
+        use masking::Mask as _;
+
         let mut header = vec![(
             headers::CONTENT_TYPE.to_string(),
-            types::PayoutQuoteType::get_content_type(self)
-                .to_string()
-                .into(),
+            PayoutQuoteType::get_content_type(self).to_string().into(),
         )];
         let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
         let mut api_key = vec![(
             headers::AUTHORIZATION.to_string(),
             auth.api_key.into_masked(),
@@ -75,29 +102,29 @@ impl ConnectorCommon for Wise {
 
     fn get_auth_header(
         &self,
-        auth_type: &types::ConnectorAuthType,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        auth_type: &ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         let auth = wise::WiseAuthType::try_from(auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
         Ok(vec![(
             headers::AUTHORIZATION.to_string(),
             auth.api_key.into_masked(),
         )])
     }
 
-    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
+    fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
         connectors.wise.base_url.as_ref()
     }
 
     fn build_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         let response: wise::ErrorResponse = res
             .response
             .parse_struct("ErrorResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -106,7 +133,7 @@ impl ConnectorCommon for Wise {
         match response.errors {
             Some(errs) => {
                 if let Some(e) = errs.first() {
-                    Ok(types::ErrorResponse {
+                    Ok(ErrorResponse {
                         status_code: res.status_code,
                         code: e.code.clone(),
                         message: e.message.clone(),
@@ -118,7 +145,7 @@ impl ConnectorCommon for Wise {
                         network_error_message: None,
                     })
                 } else {
-                    Ok(types::ErrorResponse {
+                    Ok(ErrorResponse {
                         status_code: res.status_code,
                         code: default_status,
                         message: response.message.unwrap_or_default(),
@@ -131,7 +158,7 @@ impl ConnectorCommon for Wise {
                     })
                 }
             }
-            None => Ok(types::ErrorResponse {
+            None => Ok(ErrorResponse {
                 status_code: res.status_code,
                 code: default_status,
                 message: response.message.unwrap_or_default(),
@@ -154,92 +181,36 @@ impl api::PaymentCapture for Wise {}
 impl api::MandateSetup for Wise {}
 impl api::ConnectorAccessToken for Wise {}
 impl api::PaymentToken for Wise {}
-impl ConnectorValidation for Wise {}
-
-impl
-    services::ConnectorIntegration<
-        api::PaymentMethodToken,
-        types::PaymentMethodTokenizationData,
-        types::PaymentsResponseData,
-    > for Wise
-{
-}
+impl api::ConnectorValidation for Wise {}
 
-impl
-    services::ConnectorIntegration<
-        api::AccessTokenAuth,
-        types::AccessTokenRequestData,
-        types::AccessToken,
-    > for Wise
+impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
+    for Wise
 {
 }
 
-impl
-    services::ConnectorIntegration<
-        api::SetupMandate,
-        types::SetupMandateRequestData,
-        types::PaymentsResponseData,
-    > for Wise
-{
+impl ConnectorIntegration<AccessTokenAuth, AccessTokenRequestData, AccessToken> for Wise {}
+
+impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsResponseData> for Wise {
     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 Wise".to_string())
-                .into(),
-        )
+        _req: &RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        Err(ConnectorError::NotImplemented("Setup Mandate flow for Wise".to_string()).into())
     }
 }
 
 impl api::PaymentSession for Wise {}
 
-impl
-    services::ConnectorIntegration<
-        api::Session,
-        types::PaymentsSessionData,
-        types::PaymentsResponseData,
-    > for Wise
-{
-}
+impl ConnectorIntegration<Session, PaymentsSessionData, PaymentsResponseData> for Wise {}
 
-impl
-    services::ConnectorIntegration<
-        api::Capture,
-        types::PaymentsCaptureData,
-        types::PaymentsResponseData,
-    > for Wise
-{
-}
+impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> for Wise {}
 
-impl
-    services::ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
-    for Wise
-{
-}
+impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Wise {}
 
-impl
-    services::ConnectorIntegration<
-        api::Authorize,
-        types::PaymentsAuthorizeData,
-        types::PaymentsResponseData,
-    > for Wise
-{
-}
+impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData> for Wise {}
 
-impl
-    services::ConnectorIntegration<
-        api::Void,
-        types::PaymentsCancelData,
-        types::PaymentsResponseData,
-    > for Wise
-{
-}
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Wise {}
 
 impl api::Payouts for Wise {}
 #[cfg(feature = "payouts")]
@@ -256,16 +227,14 @@ impl api::PayoutRecipient for Wise {}
 impl api::PayoutFulfill for Wise {}
 
 #[cfg(feature = "payouts")]
-impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::PayoutsResponseData>
-    for Wise
-{
+impl ConnectorIntegration<PoCancel, PayoutsData, PayoutsResponseData> for Wise {
     fn get_url(
         &self,
-        req: &types::PayoutsRouterData<api::PoCancel>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoCancel>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
         let transfer_id = req.request.connector_payout_id.clone().ok_or(
-            errors::ConnectorError::MissingRequiredField {
+            ConnectorError::MissingRequiredField {
                 field_name: "transfer_id",
             },
         )?;
@@ -277,22 +246,22 @@ impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::Pa
 
     fn get_headers(
         &self,
-        req: &types::PayoutsRouterData<api::PoCancel>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoCancel>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, _connectors)
     }
 
     fn build_request(
         &self,
-        req: &types::PayoutsRouterData<api::PoCancel>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Put)
-            .url(&types::PayoutCancelType::get_url(self, req, connectors)?)
+        req: &PayoutsRouterData<PoCancel>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Put)
+            .url(&PayoutCancelType::get_url(self, req, connectors)?)
             .attach_default_headers()
-            .headers(types::PayoutCancelType::get_headers(self, req, connectors)?)
+            .headers(PayoutCancelType::get_headers(self, req, connectors)?)
             .build();
 
         Ok(Some(request))
@@ -301,19 +270,19 @@ impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::Pa
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::PayoutsRouterData<api::PoCancel>,
+        data: &PayoutsRouterData<PoCancel>,
         event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PayoutsRouterData<api::PoCancel>, errors::ConnectorError> {
+        res: Response,
+    ) -> CustomResult<PayoutsRouterData<PoCancel>, ConnectorError> {
         let response: wise::WisePayoutResponse = res
             .response
             .parse_struct("WisePayoutResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -322,13 +291,13 @@ impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::Pa
 
     fn get_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         let response: wise::ErrorResponse = res
             .response
             .parse_struct("ErrorResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_error_response_body(&response));
         router_env::logger::info!(connector_response=?response);
@@ -340,7 +309,7 @@ impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::Pa
         } else {
             (def_res, response.message.unwrap_or_default())
         };
-        Ok(types::ErrorResponse {
+        Ok(ErrorResponse {
             status_code: res.status_code,
             code,
             message,
@@ -355,16 +324,14 @@ impl services::ConnectorIntegration<api::PoCancel, types::PayoutsData, types::Pa
 }
 
 #[cfg(feature = "payouts")]
-impl services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::PayoutsResponseData>
-    for Wise
-{
+impl ConnectorIntegration<PoQuote, PayoutsData, PayoutsResponseData> for Wise {
     fn get_url(
         &self,
-        req: &types::PayoutsRouterData<api::PoQuote>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoQuote>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
         let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
         Ok(format!(
             "{}v3/profiles/{}/quotes",
             connectors.wise.base_url,
@@ -374,17 +341,17 @@ impl services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::Pay
 
     fn get_headers(
         &self,
-        req: &types::PayoutsRouterData<api::PoQuote>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoQuote>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
     fn get_request_body(
         &self,
-        req: &types::PayoutsRouterData<api::PoQuote>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoQuote>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
         let amount = convert_amount(
             self.amount_converter,
             req.request.minor_amount,
@@ -397,17 +364,15 @@ impl services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::Pay
 
     fn build_request(
         &self,
-        req: &types::PayoutsRouterData<api::PoQuote>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Post)
-            .url(&types::PayoutQuoteType::get_url(self, req, connectors)?)
+        req: &PayoutsRouterData<PoQuote>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&PayoutQuoteType::get_url(self, req, connectors)?)
             .attach_default_headers()
-            .headers(types::PayoutQuoteType::get_headers(self, req, connectors)?)
-            .set_body(types::PayoutQuoteType::get_request_body(
-                self, req, connectors,
-            )?)
+            .headers(PayoutQuoteType::get_headers(self, req, connectors)?)
+            .set_body(PayoutQuoteType::get_request_body(self, req, connectors)?)
             .build();
 
         Ok(Some(request))
@@ -416,19 +381,19 @@ impl services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::Pay
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::PayoutsRouterData<api::PoQuote>,
+        data: &PayoutsRouterData<PoQuote>,
         event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PayoutsRouterData<api::PoQuote>, errors::ConnectorError> {
+        res: Response,
+    ) -> CustomResult<PayoutsRouterData<PoQuote>, ConnectorError> {
         let response: wise::WisePayoutQuoteResponse = res
             .response
             .parse_struct("WisePayoutQuoteResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -437,39 +402,36 @@ impl services::ConnectorIntegration<api::PoQuote, types::PayoutsData, types::Pay
 
     fn get_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
 #[cfg(feature = "payouts")]
-impl
-    services::ConnectorIntegration<api::PoRecipient, types::PayoutsData, types::PayoutsResponseData>
-    for Wise
-{
+impl ConnectorIntegration<PoRecipient, PayoutsData, PayoutsResponseData> for Wise {
     fn get_url(
         &self,
-        _req: &types::PayoutsRouterData<api::PoRecipient>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
+        _req: &PayoutsRouterData<PoRecipient>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
         Ok(format!("{}v1/accounts", connectors.wise.base_url))
     }
 
     fn get_headers(
         &self,
-        req: &types::PayoutsRouterData<api::PoRecipient>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoRecipient>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
     fn get_request_body(
         &self,
-        req: &types::PayoutsRouterData<api::PoRecipient>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoRecipient>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
         let amount = convert_amount(
             self.amount_converter,
             req.request.minor_amount,
@@ -482,17 +444,15 @@ impl
 
     fn build_request(
         &self,
-        req: &types::PayoutsRouterData<api::PoRecipient>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Post)
-            .url(&types::PayoutRecipientType::get_url(self, req, connectors)?)
+        req: &PayoutsRouterData<PoRecipient>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&PayoutRecipientType::get_url(self, req, connectors)?)
             .attach_default_headers()
-            .headers(types::PayoutRecipientType::get_headers(
-                self, req, connectors,
-            )?)
-            .set_body(types::PayoutRecipientType::get_request_body(
+            .headers(PayoutRecipientType::get_headers(self, req, connectors)?)
+            .set_body(PayoutRecipientType::get_request_body(
                 self, req, connectors,
             )?)
             .build();
@@ -503,19 +463,19 @@ impl
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::PayoutsRouterData<api::PoRecipient>,
+        data: &PayoutsRouterData<PoRecipient>,
         event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PayoutsRouterData<api::PoRecipient>, errors::ConnectorError> {
+        res: Response,
+    ) -> CustomResult<PayoutsRouterData<PoRecipient>, ConnectorError> {
         let response: wise::WiseRecipientCreateResponse = res
             .response
             .parse_struct("WiseRecipientCreateResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -524,56 +484,52 @@ impl
 
     fn get_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
 #[async_trait::async_trait]
 #[cfg(feature = "payouts")]
-impl services::ConnectorIntegration<api::PoCreate, types::PayoutsData, types::PayoutsResponseData>
-    for Wise
-{
+impl ConnectorIntegration<PoCreate, PayoutsData, PayoutsResponseData> for Wise {
     fn get_url(
         &self,
-        _req: &types::PayoutsRouterData<api::PoCreate>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
+        _req: &PayoutsRouterData<PoCreate>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
         Ok(format!("{}/v1/transfers", connectors.wise.base_url))
     }
 
     fn get_headers(
         &self,
-        req: &types::PayoutsRouterData<api::PoCreate>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoCreate>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
     fn get_request_body(
         &self,
-        req: &types::PayoutsRouterData<api::PoCreate>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoCreate>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
         let connector_req = wise::WisePayoutCreateRequest::try_from(req)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
         &self,
-        req: &types::PayoutsRouterData<api::PoCreate>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Post)
-            .url(&types::PayoutCreateType::get_url(self, req, connectors)?)
+        req: &PayoutsRouterData<PoCreate>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&PayoutCreateType::get_url(self, req, connectors)?)
             .attach_default_headers()
-            .headers(types::PayoutCreateType::get_headers(self, req, connectors)?)
-            .set_body(types::PayoutCreateType::get_request_body(
-                self, req, connectors,
-            )?)
+            .headers(PayoutCreateType::get_headers(self, req, connectors)?)
+            .set_body(PayoutCreateType::get_request_body(self, req, connectors)?)
             .build();
 
         Ok(Some(request))
@@ -582,19 +538,19 @@ impl services::ConnectorIntegration<api::PoCreate, types::PayoutsData, types::Pa
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::PayoutsRouterData<api::PoCreate>,
+        data: &PayoutsRouterData<PoCreate>,
         event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PayoutsRouterData<api::PoCreate>, errors::ConnectorError> {
+        res: Response,
+    ) -> CustomResult<PayoutsRouterData<PoCreate>, ConnectorError> {
         let response: wise::WisePayoutResponse = res
             .response
             .parse_struct("WisePayoutResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -603,47 +559,36 @@ impl services::ConnectorIntegration<api::PoCreate, types::PayoutsData, types::Pa
 
     fn get_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
 #[cfg(feature = "payouts")]
-impl
-    services::ConnectorIntegration<
-        api::PoEligibility,
-        types::PayoutsData,
-        types::PayoutsResponseData,
-    > for Wise
-{
+impl ConnectorIntegration<PoEligibility, PayoutsData, PayoutsResponseData> for Wise {
     fn build_request(
         &self,
-        _req: &types::PayoutsRouterData<api::PoEligibility>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        _req: &PayoutsRouterData<PoEligibility>,
+        _connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
         // Eligibility check for cards is not implemented
-        Err(
-            errors::ConnectorError::NotImplemented("Payout Eligibility for Wise".to_string())
-                .into(),
-        )
+        Err(ConnectorError::NotImplemented("Payout Eligibility for Wise".to_string()).into())
     }
 }
 
 #[cfg(feature = "payouts")]
-impl services::ConnectorIntegration<api::PoFulfill, types::PayoutsData, types::PayoutsResponseData>
-    for Wise
-{
+impl ConnectorIntegration<PoFulfill, PayoutsData, PayoutsResponseData> for Wise {
     fn get_url(
         &self,
-        req: &types::PayoutsRouterData<api::PoFulfill>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoFulfill>,
+        connectors: &Connectors,
+    ) -> CustomResult<String, ConnectorError> {
         let auth = wise::WiseAuthType::try_from(&req.connector_auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+            .change_context(ConnectorError::FailedToObtainAuthType)?;
         let transfer_id = req.request.connector_payout_id.to_owned().ok_or(
-            errors::ConnectorError::MissingRequiredField {
+            ConnectorError::MissingRequiredField {
                 field_name: "transfer_id",
             },
         )?;
@@ -657,36 +602,32 @@ impl services::ConnectorIntegration<api::PoFulfill, types::PayoutsData, types::P
 
     fn get_headers(
         &self,
-        req: &types::PayoutsRouterData<api::PoFulfill>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoFulfill>,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, Maskable<String>)>, ConnectorError> {
         self.build_headers(req, connectors)
     }
 
     fn get_request_body(
         &self,
-        req: &types::PayoutsRouterData<api::PoFulfill>,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
+        req: &PayoutsRouterData<PoFulfill>,
+        _connectors: &Connectors,
+    ) -> CustomResult<RequestContent, ConnectorError> {
         let connector_req = wise::WisePayoutFulfillRequest::try_from(req)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
     fn build_request(
         &self,
-        req: &types::PayoutsRouterData<api::PoFulfill>,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        let request = services::RequestBuilder::new()
-            .method(services::Method::Post)
-            .url(&types::PayoutFulfillType::get_url(self, req, connectors)?)
+        req: &PayoutsRouterData<PoFulfill>,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, ConnectorError> {
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&PayoutFulfillType::get_url(self, req, connectors)?)
             .attach_default_headers()
-            .headers(types::PayoutFulfillType::get_headers(
-                self, req, connectors,
-            )?)
-            .set_body(types::PayoutFulfillType::get_request_body(
-                self, req, connectors,
-            )?)
+            .headers(PayoutFulfillType::get_headers(self, req, connectors)?)
+            .set_body(PayoutFulfillType::get_request_body(self, req, connectors)?)
             .build();
 
         Ok(Some(request))
@@ -695,19 +636,19 @@ impl services::ConnectorIntegration<api::PoFulfill, types::PayoutsData, types::P
     #[instrument(skip_all)]
     fn handle_response(
         &self,
-        data: &types::PayoutsRouterData<api::PoFulfill>,
+        data: &PayoutsRouterData<PoFulfill>,
         event_builder: Option<&mut ConnectorEvent>,
-        res: types::Response,
-    ) -> CustomResult<types::PayoutsRouterData<api::PoFulfill>, errors::ConnectorError> {
+        res: Response,
+    ) -> CustomResult<PayoutsRouterData<PoFulfill>, ConnectorError> {
         let response: wise::WiseFulfillResponse = res
             .response
             .parse_struct("WiseFulfillResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+            .change_context(ConnectorError::ResponseDeserializationFailed)?;
 
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        types::RouterData::try_from(types::ResponseRouterData {
+        RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
@@ -716,48 +657,42 @@ impl services::ConnectorIntegration<api::PoFulfill, types::PayoutsData, types::P
 
     fn get_error_response(
         &self,
-        res: types::Response,
+        res: Response,
         event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+    ) -> CustomResult<ErrorResponse, ConnectorError> {
         self.build_error_response(res, event_builder)
     }
 }
 
-impl api::Refund for Wise {}
-impl api::RefundExecute for Wise {}
-impl api::RefundSync for Wise {}
+impl Refund for Wise {}
+impl RefundExecute for Wise {}
+impl RefundSync for Wise {}
 
-impl services::ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
-    for Wise
-{
-}
+impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Wise {}
 
-impl services::ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
-    for Wise
-{
-}
+impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Wise {}
 
 #[async_trait::async_trait]
-impl api::IncomingWebhook for Wise {
+impl IncomingWebhook for Wise {
     fn get_webhook_object_reference_id(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 
     fn get_webhook_event_type(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<IncomingWebhookEvent, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 
     fn get_webhook_resource_object(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
+        _request: &IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, ConnectorError> {
+        Err(report!(ConnectorError::WebhooksNotImplemented))
     }
 }
 
diff --git a/crates/router/src/connector/wise/transformers.rs b/crates/hyperswitch_connectors/src/connectors/wise/transformers.rs
similarity index 73%
rename from crates/router/src/connector/wise/transformers.rs
rename to crates/hyperswitch_connectors/src/connectors/wise/transformers.rs
index d3e9efa0f7f..1a9ff7bf89f 100644
--- a/crates/router/src/connector/wise/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/wise/transformers.rs
@@ -1,22 +1,30 @@
 #[cfg(feature = "payouts")]
+use api_models::payouts::Bank;
+#[cfg(feature = "payouts")]
 use api_models::payouts::PayoutMethodData;
 #[cfg(feature = "payouts")]
+use common_enums::PayoutEntityType;
+#[cfg(feature = "payouts")]
+use common_enums::{CountryAlpha2, PayoutStatus, PayoutType};
+#[cfg(feature = "payouts")]
 use common_utils::pii::Email;
 use common_utils::types::MinorUnit;
+use hyperswitch_domain_models::router_data::ConnectorAuthType;
+#[cfg(feature = "payouts")]
+use hyperswitch_domain_models::types::{PayoutsResponseData, PayoutsRouterData};
+use hyperswitch_interfaces::errors::ConnectorError;
 use masking::Secret;
 use serde::{Deserialize, Serialize};
 
-type Error = error_stack::Report<errors::ConnectorError>;
-
 #[cfg(feature = "payouts")]
-use crate::{
-    connector::utils::{self, PayoutsData, RouterData},
-    types::{
-        api::payouts,
-        storage::enums::{self as storage_enums, PayoutEntityType},
-    },
-};
-use crate::{core::errors, types};
+use crate::types::PayoutsResponseRouterData;
+#[cfg(feature = "payouts")]
+use crate::utils::get_unimplemented_payment_method_error_message;
+#[cfg(feature = "payouts")]
+use crate::utils::{PayoutsData as _, RouterData as _};
+
+type Error = error_stack::Report<ConnectorError>;
+
 #[derive(Debug, Serialize)]
 pub struct WiseRouterData<T> {
     pub amount: MinorUnit,
@@ -38,15 +46,15 @@ pub struct WiseAuthType {
     pub(super) profile_id: Secret<String>,
 }
 
-impl TryFrom<&types::ConnectorAuthType> for WiseAuthType {
+impl TryFrom<&ConnectorAuthType> for WiseAuthType {
     type Error = Error;
-    fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
+    fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
         match auth_type {
-            types::ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
+            ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
                 api_key: api_key.to_owned(),
                 profile_id: key1.to_owned(),
             }),
-            _ => Err(errors::ConnectorError::FailedToObtainAuthType)?,
+            _ => Err(ConnectorError::FailedToObtainAuthType)?,
         }
     }
 }
@@ -141,8 +149,8 @@ pub enum LegalType {
 #[derive(Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct WiseAddressDetails {
-    country: Option<storage_enums::CountryAlpha2>,
-    country_code: Option<storage_enums::CountryAlpha2>,
+    country: Option<CountryAlpha2>,
+    country_code: Option<CountryAlpha2>,
     first_line: Option<Secret<String>>,
     post_code: Option<Secret<String>>,
     city: Option<String>,
@@ -325,15 +333,15 @@ fn get_payout_bank_details(
     payout_method_data: PayoutMethodData,
     address: Option<&hyperswitch_domain_models::address::Address>,
     entity_type: PayoutEntityType,
-) -> Result<WiseBankDetails, errors::ConnectorError> {
+) -> Result<WiseBankDetails, ConnectorError> {
     let wise_address_details = match get_payout_address_details(address) {
         Some(a) => Ok(a),
-        None => Err(errors::ConnectorError::MissingRequiredField {
+        None => Err(ConnectorError::MissingRequiredField {
             field_name: "address",
         }),
     }?;
     match payout_method_data {
-        PayoutMethodData::Bank(payouts::BankPayout::Ach(b)) => Ok(WiseBankDetails {
+        PayoutMethodData::Bank(Bank::Ach(b)) => Ok(WiseBankDetails {
             legal_type: LegalType::from(entity_type),
             address: Some(wise_address_details),
             account_number: Some(b.bank_account_number.to_owned()),
@@ -341,33 +349,31 @@ fn get_payout_bank_details(
             account_type: Some(AccountType::Checking),
             ..WiseBankDetails::default()
         }),
-        PayoutMethodData::Bank(payouts::BankPayout::Bacs(b)) => Ok(WiseBankDetails {
+        PayoutMethodData::Bank(Bank::Bacs(b)) => Ok(WiseBankDetails {
             legal_type: LegalType::from(entity_type),
             address: Some(wise_address_details),
             account_number: Some(b.bank_account_number.to_owned()),
             sort_code: Some(b.bank_sort_code),
             ..WiseBankDetails::default()
         }),
-        PayoutMethodData::Bank(payouts::BankPayout::Sepa(b)) => Ok(WiseBankDetails {
+        PayoutMethodData::Bank(Bank::Sepa(b)) => Ok(WiseBankDetails {
             legal_type: LegalType::from(entity_type),
             address: Some(wise_address_details),
             iban: Some(b.iban.to_owned()),
             bic: b.bic,
             ..WiseBankDetails::default()
         }),
-        _ => Err(errors::ConnectorError::NotImplemented(
-            utils::get_unimplemented_payment_method_error_message("Wise"),
+        _ => Err(ConnectorError::NotImplemented(
+            get_unimplemented_payment_method_error_message("Wise"),
         ))?,
     }
 }
 
 // Payouts recipient create request transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<&WiseRouterData<&types::PayoutsRouterData<F>>> for WiseRecipientCreateRequest {
+impl<F> TryFrom<&WiseRouterData<&PayoutsRouterData<F>>> for WiseRecipientCreateRequest {
     type Error = Error;
-    fn try_from(
-        item_data: &WiseRouterData<&types::PayoutsRouterData<F>>,
-    ) -> Result<Self, Self::Error> {
+    fn try_from(item_data: &WiseRouterData<&PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
         let item = item_data.router_data;
         let request = item.request.to_owned();
         let customer_details = request.customer_details.to_owned();
@@ -378,25 +384,23 @@ impl<F> TryFrom<&WiseRouterData<&types::PayoutsRouterData<F>>> for WiseRecipient
             item.request.entity_type,
         )?;
         let source_id = match item.connector_auth_type.to_owned() {
-            types::ConnectorAuthType::BodyKey { api_key: _, key1 } => Ok(key1),
-            _ => Err(errors::ConnectorError::MissingRequiredField {
+            ConnectorAuthType::BodyKey { api_key: _, key1 } => Ok(key1),
+            _ => Err(ConnectorError::MissingRequiredField {
                 field_name: "source_id for PayoutRecipient creation",
             }),
         }?;
         let payout_type = request.get_payout_type()?;
         match payout_type {
-            storage_enums::PayoutType::Card | storage_enums::PayoutType::Wallet => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("Wise"),
-                ))?
-            }
-            storage_enums::PayoutType::Bank => {
+            PayoutType::Card | PayoutType::Wallet => Err(ConnectorError::NotImplemented(
+                get_unimplemented_payment_method_error_message("Wise"),
+            ))?,
+            PayoutType::Bank => {
                 let account_holder_name = customer_details
-                    .ok_or(errors::ConnectorError::MissingRequiredField {
+                    .ok_or(ConnectorError::MissingRequiredField {
                         field_name: "customer_details for PayoutRecipient creation",
                     })?
                     .name
-                    .ok_or(errors::ConnectorError::MissingRequiredField {
+                    .ok_or(ConnectorError::MissingRequiredField {
                         field_name: "customer_details.name for PayoutRecipient creation",
                     })?;
                 Ok(Self {
@@ -413,18 +417,18 @@ impl<F> TryFrom<&WiseRouterData<&types::PayoutsRouterData<F>>> for WiseRecipient
 
 // Payouts recipient fulfill response transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<types::PayoutsResponseRouterData<F, WiseRecipientCreateResponse>>
-    for types::PayoutsRouterData<F>
+impl<F> TryFrom<PayoutsResponseRouterData<F, WiseRecipientCreateResponse>>
+    for PayoutsRouterData<F>
 {
     type Error = Error;
     fn try_from(
-        item: types::PayoutsResponseRouterData<F, WiseRecipientCreateResponse>,
+        item: PayoutsResponseRouterData<F, WiseRecipientCreateResponse>,
     ) -> Result<Self, Self::Error> {
         let response: WiseRecipientCreateResponse = item.response;
 
         Ok(Self {
-            response: Ok(types::PayoutsResponseData {
-                status: Some(storage_enums::PayoutStatus::RequiresCreation),
+            response: Ok(PayoutsResponseData {
+                status: Some(PayoutStatus::RequiresCreation),
                 connector_payout_id: Some(response.id.to_string()),
                 payout_eligible: None,
                 should_add_next_step_to_process_tracker: false,
@@ -438,45 +442,39 @@ impl<F> TryFrom<types::PayoutsResponseRouterData<F, WiseRecipientCreateResponse>
 
 // Payouts quote request transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<&WiseRouterData<&types::PayoutsRouterData<F>>> for WisePayoutQuoteRequest {
+impl<F> TryFrom<&WiseRouterData<&PayoutsRouterData<F>>> for WisePayoutQuoteRequest {
     type Error = Error;
-    fn try_from(
-        item_data: &WiseRouterData<&types::PayoutsRouterData<F>>,
-    ) -> Result<Self, Self::Error> {
+    fn try_from(item_data: &WiseRouterData<&PayoutsRouterData<F>>) -> Result<Self, Self::Error> {
         let item = item_data.router_data;
         let request = item.request.to_owned();
         let payout_type = request.get_payout_type()?;
         match payout_type {
-            storage_enums::PayoutType::Bank => Ok(Self {
+            PayoutType::Bank => Ok(Self {
                 source_amount: Some(item_data.amount),
                 source_currency: request.source_currency.to_string(),
                 target_amount: None,
                 target_currency: request.destination_currency.to_string(),
                 pay_out: WisePayOutOption::default(),
             }),
-            storage_enums::PayoutType::Card | storage_enums::PayoutType::Wallet => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("Wise"),
-                ))?
-            }
+            PayoutType::Card | PayoutType::Wallet => Err(ConnectorError::NotImplemented(
+                get_unimplemented_payment_method_error_message("Wise"),
+            ))?,
         }
     }
 }
 
 // Payouts quote response transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<types::PayoutsResponseRouterData<F, WisePayoutQuoteResponse>>
-    for types::PayoutsRouterData<F>
-{
+impl<F> TryFrom<PayoutsResponseRouterData<F, WisePayoutQuoteResponse>> for PayoutsRouterData<F> {
     type Error = Error;
     fn try_from(
-        item: types::PayoutsResponseRouterData<F, WisePayoutQuoteResponse>,
+        item: PayoutsResponseRouterData<F, WisePayoutQuoteResponse>,
     ) -> Result<Self, Self::Error> {
         let response: WisePayoutQuoteResponse = item.response;
 
         Ok(Self {
-            response: Ok(types::PayoutsResponseData {
-                status: Some(storage_enums::PayoutStatus::RequiresCreation),
+            response: Ok(PayoutsResponseData {
+                status: Some(PayoutStatus::RequiresCreation),
                 connector_payout_id: Some(response.id),
                 payout_eligible: None,
                 should_add_next_step_to_process_tracker: false,
@@ -490,13 +488,13 @@ impl<F> TryFrom<types::PayoutsResponseRouterData<F, WisePayoutQuoteResponse>>
 
 // Payouts transfer creation request
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<&types::PayoutsRouterData<F>> for WisePayoutCreateRequest {
+impl<F> TryFrom<&PayoutsRouterData<F>> for WisePayoutCreateRequest {
     type Error = Error;
-    fn try_from(item: &types::PayoutsRouterData<F>) -> Result<Self, Self::Error> {
+    fn try_from(item: &PayoutsRouterData<F>) -> Result<Self, Self::Error> {
         let request = item.request.to_owned();
         let payout_type = request.get_payout_type()?;
         match payout_type {
-            storage_enums::PayoutType::Bank => {
+            PayoutType::Bank => {
                 let connector_customer_id = item.get_connector_customer_id()?;
                 let quote_uuid = item.get_quote_id()?;
                 let wise_transfer_details = WiseTransferDetails {
@@ -505,7 +503,7 @@ impl<F> TryFrom<&types::PayoutsRouterData<F>> for WisePayoutCreateRequest {
                     transfer_purpose_sub_transfer_purpose: None,
                 };
                 let target_account: i64 = connector_customer_id.trim().parse().map_err(|_| {
-                    errors::ConnectorError::MissingRequiredField {
+                    ConnectorError::MissingRequiredField {
                         field_name: "profile",
                     }
                 })?;
@@ -516,32 +514,28 @@ impl<F> TryFrom<&types::PayoutsRouterData<F>> for WisePayoutCreateRequest {
                     details: wise_transfer_details,
                 })
             }
-            storage_enums::PayoutType::Card | storage_enums::PayoutType::Wallet => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("Wise"),
-                ))?
-            }
+            PayoutType::Card | PayoutType::Wallet => Err(ConnectorError::NotImplemented(
+                get_unimplemented_payment_method_error_message("Wise"),
+            ))?,
         }
     }
 }
 
 // Payouts transfer creation response
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<types::PayoutsResponseRouterData<F, WisePayoutResponse>>
-    for types::PayoutsRouterData<F>
-{
+impl<F> TryFrom<PayoutsResponseRouterData<F, WisePayoutResponse>> for PayoutsRouterData<F> {
     type Error = Error;
     fn try_from(
-        item: types::PayoutsResponseRouterData<F, WisePayoutResponse>,
+        item: PayoutsResponseRouterData<F, WisePayoutResponse>,
     ) -> Result<Self, Self::Error> {
         let response: WisePayoutResponse = item.response;
-        let status = match storage_enums::PayoutStatus::from(response.status) {
-            storage_enums::PayoutStatus::Cancelled => storage_enums::PayoutStatus::Cancelled,
-            _ => storage_enums::PayoutStatus::RequiresFulfillment,
+        let status = match PayoutStatus::from(response.status) {
+            PayoutStatus::Cancelled => PayoutStatus::Cancelled,
+            _ => PayoutStatus::RequiresFulfillment,
         };
 
         Ok(Self {
-            response: Ok(types::PayoutsResponseData {
+            response: Ok(PayoutsResponseData {
                 status: Some(status),
                 connector_payout_id: Some(response.id.to_string()),
                 payout_eligible: None,
@@ -556,43 +550,39 @@ impl<F> TryFrom<types::PayoutsResponseRouterData<F, WisePayoutResponse>>
 
 // Payouts fulfill request transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<&types::PayoutsRouterData<F>> for WisePayoutFulfillRequest {
+impl<F> TryFrom<&PayoutsRouterData<F>> for WisePayoutFulfillRequest {
     type Error = Error;
-    fn try_from(item: &types::PayoutsRouterData<F>) -> Result<Self, Self::Error> {
+    fn try_from(item: &PayoutsRouterData<F>) -> Result<Self, Self::Error> {
         let payout_type = item.request.get_payout_type()?;
         match payout_type {
-            storage_enums::PayoutType::Bank => Ok(Self {
+            PayoutType::Bank => Ok(Self {
                 fund_type: FundType::default(),
             }),
-            storage_enums::PayoutType::Card | storage_enums::PayoutType::Wallet => {
-                Err(errors::ConnectorError::NotImplemented(
-                    utils::get_unimplemented_payment_method_error_message("Wise"),
-                ))?
-            }
+            PayoutType::Card | PayoutType::Wallet => Err(ConnectorError::NotImplemented(
+                get_unimplemented_payment_method_error_message("Wise"),
+            ))?,
         }
     }
 }
 
 // Payouts fulfill response transform
 #[cfg(feature = "payouts")]
-impl<F> TryFrom<types::PayoutsResponseRouterData<F, WiseFulfillResponse>>
-    for types::PayoutsRouterData<F>
-{
+impl<F> TryFrom<PayoutsResponseRouterData<F, WiseFulfillResponse>> for PayoutsRouterData<F> {
     type Error = Error;
     fn try_from(
-        item: types::PayoutsResponseRouterData<F, WiseFulfillResponse>,
+        item: PayoutsResponseRouterData<F, WiseFulfillResponse>,
     ) -> Result<Self, Self::Error> {
         let response: WiseFulfillResponse = item.response;
 
         Ok(Self {
-            response: Ok(types::PayoutsResponseData {
-                status: Some(storage_enums::PayoutStatus::from(response.status)),
+            response: Ok(PayoutsResponseData {
+                status: Some(PayoutStatus::from(response.status)),
                 connector_payout_id: Some(
                     item.data
                         .request
                         .connector_payout_id
                         .clone()
-                        .ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
+                        .ok_or(ConnectorError::MissingConnectorTransactionID)?,
                 ),
                 payout_eligible: None,
                 should_add_next_step_to_process_tracker: false,
@@ -605,7 +595,7 @@ impl<F> TryFrom<types::PayoutsResponseRouterData<F, WiseFulfillResponse>>
 }
 
 #[cfg(feature = "payouts")]
-impl From<WiseStatus> for storage_enums::PayoutStatus {
+impl From<WiseStatus> for PayoutStatus {
     fn from(wise_status: WiseStatus) -> Self {
         match wise_status {
             WiseStatus::Completed => Self::Success,
@@ -635,14 +625,14 @@ impl From<PayoutEntityType> for LegalType {
 
 #[cfg(feature = "payouts")]
 impl TryFrom<PayoutMethodData> for RecipientType {
-    type Error = error_stack::Report<errors::ConnectorError>;
+    type Error = error_stack::Report<ConnectorError>;
     fn try_from(payout_method_type: PayoutMethodData) -> Result<Self, Self::Error> {
         match payout_method_type {
-            PayoutMethodData::Bank(api_models::payouts::Bank::Ach(_)) => Ok(Self::Aba),
-            PayoutMethodData::Bank(api_models::payouts::Bank::Bacs(_)) => Ok(Self::SortCode),
-            PayoutMethodData::Bank(api_models::payouts::Bank::Sepa(_)) => Ok(Self::Iban),
-            _ => Err(errors::ConnectorError::NotImplemented(
-                utils::get_unimplemented_payment_method_error_message("Wise"),
+            PayoutMethodData::Bank(Bank::Ach(_)) => Ok(Self::Aba),
+            PayoutMethodData::Bank(Bank::Bacs(_)) => Ok(Self::SortCode),
+            PayoutMethodData::Bank(Bank::Sepa(_)) => Ok(Self::Iban),
+            _ => Err(ConnectorError::NotImplemented(
+                get_unimplemented_payment_method_error_message("Wise"),
             )
             .into()),
         }
diff --git a/crates/hyperswitch_connectors/src/default_implementations.rs b/crates/hyperswitch_connectors/src/default_implementations.rs
index f7b01800aa3..6f20e7222dd 100644
--- a/crates/hyperswitch_connectors/src/default_implementations.rs
+++ b/crates/hyperswitch_connectors/src/default_implementations.rs
@@ -191,18 +191,22 @@ default_imp_for_authorize_session_token!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Stripebilling,
     connectors::Taxjar,
     connectors::UnifiedAuthenticationService,
     connectors::Volt,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl,
@@ -300,18 +304,22 @@ default_imp_for_calculate_tax!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
     connectors::Volt,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl,
@@ -377,6 +385,7 @@ default_imp_for_session_update!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
@@ -410,15 +419,18 @@ default_imp_for_session_update!(
     connectors::Gocardless,
     connectors::Gpayments,
     connectors::Hipay,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl,
     connectors::Powertranz,
     connectors::Prophetpay,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -486,6 +498,7 @@ default_imp_for_post_session_tokens!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Square,
     connectors::Stax,
     connectors::Stripebilling,
@@ -518,13 +531,16 @@ default_imp_for_post_session_tokens!(
     connectors::Gocardless,
     connectors::Gpayments,
     connectors::Hipay,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Powertranz,
     connectors::Prophetpay,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -595,6 +611,7 @@ default_imp_for_update_metadata!(
     connectors::Recurly,
     connectors::Redsys,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Square,
     connectors::Stax,
     connectors::Stripebilling,
@@ -627,14 +644,17 @@ default_imp_for_update_metadata!(
     connectors::Gocardless,
     connectors::Gpayments,
     connectors::Hipay,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Powertranz,
     connectors::Prophetpay,
     connectors::Riskified,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -719,15 +739,19 @@ default_imp_for_complete_authorize!(
     connectors::Razorpay,
     connectors::Recurly,
     connectors::Riskified,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Worldline,
     connectors::Worldpayxml,
     connectors::Volt,
@@ -828,14 +852,18 @@ default_imp_for_incremental_authorization!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wellsfargopayout,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
@@ -936,17 +964,21 @@ default_imp_for_create_customer!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1031,14 +1063,18 @@ default_imp_for_connector_redirect_response!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Worldline,
     connectors::Worldpayxml,
     connectors::Volt,
@@ -1127,17 +1163,21 @@ default_imp_for_pre_processing_steps!(
     connectors::Razorpay,
     connectors::Recurly,
     connectors::Riskified,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Zen,
     connectors::Zsl,
@@ -1235,18 +1275,22 @@ default_imp_for_post_processing_steps!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1346,18 +1390,22 @@ default_imp_for_approve!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1457,18 +1505,22 @@ default_imp_for_reject!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1567,18 +1619,22 @@ default_imp_for_webhook_source_verification!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1677,18 +1733,22 @@ default_imp_for_accept_dispute!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1786,18 +1846,22 @@ default_imp_for_submit_evidence!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -1895,18 +1959,22 @@ default_imp_for_defend_dispute!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2013,18 +2081,22 @@ default_imp_for_file_upload!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2110,10 +2182,12 @@ default_imp_for_payouts!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Square,
     connectors::Stax,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
@@ -2122,6 +2196,7 @@ default_imp_for_payouts!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl,
@@ -2218,10 +2293,12 @@ default_imp_for_payouts_create!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2230,6 +2307,7 @@ default_imp_for_payouts_create!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2329,18 +2407,22 @@ default_imp_for_payouts_retrieve!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2439,10 +2521,12 @@ default_imp_for_payouts_eligibility!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2451,6 +2535,7 @@ default_imp_for_payouts_eligibility!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2545,10 +2630,12 @@ default_imp_for_payouts_fulfill!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2557,6 +2644,7 @@ default_imp_for_payouts_fulfill!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2655,10 +2743,12 @@ default_imp_for_payouts_cancel!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2667,6 +2757,7 @@ default_imp_for_payouts_cancel!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2766,10 +2857,12 @@ default_imp_for_payouts_quote!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2778,6 +2871,7 @@ default_imp_for_payouts_quote!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2877,10 +2971,12 @@ default_imp_for_payouts_recipient!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
@@ -2889,6 +2985,7 @@ default_imp_for_payouts_recipient!(
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -2989,18 +3086,22 @@ default_imp_for_payouts_recipient_account!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3105,14 +3206,17 @@ default_imp_for_frm_sale!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3217,14 +3321,17 @@ default_imp_for_frm_checkout!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3329,14 +3436,17 @@ default_imp_for_frm_transaction!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3441,14 +3551,17 @@ default_imp_for_frm_fulfillment!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3553,14 +3666,17 @@ default_imp_for_frm_record_return!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3656,14 +3772,17 @@ default_imp_for_revoking_mandates!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
@@ -3766,17 +3885,21 @@ default_imp_for_uas_pre_authentication!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3874,17 +3997,21 @@ default_imp_for_uas_post_authentication!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -3983,17 +4110,21 @@ default_imp_for_uas_authentication_confirmation!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4083,18 +4214,22 @@ default_imp_for_connector_request_id!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4191,14 +4326,17 @@ default_imp_for_fraud_check!(
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4320,6 +4458,7 @@ default_imp_for_connector_authentication!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
@@ -4328,10 +4467,12 @@ default_imp_for_connector_authentication!(
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4428,14 +4569,18 @@ default_imp_for_uas_authentication!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
+    connectors::Wise,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
@@ -4530,18 +4675,22 @@ default_imp_for_revenue_recovery! {
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4642,17 +4791,21 @@ default_imp_for_billing_connector_payment_sync!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4752,17 +4905,21 @@ default_imp_for_revenue_recovery_record_back!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
@@ -4862,19 +5019,23 @@ default_imp_for_billing_connector_invoice_sync!(
     connectors::Recurly,
     connectors::Redsys,
     connectors::Riskified,
+    connectors::Signifyd,
     connectors::Shift4,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
+    connectors::Threedsecureio,
     connectors::Taxjar,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Volt,
     connectors::Xendit,
     connectors::Zen,
diff --git a/crates/hyperswitch_connectors/src/default_implementations_v2.rs b/crates/hyperswitch_connectors/src/default_implementations_v2.rs
index 897241b687b..bbe705d33c5 100644
--- a/crates/hyperswitch_connectors/src/default_implementations_v2.rs
+++ b/crates/hyperswitch_connectors/src/default_implementations_v2.rs
@@ -315,19 +315,23 @@ default_imp_for_new_connector_integration_payment!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -427,15 +431,19 @@ default_imp_for_new_connector_integration_refund!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
@@ -534,19 +542,23 @@ default_imp_for_new_connector_integration_connector_access_token!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -646,19 +658,23 @@ default_imp_for_new_connector_integration_accept_dispute!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -757,19 +773,23 @@ default_imp_for_new_connector_integration_submit_evidence!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -869,19 +889,23 @@ default_imp_for_new_connector_integration_defend_dispute!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -991,19 +1015,23 @@ default_imp_for_new_connector_integration_file_upload!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1105,19 +1133,23 @@ default_imp_for_new_connector_integration_payouts_create!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1219,19 +1251,23 @@ default_imp_for_new_connector_integration_payouts_eligibility!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1333,19 +1369,23 @@ default_imp_for_new_connector_integration_payouts_fulfill!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1447,19 +1487,23 @@ default_imp_for_new_connector_integration_payouts_cancel!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1561,19 +1605,23 @@ default_imp_for_new_connector_integration_payouts_quote!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1675,19 +1723,23 @@ default_imp_for_new_connector_integration_payouts_recipient!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1789,19 +1841,23 @@ default_imp_for_new_connector_integration_payouts_sync!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -1903,19 +1959,23 @@ default_imp_for_new_connector_integration_payouts_recipient_account!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2015,19 +2075,23 @@ default_imp_for_new_connector_integration_webhook_source_verification!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2129,19 +2193,23 @@ default_imp_for_new_connector_integration_frm_sale!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2243,19 +2311,23 @@ default_imp_for_new_connector_integration_frm_checkout!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2357,19 +2429,23 @@ default_imp_for_new_connector_integration_frm_transaction!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2471,19 +2547,23 @@ default_imp_for_new_connector_integration_frm_fulfillment!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2585,19 +2665,23 @@ default_imp_for_new_connector_integration_frm_record_return!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2695,19 +2779,23 @@ default_imp_for_new_connector_integration_revoking_mandates!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Stripebilling,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Trustpay,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
     connectors::Worldpayxml,
     connectors::Wellsfargo,
+    connectors::Wellsfargopayout,
     connectors::Xendit,
     connectors::Zen,
     connectors::Zsl
@@ -2777,12 +2865,15 @@ default_imp_for_new_connector_integration_frm!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
@@ -2887,12 +2978,15 @@ default_imp_for_new_connector_integration_connector_authentication!(
     connectors::Riskified,
     connectors::Recurly,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
@@ -2989,12 +3083,15 @@ default_imp_for_new_connector_integration_revenue_recovery!(
     connectors::Redsys,
     connectors::Riskified,
     connectors::Shift4,
+    connectors::Signifyd,
     connectors::Stax,
     connectors::Square,
     connectors::Taxjar,
+    connectors::Threedsecureio,
     connectors::Thunes,
     connectors::Tsys,
     connectors::UnifiedAuthenticationService,
+    connectors::Wise,
     connectors::Worldline,
     connectors::Volt,
     connectors::Worldpay,
diff --git a/crates/hyperswitch_connectors/src/types.rs b/crates/hyperswitch_connectors/src/types.rs
index 79c032a8dae..a072317ea70 100644
--- a/crates/hyperswitch_connectors/src/types.rs
+++ b/crates/hyperswitch_connectors/src/types.rs
@@ -28,9 +28,10 @@ use hyperswitch_domain_models::{
 };
 #[cfg(feature = "frm")]
 use hyperswitch_domain_models::{
-    router_flow_types::{Checkout, Fulfillment, Transaction},
+    router_flow_types::{Checkout, Fulfillment, RecordReturn, Sale, Transaction},
     router_request_types::fraud_check::{
-        FraudCheckCheckoutData, FraudCheckFulfillmentData, FraudCheckTransactionData,
+        FraudCheckCheckoutData, FraudCheckFulfillmentData, FraudCheckRecordReturnData,
+        FraudCheckSaleData, FraudCheckTransactionData,
     },
     router_response_types::fraud_check::FraudCheckResponseData,
 };
@@ -129,3 +130,14 @@ pub(crate) type ConnectorPreAuthenticationVersionCallType = dyn ConnectorIntegra
 
 pub(crate) type PaymentsPostProcessingRouterData =
     RouterData<PostProcessing, PaymentsPostProcessingData, PaymentsResponseData>;
+#[cfg(feature = "frm")]
+pub(crate) type FrmSaleRouterData = RouterData<Sale, FraudCheckSaleData, FraudCheckResponseData>;
+#[cfg(feature = "frm")]
+pub(crate) type FrmRecordReturnRouterData =
+    RouterData<RecordReturn, FraudCheckRecordReturnData, FraudCheckResponseData>;
+#[cfg(feature = "frm")]
+pub(crate) type FrmRecordReturnType =
+    dyn ConnectorIntegration<RecordReturn, FraudCheckRecordReturnData, FraudCheckResponseData>;
+#[cfg(feature = "frm")]
+pub(crate) type FrmSaleType =
+    dyn ConnectorIntegration<Sale, FraudCheckSaleData, FraudCheckResponseData>;
diff --git a/crates/hyperswitch_connectors/src/utils.rs b/crates/hyperswitch_connectors/src/utils.rs
index 216b096b7a7..5a1b320ea14 100644
--- a/crates/hyperswitch_connectors/src/utils.rs
+++ b/crates/hyperswitch_connectors/src/utils.rs
@@ -40,7 +40,8 @@ use common_utils::{
 use error_stack::{report, ResultExt};
 #[cfg(feature = "frm")]
 use hyperswitch_domain_models::router_request_types::fraud_check::{
-    FraudCheckCheckoutData, FraudCheckTransactionData,
+    FraudCheckCheckoutData, FraudCheckRecordReturnData, FraudCheckSaleData,
+    FraudCheckTransactionData,
 };
 use hyperswitch_domain_models::{
     address::{Address, AddressDetails, PhoneDetails},
@@ -6292,3 +6293,27 @@ pub fn get_card_details(
         })?,
     }
 }
+
+#[cfg(feature = "frm")]
+pub trait FraudCheckSaleRequest {
+    fn get_order_details(&self) -> Result<Vec<OrderDetailsWithAmount>, Error>;
+}
+#[cfg(feature = "frm")]
+impl FraudCheckSaleRequest for FraudCheckSaleData {
+    fn get_order_details(&self) -> Result<Vec<OrderDetailsWithAmount>, Error> {
+        self.order_details
+            .clone()
+            .ok_or_else(missing_field_err("order_details"))
+    }
+}
+
+#[cfg(feature = "frm")]
+pub trait FraudCheckRecordReturnRequest {
+    fn get_currency(&self) -> Result<enums::Currency, Error>;
+}
+#[cfg(feature = "frm")]
+impl FraudCheckRecordReturnRequest for FraudCheckRecordReturnData {
+    fn get_currency(&self) -> Result<enums::Currency, Error> {
+        self.currency.ok_or_else(missing_field_err("currency"))
+    }
+}
diff --git a/crates/router/Cargo.toml b/crates/router/Cargo.toml
index d14eaaf83d5..b5acee66db0 100644
--- a/crates/router/Cargo.toml
+++ b/crates/router/Cargo.toml
@@ -74,8 +74,6 @@ hkdf = "0.12.4"
 http = "0.2.12"
 hyper = "0.14.28"
 infer = "0.15.0"
-iso_currency = "0.4.4"
-isocountry = "0.3.2"
 josekit = "0.8.6"
 jsonwebtoken = "9.2.0"
 maud = { version = "0.26.0", features = ["actix-web"] }
diff --git a/crates/router/src/connector.rs b/crates/router/src/connector.rs
index e6965134788..fcf751b9d15 100644
--- a/crates/router/src/connector.rs
+++ b/crates/router/src/connector.rs
@@ -1,11 +1,7 @@
 #[cfg(feature = "dummy_connector")]
 pub mod dummyconnector;
-pub mod signifyd;
 pub mod stripe;
-pub mod threedsecureio;
 pub mod utils;
-pub mod wellsfargopayout;
-pub mod wise;
 
 pub use hyperswitch_connectors::connectors::{
     aci, aci::Aci, adyen, adyen::Adyen, adyenplatform, adyenplatform::Adyenplatform, airwallex,
@@ -34,17 +30,16 @@ pub use hyperswitch_connectors::connectors::{
     paystack, paystack::Paystack, payu, payu::Payu, placetopay, placetopay::Placetopay, plaid,
     plaid::Plaid, powertranz, powertranz::Powertranz, prophetpay, prophetpay::Prophetpay, rapyd,
     rapyd::Rapyd, razorpay, razorpay::Razorpay, recurly, recurly::Recurly, redsys, redsys::Redsys,
-    riskified, riskified::Riskified, shift4, shift4::Shift4, square, square::Square, stax,
-    stax::Stax, stripebilling, stripebilling::Stripebilling, taxjar, taxjar::Taxjar, thunes,
-    thunes::Thunes, trustpay, trustpay::Trustpay, tsys, tsys::Tsys, unified_authentication_service,
+    riskified, riskified::Riskified, shift4, shift4::Shift4, signifyd, signifyd::Signifyd, square,
+    square::Square, stax, stax::Stax, stripebilling, stripebilling::Stripebilling, taxjar,
+    taxjar::Taxjar, threedsecureio, threedsecureio::Threedsecureio, thunes, thunes::Thunes,
+    trustpay, trustpay::Trustpay, tsys, tsys::Tsys, unified_authentication_service,
     unified_authentication_service::UnifiedAuthenticationService, volt, volt::Volt, wellsfargo,
-    wellsfargo::Wellsfargo, worldline, worldline::Worldline, worldpay, worldpay::Worldpay,
-    worldpayxml, worldpayxml::Worldpayxml, xendit, xendit::Xendit, zen, zen::Zen, zsl, zsl::Zsl,
+    wellsfargo::Wellsfargo, wellsfargopayout, wellsfargopayout::Wellsfargopayout, wise, wise::Wise,
+    worldline, worldline::Worldline, worldpay, worldpay::Worldpay, worldpayxml,
+    worldpayxml::Worldpayxml, xendit, xendit::Xendit, zen, zen::Zen, zsl, zsl::Zsl,
 };
 
 #[cfg(feature = "dummy_connector")]
 pub use self::dummyconnector::DummyConnector;
-pub use self::{
-    signifyd::Signifyd, stripe::Stripe, threedsecureio::Threedsecureio,
-    wellsfargopayout::Wellsfargopayout, wise::Wise,
-};
+pub use self::stripe::Stripe;
diff --git a/crates/router/src/connector/signifyd.rs b/crates/router/src/connector/signifyd.rs
deleted file mode 100644
index 75b78c19b78..00000000000
--- a/crates/router/src/connector/signifyd.rs
+++ /dev/null
@@ -1,761 +0,0 @@
-pub mod transformers;
-use std::fmt::Debug;
-
-#[cfg(feature = "frm")]
-use base64::Engine;
-#[cfg(feature = "frm")]
-use common_utils::{crypto, ext_traits::ByteSliceExt, request::RequestContent};
-#[cfg(feature = "frm")]
-use error_stack::ResultExt;
-#[cfg(feature = "frm")]
-use masking::{PeekInterface, Secret};
-#[cfg(feature = "frm")]
-use ring::hmac;
-#[cfg(feature = "frm")]
-use transformers as signifyd;
-
-#[cfg(feature = "frm")]
-use super::utils as connector_utils;
-use crate::{
-    configs::settings,
-    core::errors::{self, CustomResult},
-    headers,
-    services::{self, request, ConnectorIntegration, ConnectorSpecifications, ConnectorValidation},
-    types::{
-        self,
-        api::{self, ConnectorCommon, ConnectorCommonExt},
-    },
-};
-#[cfg(feature = "frm")]
-use crate::{
-    consts,
-    events::connector_api_logs::ConnectorEvent,
-    types::{api::fraud_check as frm_api, fraud_check as frm_types, ErrorResponse, Response},
-    utils::BytesExt,
-};
-
-#[derive(Debug, Clone)]
-pub struct Signifyd;
-
-impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Signifyd
-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(),
-            self.get_content_type().to_string().into(),
-        )];
-
-        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-        header.append(&mut api_key);
-        Ok(header)
-    }
-}
-
-impl ConnectorCommon for Signifyd {
-    fn id(&self) -> &'static str {
-        "signifyd"
-    }
-
-    fn common_get_content_type(&self) -> &'static str {
-        "application/json"
-    }
-    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
-        connectors.signifyd.base_url.as_ref()
-    }
-
-    #[cfg(feature = "frm")]
-    fn get_auth_header(
-        &self,
-        auth_type: &types::ConnectorAuthType,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let auth = signifyd::SignifydAuthType::try_from(auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-        let auth_api_key = format!(
-            "Basic {}",
-            consts::BASE64_ENGINE.encode(auth.api_key.peek())
-        );
-
-        Ok(vec![(
-            headers::AUTHORIZATION.to_string(),
-            request::Mask::into_masked(auth_api_key),
-        )])
-    }
-
-    #[cfg(feature = "frm")]
-    fn build_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        let response: signifyd::SignifydErrorResponse = res
-            .response
-            .parse_struct("SignifydErrorResponse")
-            .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: consts::NO_ERROR_CODE.to_string(),
-            message: response.messages.join(" &"),
-            reason: Some(response.errors.to_string()),
-            attempt_status: None,
-            connector_transaction_id: None,
-            network_advice_code: None,
-            network_decline_code: None,
-            network_error_message: None,
-        })
-    }
-}
-
-impl api::Payment for Signifyd {}
-impl api::PaymentAuthorize for Signifyd {}
-impl api::PaymentSync for Signifyd {}
-impl api::PaymentVoid for Signifyd {}
-impl api::PaymentCapture for Signifyd {}
-impl api::MandateSetup for Signifyd {}
-impl api::ConnectorAccessToken for Signifyd {}
-impl api::PaymentToken for Signifyd {}
-impl api::Refund for Signifyd {}
-impl api::RefundExecute for Signifyd {}
-impl api::RefundSync for Signifyd {}
-impl ConnectorValidation for Signifyd {}
-
-impl
-    ConnectorIntegration<
-        api::PaymentMethodToken,
-        types::PaymentMethodTokenizationData,
-        types::PaymentsResponseData,
-    > for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
-    for Signifyd
-{
-}
-
-impl
-    ConnectorIntegration<
-        api::SetupMandate,
-        types::SetupMandateRequestData,
-        types::PaymentsResponseData,
-    > for Signifyd
-{
-    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 Signifyd".to_string())
-                .into(),
-        )
-    }
-}
-
-impl api::PaymentSession for Signifyd {}
-
-impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
-    for Signifyd
-{
-}
-
-impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData> for Signifyd {}
-
-#[cfg(feature = "frm")]
-impl api::FraudCheck for Signifyd {}
-#[cfg(feature = "frm")]
-impl frm_api::FraudCheckSale for Signifyd {}
-#[cfg(feature = "frm")]
-impl frm_api::FraudCheckCheckout for Signifyd {}
-#[cfg(feature = "frm")]
-impl frm_api::FraudCheckTransaction for Signifyd {}
-#[cfg(feature = "frm")]
-impl frm_api::FraudCheckFulfillment for Signifyd {}
-#[cfg(feature = "frm")]
-impl frm_api::FraudCheckRecordReturn for Signifyd {}
-
-#[cfg(feature = "frm")]
-impl
-    ConnectorIntegration<
-        frm_api::Sale,
-        frm_types::FraudCheckSaleData,
-        frm_types::FraudCheckResponseData,
-    > for Signifyd
-{
-    fn get_headers(
-        &self,
-        req: &frm_types::FrmSaleRouterData,
-        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: &frm_types::FrmSaleRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}{}",
-            self.base_url(connectors),
-            "v3/orders/events/sales"
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &frm_types::FrmSaleRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = signifyd::SignifydPaymentsSaleRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &frm_types::FrmSaleRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&frm_types::FrmSaleType::get_url(self, req, connectors)?)
-                .attach_default_headers()
-                .headers(frm_types::FrmSaleType::get_headers(self, req, connectors)?)
-                .set_body(frm_types::FrmSaleType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &frm_types::FrmSaleRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<frm_types::FrmSaleRouterData, errors::ConnectorError> {
-        let response: signifyd::SignifydPaymentsResponse = res
-            .response
-            .parse_struct("SignifydPaymentsResponse Sale")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-
-        <frm_types::FrmSaleRouterData>::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[cfg(feature = "frm")]
-impl
-    ConnectorIntegration<
-        frm_api::Checkout,
-        frm_types::FraudCheckCheckoutData,
-        frm_types::FraudCheckResponseData,
-    > for Signifyd
-{
-    fn get_headers(
-        &self,
-        req: &frm_types::FrmCheckoutRouterData,
-        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: &frm_types::FrmCheckoutRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}{}",
-            self.base_url(connectors),
-            "v3/orders/events/checkouts"
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &frm_types::FrmCheckoutRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = signifyd::SignifydPaymentsCheckoutRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &frm_types::FrmCheckoutRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&frm_types::FrmCheckoutType::get_url(self, req, connectors)?)
-                .attach_default_headers()
-                .headers(frm_types::FrmCheckoutType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(frm_types::FrmCheckoutType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &frm_types::FrmCheckoutRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<frm_types::FrmCheckoutRouterData, errors::ConnectorError> {
-        let response: signifyd::SignifydPaymentsResponse = res
-            .response
-            .parse_struct("SignifydPaymentsResponse Checkout")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        <frm_types::FrmCheckoutRouterData>::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[cfg(feature = "frm")]
-impl
-    ConnectorIntegration<
-        frm_api::Transaction,
-        frm_types::FraudCheckTransactionData,
-        frm_types::FraudCheckResponseData,
-    > for Signifyd
-{
-    fn get_headers(
-        &self,
-        req: &frm_types::FrmTransactionRouterData,
-        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: &frm_types::FrmTransactionRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}{}",
-            self.base_url(connectors),
-            "v3/orders/events/transactions"
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &frm_types::FrmTransactionRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = signifyd::SignifydPaymentsTransactionRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &frm_types::FrmTransactionRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&frm_types::FrmTransactionType::get_url(
-                    self, req, connectors,
-                )?)
-                .attach_default_headers()
-                .headers(frm_types::FrmTransactionType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(frm_types::FrmTransactionType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &frm_types::FrmTransactionRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<frm_types::FrmTransactionRouterData, errors::ConnectorError> {
-        let response: signifyd::SignifydPaymentsResponse = res
-            .response
-            .parse_struct("SignifydPaymentsResponse Transaction")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        <frm_types::FrmTransactionRouterData>::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[cfg(feature = "frm")]
-impl
-    ConnectorIntegration<
-        frm_api::Fulfillment,
-        frm_types::FraudCheckFulfillmentData,
-        frm_types::FraudCheckResponseData,
-    > for Signifyd
-{
-    fn get_headers(
-        &self,
-        req: &frm_types::FrmFulfillmentRouterData,
-        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: &frm_types::FrmFulfillmentRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}{}",
-            self.base_url(connectors),
-            "v3/orders/events/fulfillments"
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &frm_types::FrmFulfillmentRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = signifyd::FrmFulfillmentSignifydRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(req_obj.clone())))
-    }
-
-    fn build_request(
-        &self,
-        req: &frm_types::FrmFulfillmentRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&frm_types::FrmFulfillmentType::get_url(
-                    self, req, connectors,
-                )?)
-                .attach_default_headers()
-                .headers(frm_types::FrmFulfillmentType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(frm_types::FrmFulfillmentType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &frm_types::FrmFulfillmentRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<frm_types::FrmFulfillmentRouterData, errors::ConnectorError> {
-        let response: signifyd::FrmFulfillmentSignifydApiResponse = res
-            .response
-            .parse_struct("FrmFulfillmentSignifydApiResponse Sale")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        frm_types::FrmFulfillmentRouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[cfg(feature = "frm")]
-impl
-    ConnectorIntegration<
-        frm_api::RecordReturn,
-        frm_types::FraudCheckRecordReturnData,
-        frm_types::FraudCheckResponseData,
-    > for Signifyd
-{
-    fn get_headers(
-        &self,
-        req: &frm_types::FrmRecordReturnRouterData,
-        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: &frm_types::FrmRecordReturnRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!(
-            "{}{}",
-            self.base_url(connectors),
-            "v3/orders/events/returns/records"
-        ))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &frm_types::FrmRecordReturnRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = signifyd::SignifydPaymentsRecordReturnRequest::try_from(req)?;
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &frm_types::FrmRecordReturnRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(&frm_types::FrmRecordReturnType::get_url(
-                    self, req, connectors,
-                )?)
-                .attach_default_headers()
-                .headers(frm_types::FrmRecordReturnType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(frm_types::FrmRecordReturnType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &frm_types::FrmRecordReturnRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<frm_types::FrmRecordReturnRouterData, errors::ConnectorError> {
-        let response: signifyd::SignifydPaymentsRecordReturnResponse = res
-            .response
-            .parse_struct("SignifydPaymentsResponse Transaction")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        <frm_types::FrmRecordReturnRouterData>::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-#[cfg(feature = "frm")]
-#[async_trait::async_trait]
-impl api::IncomingWebhook for Signifyd {
-    fn get_webhook_source_verification_algorithm(
-        &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
-        Ok(Box::new(crypto::HmacSha256))
-    }
-
-    fn get_webhook_source_verification_signature(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
-    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {
-        let header_value =
-            connector_utils::get_header_key_value("x-signifyd-sec-hmac-sha256", request.headers)?;
-        Ok(header_value.as_bytes().to_vec())
-    }
-
-    fn get_webhook_source_verification_message(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-        _merchant_id: &common_utils::id_type::MerchantId,
-        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
-    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {
-        Ok(request.body.to_vec())
-    }
-
-    async fn verify_webhook_source(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-        merchant_id: &common_utils::id_type::MerchantId,
-        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,
-        _connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,
-        connector_label: &str,
-    ) -> CustomResult<bool, errors::ConnectorError> {
-        let connector_webhook_secrets = self
-            .get_webhook_source_verification_merchant_secret(
-                merchant_id,
-                connector_label,
-                connector_webhook_details,
-            )
-            .await
-            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
-
-        let signature = self
-            .get_webhook_source_verification_signature(request, &connector_webhook_secrets)
-            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
-
-        let message = self
-            .get_webhook_source_verification_message(
-                request,
-                merchant_id,
-                &connector_webhook_secrets,
-            )
-            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
-
-        let signing_key = hmac::Key::new(hmac::HMAC_SHA256, &connector_webhook_secrets.secret);
-        let signed_message = hmac::sign(&signing_key, &message);
-        let payload_sign = consts::BASE64_ENGINE.encode(signed_message.as_ref());
-        Ok(payload_sign.as_bytes().eq(&signature))
-    }
-
-    fn get_webhook_object_reference_id(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {
-        let resource: signifyd::SignifydWebhookBody = request
-            .body
-            .parse_struct("SignifydWebhookBody")
-            .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
-        Ok(api::webhooks::ObjectReferenceId::PaymentId(
-            api_models::payments::PaymentIdType::PaymentAttemptId(resource.order_id),
-        ))
-    }
-
-    fn get_webhook_event_type(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
-        let resource: signifyd::SignifydWebhookBody = request
-            .body
-            .parse_struct("SignifydWebhookBody")
-            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
-        Ok(api::IncomingWebhookEvent::from(resource.review_disposition))
-    }
-
-    fn get_webhook_resource_object(
-        &self,
-        request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
-        let resource: signifyd::SignifydWebhookBody = request
-            .body
-            .parse_struct("SignifydWebhookBody")
-            .change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
-        Ok(Box::new(resource))
-    }
-}
-
-impl ConnectorSpecifications for Signifyd {}
diff --git a/crates/router/src/connector/signifyd/transformers/auth.rs b/crates/router/src/connector/signifyd/transformers/auth.rs
deleted file mode 100644
index cc5867aea36..00000000000
--- a/crates/router/src/connector/signifyd/transformers/auth.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use error_stack;
-use masking::Secret;
-
-use crate::{core::errors, types};
-
-pub struct SignifydAuthType {
-    pub api_key: Secret<String>,
-}
-
-impl TryFrom<&types::ConnectorAuthType> for SignifydAuthType {
-    type Error = error_stack::Report<errors::ConnectorError>;
-    fn try_from(auth_type: &types::ConnectorAuthType) -> Result<Self, Self::Error> {
-        match auth_type {
-            types::ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
-                api_key: api_key.to_owned(),
-            }),
-            _ => Err(errors::ConnectorError::FailedToObtainAuthType.into()),
-        }
-    }
-}
diff --git a/crates/router/src/connector/threedsecureio.rs b/crates/router/src/connector/threedsecureio.rs
deleted file mode 100644
index c01a1d894c4..00000000000
--- a/crates/router/src/connector/threedsecureio.rs
+++ /dev/null
@@ -1,537 +0,0 @@
-pub mod transformers;
-
-use std::fmt::Debug;
-
-use error_stack::{report, ResultExt};
-use masking::ExposeInterface;
-use pm_auth::consts;
-use transformers as threedsecureio;
-
-use crate::{
-    configs::settings,
-    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, RequestContent, Response,
-    },
-    utils::{self, BytesExt},
-};
-
-#[derive(Debug, Clone)]
-pub struct Threedsecureio;
-
-impl api::Payment for Threedsecureio {}
-impl api::PaymentSession for Threedsecureio {}
-impl api::ConnectorAccessToken for Threedsecureio {}
-impl api::MandateSetup for Threedsecureio {}
-impl api::PaymentAuthorize for Threedsecureio {}
-impl api::PaymentSync for Threedsecureio {}
-impl api::PaymentCapture for Threedsecureio {}
-impl api::PaymentVoid for Threedsecureio {}
-impl api::Refund for Threedsecureio {}
-impl api::RefundExecute for Threedsecureio {}
-impl api::RefundSync for Threedsecureio {}
-impl api::PaymentToken for Threedsecureio {}
-
-impl
-    ConnectorIntegration<
-        api::PaymentMethodToken,
-        types::PaymentMethodTokenizationData,
-        types::PaymentsResponseData,
-    > for Threedsecureio
-{
-}
-
-impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Threedsecureio
-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(),
-            "application/json; charset=utf-8".to_string().into(),
-        )];
-        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
-        header.append(&mut api_key);
-        Ok(header)
-    }
-}
-
-impl ConnectorCommon for Threedsecureio {
-    fn id(&self) -> &'static str {
-        "threedsecureio"
-    }
-
-    fn get_currency_unit(&self) -> api::CurrencyUnit {
-        api::CurrencyUnit::Minor
-    }
-
-    fn common_get_content_type(&self) -> &'static str {
-        "application/json"
-    }
-
-    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
-        connectors.threedsecureio.base_url.as_ref()
-    }
-
-    fn get_auth_header(
-        &self,
-        auth_type: &types::ConnectorAuthType,
-    ) -> CustomResult<Vec<(String, request::Maskable<String>)>, errors::ConnectorError> {
-        let auth = threedsecureio::ThreedsecureioAuthType::try_from(auth_type)
-            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
-        Ok(vec![(
-            headers::APIKEY.to_string(),
-            auth.api_key.expose().into_masked(),
-        )])
-    }
-
-    fn build_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        let response_result: Result<
-            threedsecureio::ThreedsecureioErrorResponse,
-            error_stack::Report<common_utils::errors::ParsingError>,
-        > = res.response.parse_struct("ThreedsecureioErrorResponse");
-
-        match response_result {
-            Ok(response) => {
-                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_description
-                        .clone()
-                        .unwrap_or(consts::NO_ERROR_MESSAGE.to_owned()),
-                    reason: response.error_description,
-                    attempt_status: None,
-                    connector_transaction_id: None,
-                    network_advice_code: None,
-                    network_decline_code: None,
-                    network_error_message: None,
-                })
-            }
-            Err(err) => {
-                router_env::logger::error!(deserialization_error =? err);
-                utils::handle_json_response_deserialization_failure(res, "threedsecureio")
-            }
-        }
-    }
-}
-
-impl ConnectorValidation for Threedsecureio {}
-
-impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
-    for Threedsecureio
-{
-}
-
-impl
-    ConnectorIntegration<
-        api::SetupMandate,
-        types::SetupMandateRequestData,
-        types::PaymentsResponseData,
-    > for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
-    for Threedsecureio
-{
-}
-
-impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData>
-    for Threedsecureio
-{
-}
-
-#[async_trait::async_trait]
-impl api::IncomingWebhook for Threedsecureio {
-    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> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
-    }
-
-    fn get_webhook_resource_object(
-        &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
-    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
-        Err(report!(errors::ConnectorError::WebhooksNotImplemented))
-    }
-}
-
-impl api::ConnectorPreAuthentication for Threedsecureio {}
-impl api::ConnectorPreAuthenticationVersionCall for Threedsecureio {}
-impl api::ExternalAuthentication for Threedsecureio {}
-impl api::ConnectorAuthentication for Threedsecureio {}
-impl api::ConnectorPostAuthentication for Threedsecureio {}
-
-impl
-    ConnectorIntegration<
-        api::Authentication,
-        types::authentication::ConnectorAuthenticationRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for Threedsecureio
-{
-    fn get_headers(
-        &self,
-        req: &types::authentication::ConnectorAuthenticationRouterData,
-        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::authentication::ConnectorAuthenticationRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!("{}/auth", self.base_url(connectors),))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::authentication::ConnectorAuthenticationRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((
-            &self.get_currency_unit(),
-            req.request
-                .currency
-                .ok_or(errors::ConnectorError::MissingRequiredField {
-                    field_name: "currency",
-                })?,
-            req.request
-                .amount
-                .ok_or(errors::ConnectorError::MissingRequiredField {
-                    field_name: "amount",
-                })?,
-            req,
-        ))?;
-        let req_obj =
-            threedsecureio::ThreedsecureioAuthenticationRequest::try_from(&connector_router_data);
-        Ok(RequestContent::Json(Box::new(req_obj?)))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::authentication::ConnectorAuthenticationRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(
-                    &types::authentication::ConnectorAuthenticationType::get_url(
-                        self, req, connectors,
-                    )?,
-                )
-                .attach_default_headers()
-                .headers(
-                    types::authentication::ConnectorAuthenticationType::get_headers(
-                        self, req, connectors,
-                    )?,
-                )
-                .set_body(
-                    types::authentication::ConnectorAuthenticationType::get_request_body(
-                        self, req, connectors,
-                    )?,
-                )
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::authentication::ConnectorAuthenticationRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<
-        types::authentication::ConnectorAuthenticationRouterData,
-        errors::ConnectorError,
-    > {
-        let response: threedsecureio::ThreedsecureioAuthenticationResponse = res
-            .response
-            .parse_struct("ThreedsecureioAuthenticationResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl
-    ConnectorIntegration<
-        api::PreAuthentication,
-        types::authentication::PreAuthNRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for Threedsecureio
-{
-    fn get_headers(
-        &self,
-        req: &types::authentication::PreAuthNRouterData,
-        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::authentication::PreAuthNRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!("{}/preauth", self.base_url(connectors),))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::authentication::PreAuthNRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_router_data = threedsecureio::ThreedsecureioRouterData::try_from((0, req))?;
-        let req_obj = threedsecureio::ThreedsecureioPreAuthenticationRequest::try_from(
-            &connector_router_data,
-        )?;
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::authentication::PreAuthNRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(
-                    &types::authentication::ConnectorPreAuthenticationType::get_url(
-                        self, req, connectors,
-                    )?,
-                )
-                .attach_default_headers()
-                .headers(
-                    types::authentication::ConnectorPreAuthenticationType::get_headers(
-                        self, req, connectors,
-                    )?,
-                )
-                .set_body(
-                    types::authentication::ConnectorPreAuthenticationType::get_request_body(
-                        self, req, connectors,
-                    )?,
-                )
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::authentication::PreAuthNRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<types::authentication::PreAuthNRouterData, errors::ConnectorError> {
-        let response: threedsecureio::ThreedsecureioPreAuthenticationResponse = res
-            .response
-            .parse_struct("threedsecureio ThreedsecureioPreAuthenticationResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        types::RouterData::try_from(types::ResponseRouterData {
-            response,
-            data: data.clone(),
-            http_code: res.status_code,
-        })
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl
-    ConnectorIntegration<
-        api::PostAuthentication,
-        types::authentication::ConnectorPostAuthenticationRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for Threedsecureio
-{
-    fn get_headers(
-        &self,
-        req: &types::authentication::ConnectorPostAuthenticationRouterData,
-        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::authentication::ConnectorPostAuthenticationRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<String, errors::ConnectorError> {
-        Ok(format!("{}/postauth", self.base_url(connectors),))
-    }
-
-    fn get_request_body(
-        &self,
-        req: &types::authentication::ConnectorPostAuthenticationRouterData,
-        _connectors: &settings::Connectors,
-    ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let req_obj = threedsecureio::ThreedsecureioPostAuthenticationRequest {
-            three_ds_server_trans_id: req.request.threeds_server_transaction_id.clone(),
-        };
-        Ok(RequestContent::Json(Box::new(req_obj)))
-    }
-
-    fn build_request(
-        &self,
-        req: &types::authentication::ConnectorPostAuthenticationRouterData,
-        connectors: &settings::Connectors,
-    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
-        Ok(Some(
-            services::RequestBuilder::new()
-                .method(services::Method::Post)
-                .url(
-                    &types::authentication::ConnectorPostAuthenticationType::get_url(
-                        self, req, connectors,
-                    )?,
-                )
-                .attach_default_headers()
-                .headers(
-                    types::authentication::ConnectorPostAuthenticationType::get_headers(
-                        self, req, connectors,
-                    )?,
-                )
-                .set_body(
-                    types::authentication::ConnectorPostAuthenticationType::get_request_body(
-                        self, req, connectors,
-                    )?,
-                )
-                .build(),
-        ))
-    }
-
-    fn handle_response(
-        &self,
-        data: &types::authentication::ConnectorPostAuthenticationRouterData,
-        event_builder: Option<&mut ConnectorEvent>,
-        res: Response,
-    ) -> CustomResult<
-        types::authentication::ConnectorPostAuthenticationRouterData,
-        errors::ConnectorError,
-    > {
-        let response: threedsecureio::ThreedsecureioPostAuthenticationResponse = res
-            .response
-            .parse_struct("threedsecureio PaymentsSyncResponse")
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-        event_builder.map(|i| i.set_response_body(&response));
-        router_env::logger::info!(connector_response=?response);
-        Ok(
-            types::authentication::ConnectorPostAuthenticationRouterData {
-                response: Ok(
-                    types::authentication::AuthenticationResponseData::PostAuthNResponse {
-                        trans_status: response.trans_status.into(),
-                        authentication_value: response.authentication_value,
-                        eci: response.eci,
-                    },
-                ),
-                ..data.clone()
-            },
-        )
-    }
-
-    fn get_error_response(
-        &self,
-        res: Response,
-        event_builder: Option<&mut ConnectorEvent>,
-    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        self.build_error_response(res, event_builder)
-    }
-}
-
-impl
-    ConnectorIntegration<
-        api::PreAuthenticationVersionCall,
-        types::authentication::PreAuthNRequestData,
-        types::authentication::AuthenticationResponseData,
-    > for Threedsecureio
-{
-}
-
-impl ConnectorSpecifications for Threedsecureio {}
diff --git a/crates/router/src/connector/utils.rs b/crates/router/src/connector/utils.rs
index e0034a63335..ddef185649b 100644
--- a/crates/router/src/connector/utils.rs
+++ b/crates/router/src/connector/utils.rs
@@ -2395,30 +2395,6 @@ impl FraudCheckSaleRequest for fraud_check::FraudCheckSaleData {
     }
 }
 
-#[cfg(feature = "frm")]
-pub trait FraudCheckCheckoutRequest {
-    fn get_order_details(&self) -> Result<Vec<OrderDetailsWithAmount>, Error>;
-}
-#[cfg(feature = "frm")]
-impl FraudCheckCheckoutRequest for fraud_check::FraudCheckCheckoutData {
-    fn get_order_details(&self) -> Result<Vec<OrderDetailsWithAmount>, Error> {
-        self.order_details
-            .clone()
-            .ok_or_else(missing_field_err("order_details"))
-    }
-}
-
-#[cfg(feature = "frm")]
-pub trait FraudCheckTransactionRequest {
-    fn get_currency(&self) -> Result<storage_enums::Currency, Error>;
-}
-#[cfg(feature = "frm")]
-impl FraudCheckTransactionRequest for fraud_check::FraudCheckTransactionData {
-    fn get_currency(&self) -> Result<storage_enums::Currency, Error> {
-        self.currency.ok_or_else(missing_field_err("currency"))
-    }
-}
-
 #[cfg(feature = "frm")]
 pub trait FraudCheckRecordReturnRequest {
     fn get_currency(&self) -> Result<storage_enums::Currency, Error>;
diff --git a/crates/router/src/core/payments/flows.rs b/crates/router/src/core/payments/flows.rs
index 68daf6f1531..ff52833cd49 100644
--- a/crates/router/src/core/payments/flows.rs
+++ b/crates/router/src/core/payments/flows.rs
@@ -217,13 +217,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_complete_authorize!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wise,
-    connector::Wellsfargopayout
-);
+default_imp_for_complete_authorize!(connector::Stripe);
 macro_rules! default_imp_for_webhook_source_verification {
     ($($path:ident::$connector:ident),*) => {
         $(
@@ -250,13 +244,7 @@ impl<const T: u8>
     > for connector::DummyConnector<T>
 {
 }
-default_imp_for_webhook_source_verification!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_webhook_source_verification!(connector::Stripe);
 
 macro_rules! default_imp_for_create_customer {
     ($($path:ident::$connector:ident),*) => {
@@ -285,12 +273,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_create_customer!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_create_customer!();
 
 macro_rules! default_imp_for_connector_redirect_response {
     ($($path:ident::$connector:ident),*) => {
@@ -321,12 +304,7 @@ impl<const T: u8> services::ConnectorRedirectResponse for connector::DummyConnec
     }
 }
 
-default_imp_for_connector_redirect_response!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_connector_redirect_response!();
 
 macro_rules! default_imp_for_connector_request_id {
     ($($path:ident::$connector:ident),*) => {
@@ -339,13 +317,7 @@ macro_rules! default_imp_for_connector_request_id {
 #[cfg(feature = "dummy_connector")]
 impl<const T: u8> api::ConnectorTransactionId for connector::DummyConnector<T> {}
 
-default_imp_for_connector_request_id!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_connector_request_id!(connector::Stripe);
 
 macro_rules! default_imp_for_accept_dispute {
     ($($path:ident::$connector:ident),*) => {
@@ -377,13 +349,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_accept_dispute!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_accept_dispute!(connector::Stripe);
 
 macro_rules! default_imp_for_file_upload {
     ($($path:ident::$connector:ident),*) => {
@@ -434,12 +400,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_file_upload!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_file_upload!();
 
 macro_rules! default_imp_for_submit_evidence {
     ($($path:ident::$connector:ident),*) => {
@@ -468,12 +429,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_submit_evidence!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_submit_evidence!();
 
 macro_rules! default_imp_for_defend_dispute {
     ($($path:ident::$connector:ident),*) => {
@@ -502,13 +458,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_defend_dispute!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_defend_dispute!(connector::Stripe);
 
 macro_rules! default_imp_for_pre_processing_steps{
     ($($path:ident::$connector:ident),*)=> {
@@ -552,13 +502,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_pre_processing_steps!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_pre_processing_steps!(connector::Stripe);
 
 #[cfg(feature = "dummy_connector")]
 impl<const T: u8> api::PaymentsPostProcessing for connector::DummyConnector<T> {}
@@ -572,13 +516,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_post_processing_steps!(
-    connector::Stripe,
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_post_processing_steps!(connector::Stripe);
 
 macro_rules! default_imp_for_payouts {
     ($($path:ident::$connector:ident),*) => {
@@ -591,11 +529,7 @@ macro_rules! default_imp_for_payouts {
 #[cfg(feature = "dummy_connector")]
 impl<const T: u8> Payouts for connector::DummyConnector<T> {}
 
-default_imp_for_payouts!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts!();
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_create {
@@ -625,11 +559,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_create!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_create!();
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_retrieve {
@@ -659,13 +589,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_retrieve!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_payouts_retrieve!(connector::Stripe);
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_eligibility {
@@ -698,12 +622,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_eligibility!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_eligibility!(connector::Stripe);
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_fulfill {
@@ -733,11 +652,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_fulfill!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_fulfill!();
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_cancel {
@@ -767,11 +682,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_cancel!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_cancel!();
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_quote {
@@ -801,12 +712,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_quote!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_quote!(connector::Stripe);
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_recipient {
@@ -836,11 +742,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_recipient!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout
-);
+default_imp_for_payouts_recipient!();
 
 #[cfg(feature = "payouts")]
 macro_rules! default_imp_for_payouts_recipient_account {
@@ -873,12 +775,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "payouts")]
-default_imp_for_payouts_recipient_account!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_payouts_recipient_account!();
 
 macro_rules! default_imp_for_approve {
     ($($path:ident::$connector:ident),*) => {
@@ -907,13 +804,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_approve!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_approve!(connector::Stripe);
 
 macro_rules! default_imp_for_reject {
     ($($path:ident::$connector:ident),*) => {
@@ -942,13 +833,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_reject!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_reject!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_fraud_check {
@@ -963,12 +848,7 @@ macro_rules! default_imp_for_fraud_check {
 impl<const T: u8> api::FraudCheck for connector::DummyConnector<T> {}
 
 #[cfg(feature = "frm")]
-default_imp_for_fraud_check!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_fraud_check!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_frm_sale {
@@ -999,12 +879,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "frm")]
-default_imp_for_frm_sale!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_frm_sale!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_frm_checkout {
@@ -1035,12 +910,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "frm")]
-default_imp_for_frm_checkout!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_frm_checkout!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_frm_transaction {
@@ -1071,12 +941,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "frm")]
-default_imp_for_frm_transaction!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_frm_transaction!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_frm_fulfillment {
@@ -1107,12 +972,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "frm")]
-default_imp_for_frm_fulfillment!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_frm_fulfillment!(connector::Stripe);
 
 #[cfg(feature = "frm")]
 macro_rules! default_imp_for_frm_record_return {
@@ -1143,12 +1003,7 @@ impl<const T: u8>
 }
 
 #[cfg(feature = "frm")]
-default_imp_for_frm_record_return!(
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_frm_record_return!(connector::Stripe);
 
 macro_rules! default_imp_for_incremental_authorization {
     ($($path:ident::$connector:ident),*) => {
@@ -1177,13 +1032,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_incremental_authorization!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_incremental_authorization!(connector::Stripe);
 
 macro_rules! default_imp_for_revoking_mandates {
     ($($path:ident::$connector:ident),*) => {
@@ -1210,12 +1059,7 @@ impl<const T: u8>
     > for connector::DummyConnector<T>
 {
 }
-default_imp_for_revoking_mandates!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wise
-);
+default_imp_for_revoking_mandates!(connector::Stripe);
 
 macro_rules! default_imp_for_connector_authentication {
     ($($path:ident::$connector:ident),*) => {
@@ -1303,12 +1147,7 @@ impl<const T: u8>
     > for connector::DummyConnector<T>
 {
 }
-default_imp_for_connector_authentication!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_connector_authentication!(connector::Stripe);
 
 macro_rules! default_imp_for_authorize_session_token {
     ($($path:ident::$connector:ident),*) => {
@@ -1334,13 +1173,7 @@ impl<const T: u8>
     > for connector::DummyConnector<T>
 {
 }
-default_imp_for_authorize_session_token!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_authorize_session_token!(connector::Stripe);
 
 macro_rules! default_imp_for_calculate_tax {
     ($($path:ident::$connector:ident),*) => {
@@ -1367,13 +1200,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_calculate_tax!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_calculate_tax!(connector::Stripe);
 
 macro_rules! default_imp_for_session_update {
     ($($path:ident::$connector:ident),*) => {
@@ -1400,13 +1227,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_session_update!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_session_update!(connector::Stripe);
 
 macro_rules! default_imp_for_post_session_tokens {
     ($($path:ident::$connector:ident),*) => {
@@ -1433,13 +1254,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_post_session_tokens!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_post_session_tokens!(connector::Stripe);
 
 macro_rules! default_imp_for_update_metadata {
     ($($path:ident::$connector:ident),*) => {
@@ -1466,12 +1281,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_update_metadata!(
-    connector::Signifyd,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_update_metadata!();
 
 macro_rules! default_imp_for_uas_pre_authentication {
     ($($path:ident::$connector:ident),*) => {
@@ -1501,13 +1311,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_uas_pre_authentication!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_uas_pre_authentication!(connector::Stripe);
 
 macro_rules! default_imp_for_uas_post_authentication {
     ($($path:ident::$connector:ident),*) => {
@@ -1534,13 +1338,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_uas_post_authentication!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_uas_post_authentication!(connector::Stripe);
 
 macro_rules! default_imp_for_uas_authentication_confirmation {
     ($($path:ident::$connector:ident),*) => {
@@ -1556,13 +1354,7 @@ macro_rules! default_imp_for_uas_authentication_confirmation {
     };
 }
 
-default_imp_for_uas_authentication_confirmation!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_uas_authentication_confirmation!(connector::Stripe);
 
 #[cfg(feature = "dummy_connector")]
 impl<const T: u8> UasAuthenticationConfirmation for connector::DummyConnector<T> {}
@@ -1602,13 +1394,7 @@ impl<const T: u8>
 {
 }
 
-default_imp_for_uas_authentication!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_uas_authentication!(connector::Stripe);
 
 /// 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
@@ -1731,11 +1517,11 @@ macro_rules! default_imp_for_revenue_recovery {
 impl<const T: u8> api::RevenueRecovery for connector::DummyConnector<T> {}
 
 default_imp_for_revenue_recovery! {
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
+
+    connector::Stripe
+
+
+
 }
 
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
@@ -1767,13 +1553,7 @@ impl<const T: u8>
 }
 
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-default_imp_for_billing_connector_payment_sync!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_billing_connector_payment_sync!(connector::Stripe);
 
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
 macro_rules! default_imp_for_revenue_recovery_record_back {
@@ -1804,13 +1584,7 @@ impl<const T: u8>
 {
 }
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-default_imp_for_revenue_recovery_record_back!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_revenue_recovery_record_back!(connector::Stripe);
 
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
 macro_rules! default_imp_for_billing_connector_invoice_sync {
@@ -1841,10 +1615,4 @@ impl<const T: u8>
 {
 }
 #[cfg(all(feature = "v2", feature = "revenue_recovery"))]
-default_imp_for_billing_connector_invoice_sync!(
-    connector::Signifyd,
-    connector::Stripe,
-    connector::Threedsecureio,
-    connector::Wellsfargopayout,
-    connector::Wise
-);
+default_imp_for_billing_connector_invoice_sync!(connector::Stripe);