Bug: Bank Redirects via stripe



Support `bank_redirects` through stripe.
diff --git a/.typos.toml b/.typos.toml
index e17306e1915..4e663dc448c 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -5,6 +5,7 @@ check-filename = true
 flate2 = "flate2"
 payment_vas = "payment_vas"
 PaymentVas = "PaymentVas"
+HypoNoeLbFurNiederosterreichUWien = "HypoNoeLbFurNiederosterreichUWien"
 
 [default.extend-words]
 aci = "aci" # Name of a connector
diff --git a/Cargo.lock b/Cargo.lock
index 8183ea5d40a..fd9a0205822 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -442,9 +442,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "awc"
-version = "3.1.0"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dff3fc64a176e0d4398c71b0f2c2679ff4a723c6ed8fcc68dfe5baa00665388"
+checksum = "87ef547a81796eb2dfe9b345aba34c2e08391a0502493711395b36dd64052b69"
 dependencies = [
  "actix-codec",
  "actix-http",
@@ -2315,15 +2315,6 @@ dependencies = [
  "minimal-lexical",
 ]
 
-[[package]]
-name = "nom8"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -3870,15 +3861,15 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.19.3"
+version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6a7712b49e1775fb9a7b998de6635b299237f48b404dde71704f2e0e7f37e5"
+checksum = "9a1eb0622d28f4b9c90adc4ea4b2b46b47663fde9ac5fafcb14a1369d5508825"
 dependencies = [
  "indexmap",
- "nom8",
  "serde",
  "serde_spanned",
  "toml_datetime",
+ "winnow",
 ]
 
 [[package]]
@@ -4458,6 +4449,15 @@ version = "0.42.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
 
+[[package]]
+name = "winnow"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf09497b8f8b5ac5d3bb4d05c0a99be20f26fd3d5f2db7b0716e946d5103658"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.10.1"
diff --git a/crates/api_models/src/admin.rs b/crates/api_models/src/admin.rs
index b517371ffca..00c9ebc0eeb 100644
--- a/crates/api_models/src/admin.rs
+++ b/crates/api_models/src/admin.rs
@@ -295,10 +295,10 @@ pub struct PaymentConnectorCreate {
 pub struct PaymentMethods {
     /// Type of payment method.
     #[schema(value_type = PaymentMethodType,example = "card")]
-    pub payment_method: api_enums::PaymentMethodType,
+    pub payment_method: api_enums::PaymentMethod,
     /// Subtype of payment method
     #[schema(value_type = Option<Vec<PaymentMethodSubType>>,example = json!(["credit"]))]
-    pub payment_method_types: Option<Vec<api_enums::PaymentMethodSubType>>,
+    pub payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,
     /// List of payment method issuers to be enabled for this payment method
     #[schema(example = json!(["HDFC"]))]
     pub payment_method_issuers: Option<Vec<String>>,
diff --git a/crates/api_models/src/enums.rs b/crates/api_models/src/enums.rs
index 033a1ce39d8..a0261293be5 100644
--- a/crates/api_models/src/enums.rs
+++ b/crates/api_models/src/enums.rs
@@ -420,13 +420,19 @@ pub enum PaymentExperience {
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
-pub enum PaymentMethodSubType {
+pub enum PaymentMethodType {
     Credit,
     Debit,
-    UpiIntent,
-    UpiCollect,
-    CreditCardInstallments,
-    PayLaterInstallments,
+    Giropay,
+    Ideal,
+    Sofort,
+    Eps,
+    Klarna,
+    Affirm,
+    AfterpayClearpay,
+    GooglePay,
+    ApplePay,
+    Paypal,
 }
 
 #[derive(
@@ -446,20 +452,12 @@ pub enum PaymentMethodSubType {
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
-pub enum PaymentMethodType {
-    Card,
-    PaymentContainer,
+pub enum PaymentMethod {
     #[default]
-    BankTransfer,
-    BankDebit,
+    Card,
     PayLater,
-    Netbanking,
-    Upi,
-    OpenBanking,
-    ConsumerFinance,
     Wallet,
-    Klarna,
-    Paypal,
+    BankRedirect,
 }
 
 #[derive(
@@ -647,6 +645,79 @@ pub enum SupportedWallets {
     Gpay,
 }
 
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    frunk::LabelledGeneric,
+)]
+#[strum(serialize_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
+pub enum BankNames {
+    AmericanExpress,
+    BankOfAmerica,
+    Barclays,
+    CapitalOne,
+    Chase,
+    Citi,
+    Discover,
+    NavyFederalCreditUnion,
+    PentagonFederalCreditUnion,
+    SynchronyBank,
+    WellsFargo,
+    AbnAmro,
+    AsnBank,
+    Bunq,
+    Handelsbanken,
+    Ing,
+    Knab,
+    Moneyou,
+    Rabobank,
+    Regiobank,
+    Revolut,
+    SnsBank,
+    TriodosBank,
+    VanLanschot,
+    ArzteUndApothekerBank,
+    AustrianAnadiBankAg,
+    BankAustria,
+    Bank99Ag,
+    BankhausCarlSpangler,
+    BankhausSchelhammerUndSchatteraAg,
+    BawagPskAg,
+    BksBankAg,
+    BrullKallmusBankAg,
+    BtvVierLanderBank,
+    CapitalBankGraweGruppeAg,
+    Dolomitenbank,
+    EasybankAg,
+    ErsteBankUndSparkassen,
+    HypoAlpeadriabankInternationalAg,
+    HypoNoeLbFurNiederosterreichUWien,
+    HypoOberosterreichSalzburgSteiermark,
+    HypoTirolBankAg,
+    HypoVorarlbergBankAg,
+    HypoBankBurgenlandAktiengesellschaft,
+    MarchfelderBank,
+    OberbankAg,
+    OsterreichischeArzteUndApothekerbank,
+    PosojilnicaBankEGen,
+    RaiffeisenBankengruppeOsterreich,
+    SchelhammerCapitalBankAg,
+    SchoellerbankAg,
+    SpardaBankWien,
+    VolksbankGruppe,
+    VolkskreditbankAg,
+    VrBankBraunau,
+}
+
 impl From<AttemptStatus> for IntentStatus {
     fn from(s: AttemptStatus) -> Self {
         match s {
diff --git a/crates/api_models/src/payment_methods.rs b/crates/api_models/src/payment_methods.rs
index ff5c0affc09..370232323fb 100644
--- a/crates/api_models/src/payment_methods.rs
+++ b/crates/api_models/src/payment_methods.rs
@@ -11,11 +11,11 @@ use crate::{admin, enums as api_enums};
 pub struct CreatePaymentMethod {
     /// The type of payment method use for the payment.
     #[schema(value_type = PaymentMethodType,example = "card")]
-    pub payment_method: api_enums::PaymentMethodType,
+    pub payment_method: api_enums::PaymentMethod,
 
     /// This is a sub-category of payment method.
-    #[schema(value_type = Option<PaymentMethodSubType>,example = "credit_card")]
-    pub payment_method_type: Option<api_enums::PaymentMethodSubType>,
+    #[schema(value_type = Option<PaymentMethodType>,example = "credit")]
+    pub payment_method_type: Option<api_enums::PaymentMethodType>,
 
     /// The name of the bank/ provider issuing the payment method to the end user
     #[schema(example = "Citibank")]
@@ -94,11 +94,11 @@ pub struct PaymentMethodResponse {
 
     /// The type of payment method use for the payment.
     #[schema(value_type = PaymentMethodType,example = "card")]
-    pub payment_method: api_enums::PaymentMethodType,
+    pub payment_method: api_enums::PaymentMethod,
 
     /// This is a sub-category of payment method.
-    #[schema(value_type = Option<PaymentMethodSubType>,example = "credit_card")]
-    pub payment_method_type: Option<api_enums::PaymentMethodSubType>,
+    #[schema(value_type = Option<PaymentMethodType>,example = "credit")]
+    pub payment_method_type: Option<api_enums::PaymentMethodType>,
 
     /// The name of the bank/ provider issuing the payment method to the end user
     #[schema(example = "Citibank")]
@@ -303,11 +303,11 @@ pub struct ListPaymentMethodResponse {
 pub struct ListPaymentMethod {
     /// The type of payment method use for the payment.
     #[schema(value_type = PaymentMethodType,example = "card")]
-    pub payment_method: api_enums::PaymentMethodType,
+    pub payment_method: api_enums::PaymentMethod,
 
     /// This is a sub-category of payment method.
     #[schema(value_type = Option<Vec<PaymentMethodSubType>>,example = json!(["credit_card"]))]
-    pub payment_method_types: Option<Vec<api_enums::PaymentMethodSubType>>,
+    pub payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,
 
     /// The name of the bank/ provider issuing the payment method to the end user
     #[schema(example = json!(["Citibank"]))]
@@ -380,7 +380,7 @@ impl serde::Serialize for ListPaymentMethod {
         state.serialize_field("payment_experience", &self.payment_experience)?;
         state.serialize_field("eligible_connectors", &self.eligible_connectors)?;
         match self.payment_method {
-            api_enums::PaymentMethodType::Wallet | api_enums::PaymentMethodType::PayLater => {
+            api_enums::PaymentMethod::Wallet | api_enums::PaymentMethod::PayLater => {
                 state.serialize_field("payment_method_issuers", &self.payment_method_issuers)?;
             }
             _ => {
@@ -437,11 +437,11 @@ pub struct CustomerPaymentMethod {
 
     /// The type of payment method use for the payment.
     #[schema(value_type = PaymentMethodType,example = "card")]
-    pub payment_method: api_enums::PaymentMethodType,
+    pub payment_method: api_enums::PaymentMethod,
 
     /// This is a sub-category of payment method.
     #[schema(value_type = Option<PaymentMethodSubType>,example = "credit_card")]
-    pub payment_method_type: Option<api_enums::PaymentMethodSubType>,
+    pub payment_method_type: Option<api_enums::PaymentMethodType>,
 
     /// The name of the bank/ provider issuing the payment method to the end user
     #[schema(example = "Citibank")]
diff --git a/crates/api_models/src/payments.rs b/crates/api_models/src/payments.rs
index 3adcc5e315d..25c8a6f115c 100644
--- a/crates/api_models/src/payments.rs
+++ b/crates/api_models/src/payments.rs
@@ -6,7 +6,10 @@ use router_derive::Setter;
 use time::PrimitiveDateTime;
 use utoipa::ToSchema;
 
-use crate::{enums as api_enums, refunds};
+use crate::{
+    enums::{self as api_enums},
+    refunds,
+};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum PaymentOp {
@@ -28,97 +31,126 @@ pub struct PaymentsRequest {
     )]
     #[serde(default, deserialize_with = "payment_id_type::deserialize_option")]
     pub payment_id: Option<PaymentIdType>,
+
     /// This is an identifier for the merchant account. This is inferred from the API key
     /// provided during the request
     #[schema(max_length = 255, example = "merchant_1668273825")]
     pub merchant_id: Option<String>,
+
     /// The payment amount. Amount for the payment in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc.,
     #[schema(value_type = Option<u64>, example = 6540)]
     #[serde(default, deserialize_with = "amount::deserialize_option")]
     pub amount: Option<Amount>,
+
     /// This allows the merchant to manually select a connector with which the payment can go through
     #[schema(value_type = Option<Connector>, max_length = 255, example = "stripe")]
     pub connector: Option<Vec<api_enums::Connector>>,
     /// The currency of the payment request can be specified here
     #[schema(value_type = Option<Currency>, example = "USD")]
     pub currency: Option<api_enums::Currency>,
+
     /// This is the instruction for capture/ debit the money from the users' card. On the other hand authorization refers to blocking the amount on the users' payment method.
     #[schema(value_type = Option<CaptureMethod>, example = "PaymentProcessor")]
     pub capture_method: Option<api_enums::CaptureMethod>,
+
     /// The Amount to be captured/ debited from the users payment method. It shall be in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc.,
     /// If not provided, the default amount_to_capture will be the payment amount.
     #[schema(example = 6540)]
     pub amount_to_capture: Option<i64>,
+
     /// A timestamp (ISO 8601 code) that determines when the payment should be captured.
     /// Providing this field will automatically set `capture` to true
     #[schema(example = "2022-09-10T10:11:12Z")]
     #[serde(default, with = "common_utils::custom_serde::iso8601::option")]
     pub capture_on: Option<PrimitiveDateTime>,
+
     /// Whether to confirm the payment (if applicable)
     #[schema(default = false, example = true)]
     pub confirm: Option<bool>,
+
     /// The identifier for the customer object. If not provided the customer ID will be autogenerated.
     #[schema(max_length = 255, example = "cus_y3oqhf46pyzuxjbcn2giaqnb44")]
     pub customer_id: Option<String>,
+
     /// description: The customer's email address
     #[schema(max_length = 255, value_type = Option<String>, example = "johntest@test.com")]
     pub email: Option<Secret<String, pii::Email>>,
+
     /// description: The customer's name
     #[schema(value_type = Option<String>, max_length = 255, example = "John Test")]
     pub name: Option<Secret<String>>,
+
     /// The customer's phone number
     #[schema(value_type = Option<String>, max_length = 255, example = "3141592653")]
     pub phone: Option<Secret<String>>,
+
     /// The country code for the customer phone number
     #[schema(max_length = 255, example = "+1")]
     pub phone_country_code: Option<String>,
+
     /// Set to true to indicate that the customer is not in your checkout flow during this payment, and therefore is unable to authenticate. This parameter is intended for scenarios where you collect card details and charge them later. This parameter can only be used with `confirm: true`.
     #[schema(example = true)]
     pub off_session: Option<bool>,
+
     /// A description of the payment
     #[schema(example = "It's my first payment request")]
     pub description: Option<String>,
+
     /// The URL to redirect after the completion of the operation
     #[schema(example = "https://hyperswitch.io")]
     pub return_url: Option<url::Url>,
     /// Indicates that you intend to make future payments with this Payment’s payment method. Providing this parameter will attach the payment method to the Customer, if present, after the Payment is confirmed and any required actions from the user are complete.
     #[schema(value_type = Option<FutureUsage>, example = "off_session")]
     pub setup_future_usage: Option<api_enums::FutureUsage>,
+
     /// The transaction authentication can be set to undergo payer authentication.
     #[schema(value_type = Option<AuthenticationType>, example = "no_three_ds", default = "three_ds")]
     pub authentication_type: Option<api_enums::AuthenticationType>,
+
     /// The payment method information provided for making a payment
     #[schema(example = "bank_transfer")]
-    pub payment_method_data: Option<PaymentMethod>,
+    pub payment_method_data: Option<PaymentMethodData>,
+
     /// The payment method that is to be used
     #[schema(value_type = Option<PaymentMethodType>, example = "bank_transfer")]
-    pub payment_method: Option<api_enums::PaymentMethodType>,
+    pub payment_method: Option<api_enums::PaymentMethod>,
+
     /// Provide a reference to a stored payment method
     #[schema(example = "187282ab-40ef-47a9-9206-5099ba31e432")]
     pub payment_token: Option<String>,
+
     /// This is used when payment is to be confirmed and the card is not saved
     #[schema(value_type = Option<String>)]
     pub card_cvc: Option<Secret<String>>,
+
     /// The shipping address for the payment
     pub shipping: Option<Address>,
+
     /// The billing address for the payment
     pub billing: Option<Address>,
+
     /// For non-card charges, you can use this value as the complete description that appears on your customers’ statements. Must contain at least one letter, maximum 22 characters.
     #[schema(max_length = 255, example = "Juspay Router")]
     pub statement_descriptor_name: Option<String>,
+
     /// Provides information about a card payment that customers see on their statements. Concatenated with the prefix (shortened descriptor) or statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 22 characters for the concatenated descriptor.
     #[schema(max_length = 255, example = "Payment for shoes purchase")]
     pub statement_descriptor_suffix: Option<String>,
+
     /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.
     pub metadata: Option<Metadata>,
+
     /// It's a token used for client side verification.
     #[schema(example = "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo")]
     pub client_secret: Option<String>,
+
     /// Provide mandate information for creating a mandate
     pub mandate_data: Option<MandateData>,
+
     /// A unique identifier to link the payment to a mandate, can be use instead of payment_method_data
     #[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
     pub mandate_id: Option<String>,
+
     /// Additional details required by 3DS 2.0
     #[schema(value_type = Option<Object>, example = r#"{
         "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
@@ -132,12 +164,14 @@ pub struct PaymentsRequest {
         "java_script_enabled":true
     }"#)]
     pub browser_info: Option<serde_json::Value>,
-    /// Payment Issuser for the current payment
-    #[schema(value_type = Option<PaymentIssuer>, example = "klarna")]
-    pub payment_issuer: Option<api_enums::PaymentIssuer>,
-    /// Payment Experience, works in tandem with payment_issuer
+
+    /// Payment Experience for the current payment
     #[schema(value_type = Option<PaymentExperience>, example = "redirect_to_url")]
     pub payment_experience: Option<api_enums::PaymentExperience>,
+
+    /// Payment Method Type
+    #[schema(value_type = Option<PaymentMethodSubType>, example = "gpay")]
+    pub payment_method_type: Option<api_enums::PaymentMethodType>,
 }
 
 #[derive(Default, Debug, serde::Deserialize, serde::Serialize, Clone, Copy, PartialEq, Eq)]
@@ -182,8 +216,8 @@ pub struct VerifyRequest {
     pub name: Option<Secret<String>>,
     pub phone: Option<Secret<String>>,
     pub phone_country_code: Option<String>,
-    pub payment_method: Option<api_enums::PaymentMethodType>,
-    pub payment_method_data: Option<PaymentMethod>,
+    pub payment_method: Option<api_enums::PaymentMethod>,
+    pub payment_method_data: Option<PaymentMethodData>,
     pub payment_token: Option<String>,
     pub mandate_data: Option<MandateData>,
     pub setup_future_usage: Option<api_enums::FutureUsage>,
@@ -323,24 +357,8 @@ pub struct Card {
     /// The CVC number for the card
     #[schema(value_type = String, example = "242")]
     pub card_cvc: Secret<String>,
-}
-
-#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum KlarnaIssuer {
-    Klarna,
-}
-
-#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum AffirmIssuer {
-    Affirm,
-}
-
-#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum AfterpayClearpayIssuer {
-    AfterpayClearpay,
+    pub card_issuer: Option<String>,
+    pub card_network: Option<String>,
 }
 
 #[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
@@ -372,15 +390,89 @@ pub enum PayLaterData {
     },
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Default, serde::Deserialize, serde::Serialize, ToSchema)]
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
 #[serde(rename_all = "snake_case")]
-pub enum PaymentMethod {
+pub enum PaymentMethodData {
     Card(Card),
-    #[default]
-    BankTransfer,
     Wallet(WalletData),
     PayLater(PayLaterData),
-    Paypal,
+    BankRedirect(BankRedirectData),
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AdditionalPaymentData {
+    Card {
+        card_issuer: Option<String>,
+        card_network: Option<String>,
+    },
+    BankRedirect {
+        bank_name: Option<api_enums::BankNames>,
+    },
+    Wallet {},
+    PayLater {},
+}
+
+impl From<&PaymentMethodData> for AdditionalPaymentData {
+    fn from(pm_data: &PaymentMethodData) -> Self {
+        match pm_data {
+            PaymentMethodData::Card(card_data) => Self::Card {
+                card_issuer: card_data.card_issuer.to_owned(),
+                card_network: card_data.card_network.to_owned(),
+            },
+            PaymentMethodData::BankRedirect(bank_redirect_data) => match bank_redirect_data {
+                BankRedirectData::Eps { bank_name, .. } => Self::BankRedirect {
+                    bank_name: Some(bank_name.to_owned()),
+                },
+                BankRedirectData::Ideal { bank_name, .. } => Self::BankRedirect {
+                    bank_name: Some(bank_name.to_owned()),
+                },
+                _ => Self::BankRedirect { bank_name: None },
+            },
+            PaymentMethodData::Wallet(_) => Self::Wallet {},
+            PaymentMethodData::PayLater(_) => Self::PayLater {},
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BankRedirectData {
+    Eps {
+        /// The billing details for bank redirection
+        billing_details: BankRedirectBilling,
+        bank_name: api_enums::BankNames,
+    },
+    Giropay {
+        /// The billing details for bank redirection
+        billing_details: BankRedirectBilling,
+    },
+    Ideal {
+        /// The billing details for bank redirection
+        billing_details: BankRedirectBilling,
+        bank_name: api_enums::BankNames,
+    },
+    Sofort {
+        /// The country for bank payment
+        country: String,
+        /// The preferred language
+        preferred_language: String,
+    },
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct SofortBilling {
+    /// The country associated with the billing
+    pub billing_country: String,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BankRedirectionRequest {}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BankRedirectBilling {
+    /// The name for which billing is issued
+    pub billing_name: Secret<String>,
 }
 
 #[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
@@ -408,6 +500,7 @@ pub enum PaymentMethodDataResponse {
     Wallet(WalletData),
     PayLater(PayLaterData),
     Paypal,
+    BankRedirect(BankRedirectData),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, ToSchema)]
@@ -642,7 +735,7 @@ pub struct PaymentsResponse {
     /// The payment method that is to be used
     #[schema(value_type = PaymentMethodType, example = "bank_transfer")]
     #[auth_based]
-    pub payment_method: Option<api_enums::PaymentMethodType>,
+    pub payment_method: Option<api_enums::PaymentMethod>,
     /// The payment method information provided for making a payment
     #[schema(value_type = Option<PaymentMethod>, example = "bank_transfer")]
     #[auth_based]
@@ -688,6 +781,12 @@ pub struct PaymentsResponse {
     /// If there was an error while calling the connector the error message is received here
     #[schema(example = "Failed while verifying the card")]
     pub error_message: Option<String>,
+    /// Payment Experience for the current payment
+    #[schema(value_type = Option<PaymentExperience>, example = "redirect_to_url")]
+    pub payment_experience: Option<api_enums::PaymentExperience>,
+    /// Payment Method Type
+    #[schema(value_type = Option<PaymentMethodSubType>, example = "gpay")]
+    pub payment_method_type: Option<api_enums::PaymentMethodType>,
 }
 
 #[derive(Clone, Debug, serde::Deserialize, ToSchema)]
@@ -743,7 +842,7 @@ pub struct VerifyResponse {
     pub phone: Option<Secret<String>>,
     pub mandate_id: Option<String>,
     #[auth_based]
-    pub payment_method: Option<api_enums::PaymentMethodType>,
+    pub payment_method: Option<api_enums::PaymentMethod>,
     #[auth_based]
     pub payment_method_data: Option<PaymentMethodDataResponse>,
     pub payment_token: Option<String>,
@@ -846,14 +945,15 @@ impl From<Card> for CardResponse {
     }
 }
 
-impl From<PaymentMethod> for PaymentMethodDataResponse {
-    fn from(payment_method_data: PaymentMethod) -> Self {
+impl From<PaymentMethodData> for PaymentMethodDataResponse {
+    fn from(payment_method_data: PaymentMethodData) -> Self {
         match payment_method_data {
-            PaymentMethod::Card(card) => Self::Card(CardResponse::from(card)),
-            PaymentMethod::BankTransfer => Self::BankTransfer,
-            PaymentMethod::PayLater(pay_later_data) => Self::PayLater(pay_later_data),
-            PaymentMethod::Wallet(wallet_data) => Self::Wallet(wallet_data),
-            PaymentMethod::Paypal => Self::Paypal,
+            PaymentMethodData::Card(card) => Self::Card(CardResponse::from(card)),
+            PaymentMethodData::PayLater(pay_later_data) => Self::PayLater(pay_later_data),
+            PaymentMethodData::Wallet(wallet_data) => Self::Wallet(wallet_data),
+            PaymentMethodData::BankRedirect(bank_redirect_data) => {
+                Self::BankRedirect(bank_redirect_data)
+            }
         }
     }
 }
diff --git a/crates/drainer/Cargo.toml b/crates/drainer/Cargo.toml
index 58c0ccb16b3..cd36cbefdfd 100644
--- a/crates/drainer/Cargo.toml
+++ b/crates/drainer/Cargo.toml
@@ -12,7 +12,7 @@ async-bb8-diesel = { git = "https://github.com/juspay/async-bb8-diesel", rev = "
 bb8 = "0.8"
 clap = { version = "4.1.4", default-features = false, features = ["std", "derive", "help", "usage"] }
 config = { version = "0.13.3", features = ["toml"] }
-diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time"] }
+diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time", "64-column-tables"] }
 error-stack = "0.2.4"
 once_cell = "1.17.0"
 serde = "1.0.152"
diff --git a/crates/router/Cargo.toml b/crates/router/Cargo.toml
index ad3df36b5ca..827986c512c 100644
--- a/crates/router/Cargo.toml
+++ b/crates/router/Cargo.toml
@@ -39,7 +39,7 @@ bytes = "1.3.0"
 clap = { version = "4.1.4", default-features = false, features = ["std", "derive", "help", "usage"] }
 config = { version = "0.13.3", features = ["toml"] }
 crc32fast = "1.3.2"
-diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time"] }
+diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time", "64-column-tables"] }
 dyn-clone = "1.0.10"
 encoding_rs = "0.8.31"
 error-stack = "0.2.4"
diff --git a/crates/router/src/compatibility/stripe/errors.rs b/crates/router/src/compatibility/stripe/errors.rs
index cc6c5ba5e01..5c06739cbfc 100644
--- a/crates/router/src/compatibility/stripe/errors.rs
+++ b/crates/router/src/compatibility/stripe/errors.rs
@@ -456,6 +456,7 @@ impl From<errors::ApiErrorResponse> for StripeErrorCode {
             errors::ApiErrorResponse::DuplicatePayment { payment_id } => {
                 Self::DuplicatePayment { payment_id }
             }
+            errors::ApiErrorResponse::NotSupported { .. } => Self::InternalServerError,
         }
     }
 }
diff --git a/crates/router/src/compatibility/stripe/payment_intents/types.rs b/crates/router/src/compatibility/stripe/payment_intents/types.rs
index f2e27ab3b95..c08accb5199 100644
--- a/crates/router/src/compatibility/stripe/payment_intents/types.rs
+++ b/crates/router/src/compatibility/stripe/payment_intents/types.rs
@@ -48,7 +48,7 @@ pub enum StripePaymentMethodType {
     Card,
 }
 
-impl From<StripePaymentMethodType> for api_enums::PaymentMethodType {
+impl From<StripePaymentMethodType> for api_enums::PaymentMethod {
     fn from(item: StripePaymentMethodType) -> Self {
         match item {
             StripePaymentMethodType::Card => Self::Card,
@@ -65,12 +65,10 @@ pub struct StripePaymentMethodData {
     pub metadata: Option<Value>,
 }
 
-#[derive(Default, PartialEq, Eq, Deserialize, Clone)]
+#[derive(PartialEq, Eq, Deserialize, Clone)]
 #[serde(rename_all = "snake_case")]
 pub enum StripePaymentMethodDetails {
     Card(StripeCard),
-    #[default]
-    BankTransfer,
 }
 
 impl From<StripeCard> for payments::Card {
@@ -81,14 +79,15 @@ impl From<StripeCard> for payments::Card {
             card_exp_year: card.exp_year,
             card_holder_name: masking::Secret::new("stripe_cust".to_owned()),
             card_cvc: card.cvc,
+            card_issuer: None,
+            card_network: None,
         }
     }
 }
-impl From<StripePaymentMethodDetails> for payments::PaymentMethod {
+impl From<StripePaymentMethodDetails> for payments::PaymentMethodData {
     fn from(item: StripePaymentMethodDetails) -> Self {
         match item {
             StripePaymentMethodDetails::Card(card) => Self::Card(payments::Card::from(card)),
-            StripePaymentMethodDetails::BankTransfer => Self::BankTransfer,
         }
     }
 }
@@ -166,12 +165,12 @@ impl TryFrom<StripePaymentIntentRequest> for payments::PaymentsRequest {
             payment_method_data: item.payment_method_data.as_ref().and_then(|pmd| {
                 pmd.payment_method_details
                     .as_ref()
-                    .map(|spmd| payments::PaymentMethod::from(spmd.to_owned()))
+                    .map(|spmd| payments::PaymentMethodData::from(spmd.to_owned()))
             }),
             payment_method: item
                 .payment_method_data
                 .as_ref()
-                .map(|pmd| api_enums::PaymentMethodType::from(pmd.stype.to_owned())),
+                .map(|pmd| api_enums::PaymentMethod::from(pmd.stype.to_owned())),
             shipping: item
                 .shipping
                 .as_ref()
@@ -287,7 +286,7 @@ pub struct StripePaymentIntentResponse {
     pub authentication_type: Option<api_models::enums::AuthenticationType>,
     pub next_action: Option<payments::NextAction>,
     pub cancellation_reason: Option<String>,
-    pub payment_method: Option<api_models::enums::PaymentMethodType>,
+    pub payment_method: Option<api_models::enums::PaymentMethod>,
     pub payment_method_data: Option<payments::PaymentMethodDataResponse>,
     pub shipping: Option<payments::Address>,
     pub billing: Option<payments::Address>,
diff --git a/crates/router/src/compatibility/stripe/setup_intents/types.rs b/crates/router/src/compatibility/stripe/setup_intents/types.rs
index 7fe3110016c..d9e58f3fe5b 100644
--- a/crates/router/src/compatibility/stripe/setup_intents/types.rs
+++ b/crates/router/src/compatibility/stripe/setup_intents/types.rs
@@ -44,7 +44,7 @@ pub enum StripePaymentMethodType {
     Card,
 }
 
-impl From<StripePaymentMethodType> for api_enums::PaymentMethodType {
+impl From<StripePaymentMethodType> for api_enums::PaymentMethod {
     fn from(item: StripePaymentMethodType) -> Self {
         match item {
             StripePaymentMethodType::Card => Self::Card,
@@ -61,12 +61,10 @@ pub struct StripePaymentMethodData {
     pub metadata: Option<Value>,
 }
 
-#[derive(Default, PartialEq, Eq, Deserialize, Clone)]
+#[derive(PartialEq, Eq, Deserialize, Clone)]
 #[serde(rename_all = "snake_case")]
 pub enum StripePaymentMethodDetails {
     Card(StripeCard),
-    #[default]
-    BankTransfer,
 }
 
 impl From<StripeCard> for payments::Card {
@@ -77,14 +75,15 @@ impl From<StripeCard> for payments::Card {
             card_exp_year: card.exp_year,
             card_holder_name: masking::Secret::new("stripe_cust".to_owned()),
             card_cvc: card.cvc,
+            card_issuer: None,
+            card_network: None,
         }
     }
 }
-impl From<StripePaymentMethodDetails> for payments::PaymentMethod {
+impl From<StripePaymentMethodDetails> for payments::PaymentMethodData {
     fn from(item: StripePaymentMethodDetails) -> Self {
         match item {
             StripePaymentMethodDetails::Card(card) => Self::Card(payments::Card::from(card)),
-            StripePaymentMethodDetails::BankTransfer => Self::BankTransfer,
         }
     }
 }
@@ -146,12 +145,12 @@ impl From<StripeSetupIntentRequest> for payments::PaymentsRequest {
             payment_method_data: item.payment_method_data.as_ref().and_then(|pmd| {
                 pmd.payment_method_details
                     .as_ref()
-                    .map(|spmd| payments::PaymentMethod::from(spmd.to_owned()))
+                    .map(|spmd| payments::PaymentMethodData::from(spmd.to_owned()))
             }),
             payment_method: item
                 .payment_method_data
                 .as_ref()
-                .map(|pmd| api_enums::PaymentMethodType::from(pmd.stype.to_owned())),
+                .map(|pmd| api_enums::PaymentMethod::from(pmd.stype.to_owned())),
             shipping: item
                 .shipping
                 .as_ref()
diff --git a/crates/router/src/connector/aci/transformers.rs b/crates/router/src/connector/aci/transformers.rs
index ffab313bde6..47702ce119a 100644
--- a/crates/router/src/connector/aci/transformers.rs
+++ b/crates/router/src/connector/aci/transformers.rs
@@ -53,10 +53,10 @@ pub enum PaymentDetails {
     #[serde(rename = "card")]
     Card(CardDetails),
     #[serde(rename = "bank")]
-    BankAccount(BankDetails),
     Wallet,
     Klarna,
-    Paypal,
+    #[serde(rename = "bankRedirect")]
+    BankRedirect,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Serialize)]
@@ -101,19 +101,16 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for AciPaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let payment_details: PaymentDetails = match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => PaymentDetails::Card(CardDetails {
+            api::PaymentMethodData::Card(ccard) => PaymentDetails::Card(CardDetails {
                 card_number: ccard.card_number,
                 card_holder: ccard.card_holder_name,
                 card_expiry_month: ccard.card_exp_month,
                 card_expiry_year: ccard.card_exp_year,
                 card_cvv: ccard.card_cvc,
             }),
-            api::PaymentMethod::BankTransfer => PaymentDetails::BankAccount(BankDetails {
-                account_holder: "xyz".to_string(),
-            }),
-            api::PaymentMethod::PayLater(_) => PaymentDetails::Klarna,
-            api::PaymentMethod::Wallet(_) => PaymentDetails::Wallet,
-            api::PaymentMethod::Paypal => PaymentDetails::Paypal,
+            api::PaymentMethodData::PayLater(_) => PaymentDetails::Klarna,
+            api::PaymentMethodData::Wallet(_) => PaymentDetails::Wallet,
+            api::PaymentMethodData::BankRedirect(_) => PaymentDetails::BankRedirect,
         };
 
         let auth = AciAuthType::try_from(&item.connector_auth_type)?;
diff --git a/crates/router/src/connector/adyen/transformers.rs b/crates/router/src/connector/adyen/transformers.rs
index 98a57750d3e..da9397f9563 100644
--- a/crates/router/src/connector/adyen/transformers.rs
+++ b/crates/router/src/connector/adyen/transformers.rs
@@ -334,13 +334,11 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for AdyenPaymentRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         match item.payment_method {
-            storage_models::enums::PaymentMethodType::Card => get_card_specific_payment_data(item),
-            storage_models::enums::PaymentMethodType::PayLater => {
+            storage_models::enums::PaymentMethod::Card => get_card_specific_payment_data(item),
+            storage_models::enums::PaymentMethod::PayLater => {
                 get_paylater_specific_payment_data(item)
             }
-            storage_models::enums::PaymentMethodType::Wallet => {
-                get_wallet_specific_payment_data(item)
-            }
+            storage_models::enums::PaymentMethod::Wallet => get_wallet_specific_payment_data(item),
             _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
         }
     }
@@ -472,7 +470,7 @@ fn get_payment_method_data(
     item: &types::PaymentsAuthorizeRouterData,
 ) -> Result<AdyenPaymentMethod, error_stack::Report<errors::ConnectorError>> {
     match item.request.payment_method_data {
-        api::PaymentMethod::Card(ref card) => {
+        api::PaymentMethodData::Card(ref card) => {
             let adyen_card = AdyenCard {
                 payment_type: PaymentType::Scheme,
                 number: card.card_number.clone(),
@@ -482,7 +480,7 @@ fn get_payment_method_data(
             };
             Ok(AdyenPaymentMethod::AdyenCard(adyen_card))
         }
-        api::PaymentMethod::Wallet(ref wallet_data) => match wallet_data.issuer_name {
+        api::PaymentMethodData::Wallet(ref wallet_data) => match wallet_data.issuer_name {
             api_enums::WalletIssuer::GooglePay => {
                 let gpay_data = AdyenGPay {
                     payment_type: PaymentType::Googlepay,
@@ -511,29 +509,30 @@ fn get_payment_method_data(
                 Ok(AdyenPaymentMethod::AdyenPaypal(wallet))
             }
         },
-        api_models::payments::PaymentMethod::PayLater(ref pay_later_data) => match pay_later_data {
-            api_models::payments::PayLaterData::KlarnaRedirect { .. } => {
-                let klarna = AdyenPayLaterData {
-                    payment_type: PaymentType::Klarna,
-                };
-                Ok(AdyenPaymentMethod::AdyenKlarna(klarna))
-            }
-            api_models::payments::PayLaterData::AffirmRedirect { .. } => {
-                Ok(AdyenPaymentMethod::AdyenAffirm(AdyenPayLaterData {
-                    payment_type: PaymentType::Affirm,
-                }))
+        api_models::payments::PaymentMethodData::PayLater(ref pay_later_data) => {
+            match pay_later_data {
+                api_models::payments::PayLaterData::KlarnaRedirect { .. } => {
+                    let klarna = AdyenPayLaterData {
+                        payment_type: PaymentType::Klarna,
+                    };
+                    Ok(AdyenPaymentMethod::AdyenKlarna(klarna))
+                }
+                api_models::payments::PayLaterData::AffirmRedirect { .. } => {
+                    Ok(AdyenPaymentMethod::AdyenAffirm(AdyenPayLaterData {
+                        payment_type: PaymentType::Affirm,
+                    }))
+                }
+                api_models::payments::PayLaterData::AfterpayClearpayRedirect { .. } => {
+                    Ok(AdyenPaymentMethod::AfterPay(AdyenPayLaterData {
+                        payment_type: PaymentType::Afterpaytouch,
+                    }))
+                }
+                _ => Err(
+                    errors::ConnectorError::NotImplemented("Payment methods".to_string()).into(),
+                ),
             }
-            api_models::payments::PayLaterData::AfterpayClearpayRedirect { .. } => {
-                Ok(AdyenPaymentMethod::AfterPay(AdyenPayLaterData {
-                    payment_type: PaymentType::Afterpaytouch,
-                }))
-            }
-            _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
-        },
-        api_models::payments::PaymentMethod::BankTransfer
-        | api_models::payments::PaymentMethod::Paypal => {
-            Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into())
         }
+        _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
     }
 }
 
diff --git a/crates/router/src/connector/airwallex/transformers.rs b/crates/router/src/connector/airwallex/transformers.rs
index 97e876bd091..938d14cba7b 100644
--- a/crates/router/src/connector/airwallex/transformers.rs
+++ b/crates/router/src/connector/airwallex/transformers.rs
@@ -83,7 +83,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for AirwallexPaymentsRequest {
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let mut payment_method_options = None;
         let payment_method = match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => {
+            api::PaymentMethodData::Card(ccard) => {
                 payment_method_options =
                     Some(AirwallexPaymentOptions::Card(AirwallexCardPaymentOptions {
                         auto_capture: matches!(
diff --git a/crates/router/src/connector/authorizedotnet/transformers.rs b/crates/router/src/connector/authorizedotnet/transformers.rs
index b0a744d1287..40c29a1b9dc 100644
--- a/crates/router/src/connector/authorizedotnet/transformers.rs
+++ b/crates/router/src/connector/authorizedotnet/transformers.rs
@@ -64,12 +64,14 @@ enum PaymentDetails {
     Wallet,
     Klarna,
     Paypal,
+    #[serde(rename = "bankRedirect")]
+    BankRedirect,
 }
 
-impl From<api_models::payments::PaymentMethod> for PaymentDetails {
-    fn from(value: api_models::payments::PaymentMethod) -> Self {
+impl From<api_models::payments::PaymentMethodData> for PaymentDetails {
+    fn from(value: api_models::payments::PaymentMethodData) -> Self {
         match value {
-            api::PaymentMethod::Card(ref ccard) => {
+            api::PaymentMethodData::Card(ref ccard) => {
                 Self::CreditCard(CreditCardDetails {
                     card_number: ccard.card_number.clone(),
                     // expiration_date: format!("{expiry_year}-{expiry_month}").into(),
@@ -81,12 +83,9 @@ impl From<api_models::payments::PaymentMethod> for PaymentDetails {
                     card_code: Some(ccard.card_cvc.clone()),
                 })
             }
-            api::PaymentMethod::BankTransfer => Self::BankAccount(BankAccountDetails {
-                account_number: "XXXXX".to_string().into(),
-            }),
-            api::PaymentMethod::PayLater(_) => Self::Klarna,
-            api::PaymentMethod::Wallet(_) => Self::Wallet,
-            api::PaymentMethod::Paypal => Self::Paypal,
+            api::PaymentMethodData::PayLater(_) => Self::Klarna,
+            api::PaymentMethodData::Wallet(_) => Self::Wallet,
+            api::PaymentMethodData::BankRedirect(_) => Self::BankRedirect,
         }
     }
 }
diff --git a/crates/router/src/connector/bluesnap/transformers.rs b/crates/router/src/connector/bluesnap/transformers.rs
index 89c088e1c7f..3c12c2de368 100644
--- a/crates/router/src/connector/bluesnap/transformers.rs
+++ b/crates/router/src/connector/bluesnap/transformers.rs
@@ -44,7 +44,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for BluesnapPaymentsRequest {
             _ => BluesnapTxnType::AuthCapture,
         };
         let payment_method = match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => Ok(PaymentMethodDetails::CreditCard(Card {
+            api::PaymentMethodData::Card(ccard) => Ok(PaymentMethodDetails::CreditCard(Card {
                 card_number: ccard.card_number,
                 expiration_month: ccard.card_exp_month.clone(),
                 expiration_year: ccard.card_exp_year.clone(),
diff --git a/crates/router/src/connector/braintree/transformers.rs b/crates/router/src/connector/braintree/transformers.rs
index 59e854f46d2..97ec3ed87d5 100644
--- a/crates/router/src/connector/braintree/transformers.rs
+++ b/crates/router/src/connector/braintree/transformers.rs
@@ -101,7 +101,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for BraintreePaymentsRequest {
         let kind = "sale".to_string();
 
         let payment_method_data_type = match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => Ok(PaymentMethodType::CreditCard(Card {
+            api::PaymentMethodData::Card(ccard) => Ok(PaymentMethodType::CreditCard(Card {
                 credit_card: CardDetails {
                     number: ccard.card_number,
                     expiration_month: ccard.card_exp_month,
@@ -109,7 +109,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for BraintreePaymentsRequest {
                     cvv: ccard.card_cvc,
                 },
             })),
-            api::PaymentMethod::Wallet(ref wallet_data) => {
+            api::PaymentMethodData::Wallet(ref wallet_data) => {
                 Ok(PaymentMethodType::PaymentMethodNonce(Nonce {
                     payment_method_nonce: wallet_data
                         .token
diff --git a/crates/router/src/connector/checkout/transformers.rs b/crates/router/src/connector/checkout/transformers.rs
index bdda148bb3a..a8255708801 100644
--- a/crates/router/src/connector/checkout/transformers.rs
+++ b/crates/router/src/connector/checkout/transformers.rs
@@ -73,11 +73,10 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let ccard = match item.request.payment_method_data {
-            api::PaymentMethod::Card(ref ccard) => Some(ccard),
-            api::PaymentMethod::BankTransfer
-            | api::PaymentMethod::Wallet(_)
-            | api::PaymentMethod::PayLater(_)
-            | api::PaymentMethod::Paypal => None,
+            api::PaymentMethodData::Card(ref ccard) => Some(ccard),
+            api::PaymentMethodData::Wallet(_)
+            | api::PaymentMethodData::PayLater(_)
+            | api::PaymentMethodData::BankRedirect(_) => None,
         };
 
         let three_ds = match item.auth_type {
diff --git a/crates/router/src/connector/cybersource/transformers.rs b/crates/router/src/connector/cybersource/transformers.rs
index 59ba3a28314..b4de0645900 100644
--- a/crates/router/src/connector/cybersource/transformers.rs
+++ b/crates/router/src/connector/cybersource/transformers.rs
@@ -108,7 +108,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for CybersourcePaymentsRequest
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => {
+            api::PaymentMethodData::Card(ccard) => {
                 let phone = item.get_billing_phone()?;
                 let phone_number = phone.get_number()?;
                 let country_code = phone.get_country_code()?;
diff --git a/crates/router/src/connector/dlocal/transformers.rs b/crates/router/src/connector/dlocal/transformers.rs
index f429d6cd3eb..d571e6721b7 100644
--- a/crates/router/src/connector/dlocal/transformers.rs
+++ b/crates/router/src/connector/dlocal/transformers.rs
@@ -73,7 +73,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for DlocalPaymentsRequest {
         let country = address.get_country()?;
         let name = get_payer_name(address);
         match item.request.payment_method_data {
-            api::PaymentMethod::Card(ref ccard) => {
+            api::PaymentMethodData::Card(ref ccard) => {
                 let should_capture = matches!(
                     item.request.capture_method,
                     Some(enums::CaptureMethod::Automatic)
diff --git a/crates/router/src/connector/fiserv/transformers.rs b/crates/router/src/connector/fiserv/transformers.rs
index 6699991b157..6f2adf90449 100644
--- a/crates/router/src/connector/fiserv/transformers.rs
+++ b/crates/router/src/connector/fiserv/transformers.rs
@@ -65,7 +65,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for FiservPaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         match item.request.payment_method_data {
-            api::PaymentMethod::Card(ref ccard) => {
+            api::PaymentMethodData::Card(ref ccard) => {
                 let auth: FiservAuthType = FiservAuthType::try_from(&item.connector_auth_type)?;
                 let amount = Amount {
                     total: item.request.amount,
diff --git a/crates/router/src/connector/klarna.rs b/crates/router/src/connector/klarna.rs
index a6d0efc8577..9781e19b0d8 100644
--- a/crates/router/src/connector/klarna.rs
+++ b/crates/router/src/connector/klarna.rs
@@ -231,15 +231,15 @@ impl
     ) -> CustomResult<String, errors::ConnectorError> {
         let payment_method_data = &req.request.payment_method_data;
         match payment_method_data {
-            api_payments::PaymentMethod::PayLater(api_payments::PayLaterData::KlarnaSdk {
+            api_payments::PaymentMethodData::PayLater(api_payments::PayLaterData::KlarnaSdk {
                 token,
             }) => match (
-                req.request.payment_issuer.as_ref(),
                 req.request.payment_experience.as_ref(),
+                req.request.payment_method_type.as_ref(),
             ) {
                 (
-                    Some(storage_enums::PaymentIssuer::Klarna),
                     Some(storage_enums::PaymentExperience::InvokeSdkClient),
+                    Some(storage_enums::PaymentMethodType::Klarna),
                 ) => Ok(format!(
                     "{}payments/v1/authorizations/{}/order",
                     self.base_url(connectors),
@@ -247,7 +247,7 @@ impl
                 )),
                 (None, _) | (_, None) => Err(error_stack::report!(
                     errors::ConnectorError::MissingRequiredField {
-                        field_name: "payment_issuer and payment_experience"
+                        field_name: "payment_experience/payment_method_type"
                     }
                 )),
                 _ => Err(error_stack::report!(
diff --git a/crates/router/src/connector/nuvei/transformers.rs b/crates/router/src/connector/nuvei/transformers.rs
index 6fa32954a90..da6b627b0af 100644
--- a/crates/router/src/connector/nuvei/transformers.rs
+++ b/crates/router/src/connector/nuvei/transformers.rs
@@ -238,7 +238,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for NuveiPaymentsRequest {
         let time_stamp = date_time::date_as_yyyymmddhhmmss();
         let merchant_secret = connector_meta.merchant_secret;
         match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(card) => Ok(Self {
+            api::PaymentMethodData::Card(card) => Ok(Self {
                 merchant_id: merchant_id.clone(),
                 merchant_site_id: merchant_site_id.clone(),
                 client_request_id: client_request_id.clone(),
diff --git a/crates/router/src/connector/payu/transformers.rs b/crates/router/src/connector/payu/transformers.rs
index 3c107ddcb1b..9ea06ccb859 100644
--- a/crates/router/src/connector/payu/transformers.rs
+++ b/crates/router/src/connector/payu/transformers.rs
@@ -70,7 +70,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PayuPaymentsRequest {
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let auth_type = PayuAuthType::try_from(&item.connector_auth_type)?;
         let payment_method = match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => Ok(PayuPaymentMethod {
+            api::PaymentMethodData::Card(ccard) => Ok(PayuPaymentMethod {
                 pay_method: PayuPaymentMethodData::Card(PayuCard::Card {
                     number: ccard.card_number,
                     expiration_month: ccard.card_exp_month,
@@ -78,7 +78,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PayuPaymentsRequest {
                     cvv: ccard.card_cvc,
                 }),
             }),
-            api::PaymentMethod::Wallet(wallet_data) => match wallet_data.issuer_name {
+            api::PaymentMethodData::Wallet(wallet_data) => match wallet_data.issuer_name {
                 api_models::enums::WalletIssuer::GooglePay => Ok(PayuPaymentMethod {
                     pay_method: PayuPaymentMethodData::Wallet({
                         PayuWallet {
diff --git a/crates/router/src/connector/rapyd/transformers.rs b/crates/router/src/connector/rapyd/transformers.rs
index 96cdfee8d2f..d1ecf73add0 100644
--- a/crates/router/src/connector/rapyd/transformers.rs
+++ b/crates/router/src/connector/rapyd/transformers.rs
@@ -73,7 +73,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for RapydPaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         let (capture, payment_method_options) = match item.payment_method {
-            storage_models::enums::PaymentMethodType::Card => {
+            storage_models::enums::PaymentMethod::Card => {
                 let three_ds_enabled = matches!(item.auth_type, enums::AuthenticationType::ThreeDs);
                 let payment_method_options = PaymentMethodOptions {
                     three_ds: three_ds_enabled,
@@ -89,7 +89,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for RapydPaymentsRequest {
             _ => (None, None),
         };
         let payment_method = match item.request.payment_method_data {
-            api_models::payments::PaymentMethod::Card(ref ccard) => {
+            api_models::payments::PaymentMethodData::Card(ref ccard) => {
                 Some(PaymentMethod {
                     pm_type: "in_amex_card".to_owned(), //[#369] Map payment method type based on country
                     fields: Some(PaymentFields {
@@ -103,7 +103,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for RapydPaymentsRequest {
                     digital_wallet: None,
                 })
             }
-            api_models::payments::PaymentMethod::Wallet(ref wallet_data) => {
+            api_models::payments::PaymentMethodData::Wallet(ref wallet_data) => {
                 let digital_wallet = match wallet_data.issuer_name {
                     api_models::enums::WalletIssuer::GooglePay => Some(RapydWallet {
                         payment_type: "google_pay".to_string(),
diff --git a/crates/router/src/connector/shift4/transformers.rs b/crates/router/src/connector/shift4/transformers.rs
index 76370d53c08..e21eaec6b88 100644
--- a/crates/router/src/connector/shift4/transformers.rs
+++ b/crates/router/src/connector/shift4/transformers.rs
@@ -32,7 +32,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for Shift4PaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         match item.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(ccard) => {
+            api::PaymentMethodData::Card(ccard) => {
                 let submit_for_settlement = matches!(
                     item.request.capture_method,
                     Some(enums::CaptureMethod::Automatic) | None
diff --git a/crates/router/src/connector/stripe.rs b/crates/router/src/connector/stripe.rs
index 1f15f8eca79..ab508b8eaca 100644
--- a/crates/router/src/connector/stripe.rs
+++ b/crates/router/src/connector/stripe.rs
@@ -4,6 +4,7 @@ use std::{collections::HashMap, fmt::Debug};
 
 use error_stack::{IntoReport, ResultExt};
 use router_env::{instrument, tracing};
+use storage_models::enums;
 
 use self::transformers as stripe;
 use super::utils::RefundsRequestData;
@@ -164,9 +165,9 @@ impl
         types::PaymentsCaptureData: Clone,
         types::PaymentsResponseData: Clone,
     {
-        let response: stripe::PaymentIntentResponse = res
+        let response: stripe::PaymentIntentSyncResponse = res
             .response
-            .parse_struct("PaymentIntentResponse")
+            .parse_struct("PaymentIntentSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         types::RouterData::try_from(types::ResponseRouterData {
             response,
@@ -264,9 +265,9 @@ impl
         types::PaymentsAuthorizeData: Clone,
         types::PaymentsResponseData: Clone,
     {
-        let response: stripe::PaymentIntentResponse = res
+        let response: stripe::PaymentIntentSyncResponse = res
             .response
-            .parse_struct("PaymentSyncResponse")
+            .parse_struct("PaymentIntentSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
         types::RouterData::try_from(types::ResponseRouterData {
             response,
@@ -979,15 +980,20 @@ impl services::ConnectorRedirectResponse for Stripe {
                 .into_report()
                 .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
 
+        crate::logger::debug!(stripe_redirect_response=?query);
+
         Ok(query
             .redirect_status
-            .map_or(payments::CallConnectorAction::Trigger, |status| {
-                // Get failed error message by triggering call to connector
-                if status == transformers::StripePaymentStatus::Failed {
-                    payments::CallConnectorAction::Trigger
-                } else {
-                    payments::CallConnectorAction::StatusUpdate(status.into())
-                }
-            }))
+            .map_or(
+                payments::CallConnectorAction::Trigger,
+                |status| match status {
+                    transformers::StripePaymentStatus::Failed => {
+                        payments::CallConnectorAction::Trigger
+                    }
+                    _ => payments::CallConnectorAction::StatusUpdate(enums::AttemptStatus::from(
+                        status,
+                    )),
+                },
+            ))
     }
 }
diff --git a/crates/router/src/connector/stripe/transformers.rs b/crates/router/src/connector/stripe/transformers.rs
index a38a9a1040d..a23f4af796c 100644
--- a/crates/router/src/connector/stripe/transformers.rs
+++ b/crates/router/src/connector/stripe/transformers.rs
@@ -1,4 +1,4 @@
-use std::{ops::Deref, str::FromStr};
+use std::str::FromStr;
 
 use api_models::{self, payments};
 use common_utils::{fp_utils, pii::Email};
@@ -131,14 +131,71 @@ pub struct StripePayLaterData {
     pub payment_method_data_type: StripePaymentMethodType,
 }
 
+#[derive(Debug, Eq, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum StripeBankName {
+    Eps {
+        #[serde(rename = "payment_method_data[eps][bank]")]
+        bank_name: api_models::enums::BankNames,
+    },
+    Ideal {
+        #[serde(rename = "payment_method_data[ideal][bank]")]
+        ideal_bank_name: api_models::enums::BankNames,
+    },
+}
+
+#[derive(Debug, Eq, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum BankSpecificData {
+    Sofort {
+        #[serde(rename = "payment_method_options[sofort][preferred_language]")]
+        preferred_language: String,
+        #[serde(rename = "payment_method_data[sofort][country]")]
+        country: String,
+    },
+}
+
+fn get_bank_name(
+    stripe_pm_type: &StripePaymentMethodType,
+    bank_redirect_data: &api_models::payments::BankRedirectData,
+) -> Result<Option<StripeBankName>, errors::ConnectorError> {
+    match (stripe_pm_type, bank_redirect_data) {
+        (
+            StripePaymentMethodType::Eps,
+            api_models::payments::BankRedirectData::Eps { bank_name, .. },
+        ) => Ok(Some(StripeBankName::Eps {
+            bank_name: bank_name.to_owned(),
+        })),
+        (
+            StripePaymentMethodType::Ideal,
+            api_models::payments::BankRedirectData::Ideal { bank_name, .. },
+        ) => Ok(Some(StripeBankName::Ideal {
+            ideal_bank_name: bank_name.to_owned(),
+        })),
+        (StripePaymentMethodType::Sofort | StripePaymentMethodType::Giropay, _) => Ok(None),
+        _ => Err(errors::ConnectorError::MismatchedPaymentData),
+    }
+}
+#[derive(Debug, Eq, PartialEq, Serialize)]
+pub struct StripeBankRedirectData {
+    #[serde(rename = "payment_method_types[]")]
+    pub payment_method_types: StripePaymentMethodType,
+    #[serde(rename = "payment_method_data[type]")]
+    pub payment_method_data_type: StripePaymentMethodType,
+    // Required only for eps and ideal
+    #[serde(flatten)]
+    pub bank_name: Option<StripeBankName>,
+    #[serde(flatten)]
+    pub bank_specific_data: Option<BankSpecificData>,
+}
+
 #[derive(Debug, Eq, PartialEq, Serialize)]
 #[serde(untagged)]
 pub enum StripePaymentMethodData {
     Card(StripeCardData),
     PayLater(StripePayLaterData),
-    Bank,
     Wallet,
-    Paypal,
+    BankRedirect(StripeBankRedirectData),
 }
 
 #[derive(Debug, Eq, PartialEq, Serialize, Clone)]
@@ -148,6 +205,10 @@ pub enum StripePaymentMethodType {
     Klarna,
     Affirm,
     AfterpayClearpay,
+    Eps,
+    Giropay,
+    Ideal,
+    Sofort,
 }
 
 fn validate_shipping_address_against_payment_method(
@@ -182,28 +243,49 @@ fn validate_shipping_address_against_payment_method(
     Ok(())
 }
 
-fn infer_stripe_pay_later_issuer(
-    issuer: &enums::PaymentIssuer,
+fn infer_stripe_pay_later_type(
+    pm_type: &enums::PaymentMethodType,
     experience: &enums::PaymentExperience,
 ) -> Result<StripePaymentMethodType, errors::ConnectorError> {
     if &enums::PaymentExperience::RedirectToUrl == experience {
-        match issuer {
-            enums::PaymentIssuer::Klarna => Ok(StripePaymentMethodType::Klarna),
-            enums::PaymentIssuer::Affirm => Ok(StripePaymentMethodType::Affirm),
-            enums::PaymentIssuer::AfterpayClearpay => Ok(StripePaymentMethodType::AfterpayClearpay),
+        match pm_type {
+            enums::PaymentMethodType::Klarna => Ok(StripePaymentMethodType::Klarna),
+            enums::PaymentMethodType::Affirm => Ok(StripePaymentMethodType::Affirm),
+            enums::PaymentMethodType::AfterpayClearpay => {
+                Ok(StripePaymentMethodType::AfterpayClearpay)
+            }
             _ => Err(errors::ConnectorError::NotSupported {
-                payment_method: format!("{issuer} payments by {experience}"),
+                payment_method: format!("{pm_type} payments by {experience}"),
                 connector: "stripe",
             }),
         }
     } else {
         Err(errors::ConnectorError::NotSupported {
-            payment_method: format!("{issuer} payments by {experience}"),
+            payment_method: format!("{pm_type} payments by {experience}"),
             connector: "stripe",
         })
     }
 }
 
+fn infer_stripe_bank_redirect_issuer(
+    payment_method_type: Option<&enums::PaymentMethodType>,
+) -> Result<StripePaymentMethodType, errors::ConnectorError> {
+    match payment_method_type {
+        Some(storage_models::enums::PaymentMethodType::Giropay) => {
+            Ok(StripePaymentMethodType::Giropay)
+        }
+        Some(storage_models::enums::PaymentMethodType::Ideal) => Ok(StripePaymentMethodType::Ideal),
+        Some(storage_models::enums::PaymentMethodType::Sofort) => {
+            Ok(StripePaymentMethodType::Sofort)
+        }
+        Some(storage_models::enums::PaymentMethodType::Eps) => Ok(StripePaymentMethodType::Eps),
+        None => Err(errors::ConnectorError::MissingRequiredField {
+            field_name: "payment_method_type",
+        }),
+        _ => Err(errors::ConnectorError::MismatchedPaymentData),
+    }
+}
+
 impl TryFrom<(&api_models::payments::PayLaterData, StripePaymentMethodType)>
     for StripeBillingAddress
 {
@@ -243,10 +325,51 @@ impl TryFrom<(&api_models::payments::PayLaterData, StripePaymentMethodType)>
     }
 }
 
+impl TryFrom<&payments::BankRedirectData> for StripeBillingAddress {
+    type Error = errors::ConnectorError;
+
+    fn try_from(bank_redirection_data: &payments::BankRedirectData) -> Result<Self, Self::Error> {
+        match bank_redirection_data {
+            payments::BankRedirectData::Eps {
+                billing_details, ..
+            } => Ok(Self {
+                name: Some(billing_details.billing_name.clone()),
+                ..Self::default()
+            }),
+            payments::BankRedirectData::Giropay { billing_details } => Ok(Self {
+                name: Some(billing_details.billing_name.clone()),
+                ..Self::default()
+            }),
+            payments::BankRedirectData::Ideal {
+                billing_details, ..
+            } => Ok(Self {
+                name: Some(billing_details.billing_name.clone()),
+                ..Self::default()
+            }),
+            _ => Ok(Self::default()),
+        }
+    }
+}
+
+fn get_bank_specific_data(
+    bank_redirect_data: &payments::BankRedirectData,
+) -> Option<BankSpecificData> {
+    match bank_redirect_data {
+        payments::BankRedirectData::Sofort {
+            country,
+            preferred_language,
+        } => Some(BankSpecificData::Sofort {
+            country: country.to_owned(),
+            preferred_language: preferred_language.to_owned(),
+        }),
+        _ => None,
+    }
+}
+
 fn create_stripe_payment_method(
-    issuer: Option<&enums::PaymentIssuer>,
+    pm_type: Option<&enums::PaymentMethodType>,
     experience: Option<&enums::PaymentExperience>,
-    payment_method: &api_models::payments::PaymentMethod,
+    payment_method_data: &api_models::payments::PaymentMethodData,
     auth_type: enums::AuthenticationType,
 ) -> Result<
     (
@@ -256,8 +379,8 @@ fn create_stripe_payment_method(
     ),
     errors::ConnectorError,
 > {
-    match payment_method {
-        payments::PaymentMethod::Card(card_details) => {
+    match payment_method_data {
+        payments::PaymentMethodData::Card(card_details) => {
             let payment_method_auth_type = match auth_type {
                 enums::AuthenticationType::ThreeDs => Auth3ds::Any,
                 enums::AuthenticationType::NoThreeDs => Auth3ds::Automatic,
@@ -276,24 +399,40 @@ fn create_stripe_payment_method(
                 StripeBillingAddress::default(),
             ))
         }
-        payments::PaymentMethod::PayLater(pay_later_data) => {
-            let pm_issuer = issuer.ok_or(errors::ConnectorError::MissingRequiredField {
-                field_name: "payment_issuer",
+        payments::PaymentMethodData::PayLater(pay_later_data) => {
+            let pm_type = pm_type.ok_or(errors::ConnectorError::MissingRequiredField {
+                field_name: "payment_method_type",
             })?;
 
             let pm_experience = experience.ok_or(errors::ConnectorError::MissingRequiredField {
                 field_name: "payment_experience",
             })?;
 
-            let pm_type = infer_stripe_pay_later_issuer(pm_issuer, pm_experience)?;
+            let stripe_pm_type = infer_stripe_pay_later_type(pm_type, pm_experience)?;
 
             let billing_address =
-                StripeBillingAddress::try_from((pay_later_data, pm_type.clone()))?;
+                StripeBillingAddress::try_from((pay_later_data, stripe_pm_type.clone()))?;
 
             Ok((
                 StripePaymentMethodData::PayLater(StripePayLaterData {
+                    payment_method_types: stripe_pm_type.clone(),
+                    payment_method_data_type: stripe_pm_type.clone(),
+                }),
+                stripe_pm_type,
+                billing_address,
+            ))
+        }
+        payments::PaymentMethodData::BankRedirect(bank_redirect_data) => {
+            let billing_address = StripeBillingAddress::try_from(bank_redirect_data)?;
+            let pm_type = infer_stripe_bank_redirect_issuer(pm_type)?;
+            let bank_specific_data = get_bank_specific_data(bank_redirect_data);
+            let bank_name = get_bank_name(&pm_type, bank_redirect_data)?;
+            Ok((
+                StripePaymentMethodData::BankRedirect(StripeBankRedirectData {
                     payment_method_types: pm_type.clone(),
                     payment_method_data_type: pm_type.clone(),
+                    bank_name,
+                    bank_specific_data,
                 }),
                 pm_type,
                 billing_address,
@@ -352,7 +491,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PaymentIntentRequest {
                 None => {
                     let (payment_method_data, payment_method_type, billing_address) =
                         create_stripe_payment_method(
-                            item.request.payment_issuer.as_ref(),
+                            item.request.payment_method_type.as_ref(),
                             item.request.payment_experience.as_ref(),
                             &item.request.payment_method_data,
                             item.auth_type,
@@ -442,6 +581,8 @@ pub enum StripePaymentStatus {
     RequiresConfirmation,
     Canceled,
     RequiresCapture,
+    // This is the case in
+    Pending,
 }
 
 impl From<StripePaymentStatus> for enums::AttemptStatus {
@@ -455,6 +596,7 @@ impl From<StripePaymentStatus> for enums::AttemptStatus {
             StripePaymentStatus::RequiresConfirmation => Self::ConfirmationAwaited,
             StripePaymentStatus::Canceled => Self::Voided,
             StripePaymentStatus::RequiresCapture => Self::Authorized,
+            StripePaymentStatus::Pending => Self::Pending,
         }
     }
 }
@@ -487,7 +629,7 @@ pub struct PaymentSyncResponse {
     pub last_payment_error: Option<ErrorDetails>,
 }
 
-impl Deref for PaymentSyncResponse {
+impl std::ops::Deref for PaymentSyncResponse {
     type Target = PaymentIntentResponse;
 
     fn deref(&self) -> &Self::Target {
@@ -495,6 +637,27 @@ impl Deref for PaymentSyncResponse {
     }
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct LastPaymentError {
+    code: String,
+    message: String,
+}
+
+#[derive(Deserialize)]
+pub struct PaymentIntentSyncResponse {
+    #[serde(flatten)]
+    payment_intent_fields: PaymentIntentResponse,
+    pub last_payment_error: Option<LastPaymentError>,
+}
+
+impl std::ops::Deref for PaymentIntentSyncResponse {
+    type Target = PaymentIntentResponse;
+
+    fn deref(&self) -> &Self::Target {
+        &self.payment_intent_fields
+    }
+}
+
 #[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)]
 pub struct SetupIntentResponse {
     pub id: String,
@@ -531,9 +694,7 @@ impl<F, T>
                     StripePaymentMethodOptions::Card {
                         mandate_options, ..
                     } => mandate_options.map(|mandate_options| mandate_options.reference),
-                    StripePaymentMethodOptions::Klarna {} => None,
-                    StripePaymentMethodOptions::Affirm {} => None,
-                    StripePaymentMethodOptions::AfterpayClearpay {} => None,
+                    _ => None,
                 });
 
         Ok(Self {
@@ -555,12 +716,17 @@ impl<F, T>
 }
 
 impl<F, T>
-    TryFrom<types::ResponseRouterData<F, PaymentSyncResponse, T, types::PaymentsResponseData>>
+    TryFrom<types::ResponseRouterData<F, PaymentIntentSyncResponse, T, types::PaymentsResponseData>>
     for types::RouterData<F, T, types::PaymentsResponseData>
 {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(
-        item: types::ResponseRouterData<F, PaymentSyncResponse, T, types::PaymentsResponseData>,
+        item: types::ResponseRouterData<
+            F,
+            PaymentIntentSyncResponse,
+            T,
+            types::PaymentsResponseData,
+        >,
     ) -> Result<Self, Self::Error> {
         let redirection_data = item.response.next_action.as_ref().map(
             |StripeNextActionResponse::RedirectToUrl(response)| {
@@ -578,7 +744,11 @@ impl<F, T>
                     } => mandate_options.map(|mandate_options| mandate_options.reference),
                     StripePaymentMethodOptions::Klarna {}
                     | StripePaymentMethodOptions::Affirm {}
-                    | StripePaymentMethodOptions::AfterpayClearpay {} => None,
+                    | StripePaymentMethodOptions::AfterpayClearpay {}
+                    | StripePaymentMethodOptions::Eps {}
+                    | StripePaymentMethodOptions::Giropay {}
+                    | StripePaymentMethodOptions::Ideal {}
+                    | StripePaymentMethodOptions::Sofort {} => None,
                 });
 
         let error_res =
@@ -586,8 +756,8 @@ impl<F, T>
                 .last_payment_error
                 .as_ref()
                 .map(|error| types::ErrorResponse {
-                    code: error.code.to_owned().unwrap_or_default(),
-                    message: error.message.to_owned().unwrap_or_default(),
+                    code: error.code.to_owned(),
+                    message: error.message.to_owned(),
                     reason: None,
                     status_code: item.http_code,
                 });
@@ -633,9 +803,7 @@ impl<F, T>
                     StripePaymentMethodOptions::Card {
                         mandate_options, ..
                     } => mandate_options.map(|mandate_option| mandate_option.reference),
-                    StripePaymentMethodOptions::Klarna {} => None,
-                    StripePaymentMethodOptions::Affirm {} => None,
-                    StripePaymentMethodOptions::AfterpayClearpay {} => None,
+                    _ => None,
                 });
 
         Ok(Self {
@@ -879,6 +1047,10 @@ pub enum StripePaymentMethodOptions {
     Klarna {},
     Affirm {},
     AfterpayClearpay {},
+    Eps {},
+    Giropay {},
+    Ideal {},
+    Sofort {},
 }
 // #[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
 // pub struct Card
@@ -972,7 +1144,7 @@ pub struct StripeWebhookObjectId {
 
 impl
     TryFrom<(
-        api::PaymentMethod,
+        api::PaymentMethodData,
         enums::AuthenticationType,
         StripePaymentMethodType,
     )> for StripePaymentMethodData
@@ -980,13 +1152,13 @@ impl
     type Error = errors::ConnectorError;
     fn try_from(
         (pm_data, auth_type, pm_type): (
-            api::PaymentMethod,
+            api::PaymentMethodData,
             enums::AuthenticationType,
             StripePaymentMethodType,
         ),
     ) -> Result<Self, Self::Error> {
         match pm_data {
-            api::PaymentMethod::Card(ref ccard) => Ok(Self::Card({
+            api::PaymentMethodData::Card(ref ccard) => Ok(Self::Card({
                 let payment_method_auth_type = match auth_type {
                     enums::AuthenticationType::ThreeDs => Auth3ds::Any,
                     enums::AuthenticationType::NoThreeDs => Auth3ds::Automatic,
@@ -1001,13 +1173,19 @@ impl
                     payment_method_auth_type,
                 }
             })),
-            api::PaymentMethod::BankTransfer => Ok(Self::Bank),
-            api::PaymentMethod::PayLater(_) => Ok(Self::PayLater(StripePayLaterData {
+            api::PaymentMethodData::PayLater(_) => Ok(Self::PayLater(StripePayLaterData {
                 payment_method_types: pm_type.clone(),
                 payment_method_data_type: pm_type,
             })),
-            api::PaymentMethod::Wallet(_) => Ok(Self::Wallet),
-            api::PaymentMethod::Paypal => Ok(Self::Paypal),
+            api::PaymentMethodData::BankRedirect(_) => {
+                Ok(Self::BankRedirect(StripeBankRedirectData {
+                    payment_method_types: pm_type.clone(),
+                    payment_method_data_type: pm_type,
+                    bank_name: None,
+                    bank_specific_data: None,
+                }))
+            }
+            api::PaymentMethodData::Wallet(_) => Ok(Self::Wallet),
         }
     }
 }
diff --git a/crates/router/src/connector/utils.rs b/crates/router/src/connector/utils.rs
index 4b3ff44906f..c2dddc8f6f5 100644
--- a/crates/router/src/connector/utils.rs
+++ b/crates/router/src/connector/utils.rs
@@ -139,7 +139,7 @@ impl PaymentsRequestData for types::PaymentsAuthorizeRouterData {
     }
     fn get_card(&self) -> Result<api::Card, Error> {
         match self.request.payment_method_data.clone() {
-            api::PaymentMethod::Card(card) => Ok(card),
+            api::PaymentMethodData::Card(card) => Ok(card),
             _ => Err(missing_field_err("card")()),
         }
     }
diff --git a/crates/router/src/connector/worldline/transformers.rs b/crates/router/src/connector/worldline/transformers.rs
index 4722a81ed28..9b2c4a24ed9 100644
--- a/crates/router/src/connector/worldline/transformers.rs
+++ b/crates/router/src/connector/worldline/transformers.rs
@@ -122,7 +122,7 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for PaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
         match item.request.payment_method_data {
-            api::PaymentMethod::Card(ref card) => {
+            api::PaymentMethodData::Card(ref card) => {
                 make_card_request(&item.address, &item.request, card)
             }
             _ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
diff --git a/crates/router/src/connector/worldpay/transformers.rs b/crates/router/src/connector/worldpay/transformers.rs
index de160756842..21ce9e79368 100644
--- a/crates/router/src/connector/worldpay/transformers.rs
+++ b/crates/router/src/connector/worldpay/transformers.rs
@@ -10,10 +10,10 @@ use crate::{
 };
 
 fn fetch_payment_instrument(
-    payment_method: api::PaymentMethod,
+    payment_method: api::PaymentMethodData,
 ) -> CustomResult<PaymentInstrument, errors::ConnectorError> {
     match payment_method {
-        api::PaymentMethod::Card(card) => Ok(PaymentInstrument::Card(CardPayment {
+        api::PaymentMethodData::Card(card) => Ok(PaymentInstrument::Card(CardPayment {
             card_expiry_date: CardExpiryDate {
                 month: card.card_exp_month,
                 year: card.card_exp_year,
@@ -21,7 +21,7 @@ fn fetch_payment_instrument(
             card_number: card.card_number,
             ..CardPayment::default()
         })),
-        api::PaymentMethod::Wallet(wallet) => match wallet.issuer_name {
+        api::PaymentMethodData::Wallet(wallet) => match wallet.issuer_name {
             api_models::enums::WalletIssuer::ApplePay => {
                 Ok(PaymentInstrument::Applepay(WalletPayment {
                     payment_type: PaymentType::Applepay,
diff --git a/crates/router/src/core/customers.rs b/crates/router/src/core/customers.rs
index 699c114d59e..9a93b0db7c6 100644
--- a/crates/router/src/core/customers.rs
+++ b/crates/router/src/core/customers.rs
@@ -140,7 +140,7 @@ pub async fn delete_customer(
     {
         Ok(customer_payment_methods) => {
             for pm in customer_payment_methods.into_iter() {
-                if pm.payment_method == enums::PaymentMethodType::Card {
+                if pm.payment_method == enums::PaymentMethod::Card {
                     cards::delete_card(state, &merchant_account.merchant_id, &pm.payment_method_id)
                         .await?;
                 }
diff --git a/crates/router/src/core/errors.rs b/crates/router/src/core/errors.rs
index c27f2ee65a8..196a0f1d6fb 100644
--- a/crates/router/src/core/errors.rs
+++ b/crates/router/src/core/errors.rs
@@ -275,7 +275,7 @@ pub enum ConnectorError {
     WebhookResourceObjectNotFound,
     #[error("Invalid Date/time format")]
     InvalidDateFormat,
-    #[error("Payment Issuer does not match the Payment Data provided")]
+    #[error("Payment Method data / Payment Method Type / Payment Experience Mismatch ")]
     MismatchedPaymentData,
 }
 
diff --git a/crates/router/src/core/errors/api_error_response.rs b/crates/router/src/core/errors/api_error_response.rs
index 1aa55720e32..a176f42e18a 100644
--- a/crates/router/src/core/errors/api_error_response.rs
+++ b/crates/router/src/core/errors/api_error_response.rs
@@ -81,6 +81,8 @@ pub enum ApiErrorResponse {
         message = "{message}",
     )]
     GenericUnauthorized { message: String },
+    #[error(error_type = ErrorType::InvalidRequestError, code = "IR_19", message = "{message}")]
+    NotSupported { message: String },
 
     #[error(error_type = ErrorType::ConnectorError, code = "CE_00", message = "{code}: {message}", ignore = "status_code")]
     ExternalConnectorError {
@@ -236,6 +238,7 @@ impl actix_web::ResponseError for ApiErrorResponse {
             | Self::ResourceIdNotFound
             | Self::ConfigNotFound
             | Self::AddressNotFound
+            | Self::NotSupported { .. }
             | Self::ApiKeyNotFound => StatusCode::BAD_REQUEST, // 400
             Self::DuplicateMerchantAccount
             | Self::DuplicateMerchantConnectorAccount
@@ -419,6 +422,9 @@ impl common_utils::errors::ErrorSwitch<api_models::errors::types::ApiErrorRespon
             Self::ApiKeyNotFound => {
                 AER::NotFound(ApiError::new("HE", 2, "API Key does not exist in our records", None))
             }
+            Self::NotSupported { message } => {
+                AER::BadRequest(ApiError::new("HE", 3, "{message}", None))
+            }
         }
     }
 }
diff --git a/crates/router/src/core/errors/utils.rs b/crates/router/src/core/errors/utils.rs
index 4371b6bf5a9..c0ee87e9a04 100644
--- a/crates/router/src/core/errors/utils.rs
+++ b/crates/router/src/core/errors/utils.rs
@@ -104,8 +104,11 @@ impl ConnectorErrorExt for error_stack::Report<errors::ConnectorError> {
             errors::ConnectorError::MismatchedPaymentData => {
                 errors::ApiErrorResponse::InvalidDataValue {
                     field_name:
-                        "payment_method_data and payment_issuer, payment_experience does not match",
+                        "payment_method_data, payment_method_type and payment_experience does not match",
                 }
+            },
+            errors::ConnectorError::NotSupported { payment_method, connector } => {
+                errors::ApiErrorResponse::NotSupported { message: format!("{payment_method} is not supported by {connector}") }
             }
             _ => errors::ApiErrorResponse::InternalServerError,
         };
diff --git a/crates/router/src/core/mandate.rs b/crates/router/src/core/mandate.rs
index 0ec74004107..b49ff51899d 100644
--- a/crates/router/src/core/mandate.rs
+++ b/crates/router/src/core/mandate.rs
@@ -204,6 +204,6 @@ pub trait MandateBehaviour {
     fn get_setup_future_usage(&self) -> Option<storage_models::enums::FutureUsage>;
     fn get_mandate_id(&self) -> Option<&api_models::payments::MandateIds>;
     fn set_mandate_id(&mut self, new_mandate_id: api_models::payments::MandateIds);
-    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethod;
+    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethodData;
     fn get_setup_mandate_details(&self) -> Option<&api_models::payments::MandateData>;
 }
diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs
index 96fe75ed10e..a091a3fffe6 100644
--- a/crates/router/src/core/payment_methods/cards.rs
+++ b/crates/router/src/core/payment_methods/cards.rs
@@ -110,7 +110,7 @@ pub async fn update_customer_payment_method(
         .map_err(|error| {
             error.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)
         })?;
-    if pm.payment_method == enums::PaymentMethodType::Card {
+    if pm.payment_method == enums::PaymentMethod::Card {
         delete_card(state, &pm.merchant_id, &pm.payment_method_id).await?;
     };
     let new_pm = api::CreatePaymentMethod {
@@ -724,7 +724,7 @@ pub async fn list_customer_payment_method(
     let mut vec = Vec::new();
     for pm in resp.into_iter() {
         let payment_token = generate_id(consts::ID_LENGTH, "token");
-        let card = if pm.payment_method == enums::PaymentMethodType::Card {
+        let card = if pm.payment_method == enums::PaymentMethod::Card {
             let locker_id = merchant_account
                 .locker_id
                 .to_owned()
@@ -963,7 +963,7 @@ pub async fn retrieve_payment_method(
         .map_err(|error| {
             error.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)
         })?;
-    let card = if pm.payment_method == enums::PaymentMethodType::Card {
+    let card = if pm.payment_method == enums::PaymentMethod::Card {
         let locker_id = merchant_account.locker_id.get_required_value("locker_id")?;
         let get_card_resp =
             get_card_from_legacy_locker(state, &locker_id, &pm.payment_method_id).await?;
@@ -1017,7 +1017,7 @@ pub async fn delete_payment_method(
             error.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)
         })?;
 
-    if pm.payment_method == enums::PaymentMethodType::Card {
+    if pm.payment_method == enums::PaymentMethod::Card {
         let response = delete_card(state, &pm.merchant_id, &payment_method_id).await?;
         if response.status == "success" {
             print!("Card From locker deleted Successfully")
diff --git a/crates/router/src/core/payment_methods/vault.rs b/crates/router/src/core/payment_methods/vault.rs
index 9646df7d593..4d9f805c450 100644
--- a/crates/router/src/core/payment_methods/vault.rs
+++ b/crates/router/src/core/payment_methods/vault.rs
@@ -87,6 +87,8 @@ impl Vaultable for api::Card {
             card_exp_year: value1.exp_year.into(),
             card_holder_name: value1.name_on_card.unwrap_or_default().into(),
             card_cvc: value2.card_security_code.unwrap_or_default().into(),
+            card_issuer: None,
+            card_network: None,
         };
 
         let supp_data = SupplementaryVaultData {
@@ -156,7 +158,7 @@ pub enum VaultPaymentMethod {
     Wallet(String),
 }
 
-impl Vaultable for api::PaymentMethod {
+impl Vaultable for api::PaymentMethodData {
     fn get_value1(&self, customer_id: Option<String>) -> CustomResult<String, errors::VaultError> {
         let value1 = match self {
             Self::Card(card) => VaultPaymentMethod::Card(card.get_value1(customer_id)?),
@@ -229,7 +231,7 @@ impl Vault {
     pub async fn get_payment_method_data_from_locker(
         state: &routes::AppState,
         lookup_key: &str,
-    ) -> RouterResult<(Option<api::PaymentMethod>, SupplementaryVaultData)> {
+    ) -> RouterResult<(Option<api::PaymentMethodData>, SupplementaryVaultData)> {
         let config = state
             .store
             .find_config_by_key(lookup_key)
@@ -244,7 +246,7 @@ impl Vault {
             .attach_printable("Unable to deserialize Mock tokenize db value")?;
 
         let (payment_method, supp_data) =
-            api::PaymentMethod::from_values(tokenize_value.value1, tokenize_value.value2)
+            api::PaymentMethodData::from_values(tokenize_value.value1, tokenize_value.value2)
                 .change_context(errors::ApiErrorResponse::InternalServerError)
                 .attach_printable("Error parsing Payment Method from Values")?;
 
@@ -255,7 +257,7 @@ impl Vault {
     pub async fn store_payment_method_data_in_locker(
         state: &routes::AppState,
         token_id: Option<String>,
-        payment_method: &api::PaymentMethod,
+        payment_method: &api::PaymentMethodData,
         customer_id: Option<String>,
     ) -> RouterResult<String> {
         let value1 = payment_method
@@ -327,10 +329,10 @@ impl Vault {
     pub async fn get_payment_method_data_from_locker(
         state: &routes::AppState,
         lookup_key: &str,
-    ) -> RouterResult<(Option<api::PaymentMethod>, SupplementaryVaultData)> {
+    ) -> RouterResult<(Option<api::PaymentMethodData>, SupplementaryVaultData)> {
         let de_tokenize = get_tokenized_data(state, lookup_key, true).await?;
         let (payment_method, customer_id) =
-            api::PaymentMethod::from_values(de_tokenize.value1, de_tokenize.value2)
+            api::PaymentMethodData::from_values(de_tokenize.value1, de_tokenize.value2)
                 .change_context(errors::ApiErrorResponse::InternalServerError)
                 .attach_printable("Error parsing Payment Method from Values")?;
 
@@ -341,7 +343,7 @@ impl Vault {
     pub async fn store_payment_method_data_in_locker(
         state: &routes::AppState,
         token_id: Option<String>,
-        payment_method: &api::PaymentMethod,
+        payment_method: &api::PaymentMethodData,
         customer_id: Option<String>,
     ) -> RouterResult<String> {
         let value1 = payment_method
diff --git a/crates/router/src/core/payments.rs b/crates/router/src/core/payments.rs
index b7b0e982042..06f5d192f84 100644
--- a/crates/router/src/core/payments.rs
+++ b/crates/router/src/core/payments.rs
@@ -509,7 +509,7 @@ where
     pub token: Option<String>,
     pub confirm: Option<bool>,
     pub force_sync: Option<bool>,
-    pub payment_method_data: Option<api::PaymentMethod>,
+    pub payment_method_data: Option<api::PaymentMethodData>,
     pub refunds: Vec<storage::Refund>,
     pub sessions_token: Vec<api::SessionToken>,
     pub card_cvc: Option<pii::Secret<String>>,
diff --git a/crates/router/src/core/payments/flows/authorize_flow.rs b/crates/router/src/core/payments/flows/authorize_flow.rs
index c60d1b734b6..215bcca82ab 100644
--- a/crates/router/src/core/payments/flows/authorize_flow.rs
+++ b/crates/router/src/core/payments/flows/authorize_flow.rs
@@ -127,7 +127,7 @@ impl mandate::MandateBehaviour for types::PaymentsAuthorizeData {
     fn get_mandate_id(&self) -> Option<&api_models::payments::MandateIds> {
         self.mandate_id.as_ref()
     }
-    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethod {
+    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethodData {
         self.payment_method_data.clone()
     }
     fn get_setup_future_usage(&self) -> Option<storage_models::enums::FutureUsage> {
diff --git a/crates/router/src/core/payments/flows/verfiy_flow.rs b/crates/router/src/core/payments/flows/verfiy_flow.rs
index 51265e67be5..850fa1f4954 100644
--- a/crates/router/src/core/payments/flows/verfiy_flow.rs
+++ b/crates/router/src/core/payments/flows/verfiy_flow.rs
@@ -116,7 +116,7 @@ impl mandate::MandateBehaviour for types::VerifyRequestData {
         self.mandate_id = Some(new_mandate_id);
     }
 
-    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethod {
+    fn get_payment_method_data(&self) -> api_models::payments::PaymentMethodData {
         self.payment_method_data.clone()
     }
 
diff --git a/crates/router/src/core/payments/helpers.rs b/crates/router/src/core/payments/helpers.rs
index 3af7e810fd3..3a3068dc3df 100644
--- a/crates/router/src/core/payments/helpers.rs
+++ b/crates/router/src/core/payments/helpers.rs
@@ -103,7 +103,7 @@ pub async fn get_token_pm_type_mandate_details(
     merchant_account: &storage::MerchantAccount,
 ) -> RouterResult<(
     Option<String>,
-    Option<storage_enums::PaymentMethodType>,
+    Option<storage_enums::PaymentMethod>,
     Option<api::MandateData>,
 )> {
     match mandate_type {
@@ -135,7 +135,7 @@ pub async fn get_token_for_recurring_mandate(
     state: &AppState,
     req: &api::PaymentsRequest,
     merchant_account: &storage::MerchantAccount,
-) -> RouterResult<(Option<String>, Option<storage_enums::PaymentMethodType>)> {
+) -> RouterResult<(Option<String>, Option<storage_enums::PaymentMethod>)> {
     let db = &*state.store;
     let mandate_id = req.mandate_id.clone().get_required_value("mandate_id")?;
 
@@ -180,7 +180,7 @@ pub async fn get_token_for_recurring_mandate(
     let _ = cards::get_lookup_key_from_locker(state, &token, &payment_method, &locker_id).await?;
 
     if let Some(payment_method_from_request) = req.payment_method {
-        let pm: storage_enums::PaymentMethodType = payment_method_from_request.foreign_into();
+        let pm: storage_enums::PaymentMethod = payment_method_from_request.foreign_into();
         if pm != payment_method.payment_method {
             Err(report!(errors::ApiErrorResponse::PreconditionFailed {
                 message: "payment method in request does not match previously provided payment \
@@ -419,7 +419,7 @@ pub fn verify_mandate_details(
 
 #[instrument(skip_all)]
 pub fn payment_attempt_status_fsm(
-    payment_method_data: &Option<api::PaymentMethod>,
+    payment_method_data: &Option<api::PaymentMethodData>,
     confirm: Option<bool>,
 ) -> storage_enums::AttemptStatus {
     match payment_method_data {
@@ -432,7 +432,7 @@ pub fn payment_attempt_status_fsm(
 }
 
 pub fn payment_intent_status_fsm(
-    payment_method_data: &Option<api::PaymentMethod>,
+    payment_method_data: &Option<api::PaymentMethodData>,
     confirm: Option<bool>,
 ) -> storage_enums::IntentStatus {
     match payment_method_data {
@@ -497,14 +497,14 @@ where
 pub(crate) async fn call_payment_method(
     state: &AppState,
     merchant_account: &storage::MerchantAccount,
-    payment_method: Option<&api::PaymentMethod>,
-    payment_method_type: Option<storage_enums::PaymentMethodType>,
+    payment_method: Option<&api::PaymentMethodData>,
+    payment_method_type: Option<storage_enums::PaymentMethod>,
     maybe_customer: &Option<storage::Customer>,
 ) -> RouterResult<api::PaymentMethodResponse> {
     match payment_method {
         Some(pm_data) => match payment_method_type {
             Some(payment_method_type) => match pm_data {
-                api::PaymentMethod::Card(card) => {
+                api::PaymentMethodData::Card(card) => {
                     let card_detail = api::CardDetail {
                         card_number: card.card_number.clone(),
                         card_exp_month: card.card_exp_month.clone(),
@@ -671,7 +671,7 @@ pub async fn make_pm_data<'a, F: Clone, R>(
     operation: BoxedOperation<'a, F, R>,
     state: &'a AppState,
     payment_data: &mut PaymentData<F>,
-) -> RouterResult<(BoxedOperation<'a, F, R>, Option<api::PaymentMethod>)> {
+) -> RouterResult<(BoxedOperation<'a, F, R>, Option<api::PaymentMethodData>)> {
     let request = &payment_data.payment_method_data;
     let token = payment_data.token.clone();
     let card_cvc = payment_data.card_cvc.clone();
@@ -697,13 +697,13 @@ pub async fn make_pm_data<'a, F: Clone, R>(
             )?;
 
             Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(match pm.clone() {
-                Some(api::PaymentMethod::Card(card)) => {
+                Some(api::PaymentMethodData::Card(card)) => {
                     payment_data.payment_attempt.payment_method =
-                        Some(storage_enums::PaymentMethodType::Card);
+                        Some(storage_enums::PaymentMethod::Card);
                     if let Some(cvc) = card_cvc {
                         let mut updated_card = card;
                         updated_card.card_cvc = cvc;
-                        let updated_pm = api::PaymentMethod::Card(updated_card);
+                        let updated_pm = api::PaymentMethodData::Card(updated_card);
                         vault::Vault::store_payment_method_data_in_locker(
                             state,
                             Some(token),
@@ -717,12 +717,12 @@ pub async fn make_pm_data<'a, F: Clone, R>(
                     }
                 }
 
-                Some(api::PaymentMethod::Wallet(wallet_data)) => {
+                Some(api::PaymentMethodData::Wallet(wallet_data)) => {
                     payment_data.payment_attempt.payment_method =
-                        Some(storage_enums::PaymentMethodType::Wallet);
+                        Some(storage_enums::PaymentMethod::Wallet);
                     // TODO: Remove redundant update from wallets.
                     if wallet_data.token.is_some() {
-                        let updated_pm = api::PaymentMethod::Wallet(wallet_data);
+                        let updated_pm = api::PaymentMethodData::Wallet(wallet_data);
                         vault::Vault::store_payment_method_data_in_locker(
                             state,
                             Some(token),
@@ -745,7 +745,7 @@ pub async fn make_pm_data<'a, F: Clone, R>(
                 None => None,
             })
         }
-        (pm_opt @ Some(pm @ api::PaymentMethod::Card(_)), _) => {
+        (pm_opt @ Some(pm @ api::PaymentMethodData::Card(_)), _) => {
             let token = vault::Vault::store_payment_method_data_in_locker(
                 state,
                 None,
@@ -756,8 +756,9 @@ pub async fn make_pm_data<'a, F: Clone, R>(
             payment_data.token = Some(token);
             Ok(pm_opt.to_owned())
         }
-        (pm @ Some(api::PaymentMethod::PayLater(_)), _) => Ok(pm.to_owned()),
-        (pm_opt @ Some(pm @ api::PaymentMethod::Wallet(_)), _) => {
+        (pm @ Some(api::PaymentMethodData::PayLater(_)), _) => Ok(pm.to_owned()),
+        (pm @ Some(api::PaymentMethodData::BankRedirect(_)), _) => Ok(pm.to_owned()),
+        (pm_opt @ Some(pm @ api::PaymentMethodData::Wallet(_)), _) => {
             let token = vault::Vault::store_payment_method_data_in_locker(
                 state,
                 None,
@@ -1162,14 +1163,17 @@ pub(crate) fn validate_payment_status_against_not_allowed_statuses(
 }
 
 pub(crate) fn validate_pm_or_token_given(
-    payment_method: &Option<api_enums::PaymentMethodType>,
-    payment_method_data: &Option<api::PaymentMethod>,
+    payment_method: &Option<api_enums::PaymentMethod>,
+    payment_method_data: &Option<api::PaymentMethodData>,
+    payment_method_type: &Option<api_enums::PaymentMethodType>,
     mandate_type: &Option<api::MandateTxnType>,
     token: &Option<String>,
 ) -> Result<(), errors::ApiErrorResponse> {
     utils::when(
-        !matches!(payment_method, Some(api_enums::PaymentMethodType::Paypal))
-            && !matches!(mandate_type, Some(api::MandateTxnType::RecurringMandateTxn))
+        !matches!(
+            payment_method_type,
+            Some(api_enums::PaymentMethodType::Paypal)
+        ) && !matches!(mandate_type, Some(api::MandateTxnType::RecurringMandateTxn))
             && token.is_none()
             && (payment_method_data.is_none() || payment_method.is_none()),
         || {
diff --git a/crates/router/src/core/payments/operations.rs b/crates/router/src/core/payments/operations.rs
index 062fa91e2bf..7cba4ba96c6 100644
--- a/crates/router/src/core/payments/operations.rs
+++ b/crates/router/src/core/payments/operations.rs
@@ -110,7 +110,7 @@ pub trait Domain<F: Clone, R>: Send + Sync {
         state: &'a AppState,
         payment_data: &mut PaymentData<F>,
         storage_scheme: enums::MerchantStorageScheme,
-    ) -> RouterResult<(BoxedOperation<'a, F, R>, Option<api::PaymentMethod>)>;
+    ) -> RouterResult<(BoxedOperation<'a, F, R>, Option<api::PaymentMethodData>)>;
 
     async fn add_task_to_process_tracker<'a>(
         &'a self,
@@ -206,7 +206,7 @@ where
         _storage_scheme: enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsRetrieveRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
@@ -250,7 +250,7 @@ where
         _storage_scheme: enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsCaptureRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         Ok((Box::new(self), None))
     }
@@ -305,7 +305,7 @@ where
         _storage_scheme: enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsCancelRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         Ok((Box::new(self), None))
     }
diff --git a/crates/router/src/core/payments/operations/payment_confirm.rs b/crates/router/src/core/payments/operations/payment_confirm.rs
index 9ff2f81b783..ef09e652c94 100644
--- a/crates/router/src/core/payments/operations/payment_confirm.rs
+++ b/crates/router/src/core/payments/operations/payment_confirm.rs
@@ -1,6 +1,7 @@
 use std::marker::PhantomData;
 
 use async_trait::async_trait;
+use common_utils::ext_traits::Encode;
 use error_stack::ResultExt;
 use router_derive::PaymentOperation;
 use router_env::{instrument, tracing};
@@ -72,14 +73,13 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
             "confirm",
         )?;
 
-        let (token, payment_method_type, setup_mandate) =
-            helpers::get_token_pm_type_mandate_details(
-                state,
-                request,
-                mandate_type.clone(),
-                merchant_account,
-            )
-            .await?;
+        let (token, payment_method, setup_mandate) = helpers::get_token_pm_type_mandate_details(
+            state,
+            request,
+            mandate_type.clone(),
+            merchant_account,
+        )
+        .await?;
 
         helpers::authenticate_client_secret(
             request.client_secret.as_ref(),
@@ -111,12 +111,22 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
         helpers::validate_pm_or_token_given(
             &request.payment_method,
             &request.payment_method_data,
+            &request.payment_method_type,
             &mandate_type,
             &token,
         )?;
 
-        payment_attempt.payment_method = payment_method_type.or(payment_attempt.payment_method);
+        payment_attempt.payment_method = payment_method.or(payment_attempt.payment_method);
         payment_attempt.browser_info = browser_info;
+        payment_attempt.payment_method_type = request
+            .payment_method_type
+            .map(|pmt| pmt.foreign_into())
+            .or(payment_attempt.payment_method_type);
+
+        payment_attempt.payment_experience = request
+            .payment_experience
+            .map(|experience| experience.foreign_into());
+
         currency = payment_attempt.currency.get_required_value("currency")?;
         amount = payment_attempt.amount.into();
 
@@ -232,7 +242,7 @@ impl<F: Clone + Send> Domain<F, api::PaymentsRequest> for PaymentConfirm {
         _storage_scheme: storage_enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         let (op, payment_method_data) =
             helpers::make_pm_data(Box::new(self), state, payment_data).await?;
@@ -305,6 +315,17 @@ impl<F: Clone> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for Paymen
 
         let connector = payment_data.payment_attempt.connector.clone();
         let payment_token = payment_data.token.clone();
+        let payment_method_type = payment_data.payment_attempt.payment_method_type.clone();
+        let payment_experience = payment_data.payment_attempt.payment_experience.clone();
+        let additional_pm_data = payment_data
+            .payment_method_data
+            .as_ref()
+            .map(api_models::payments::AdditionalPaymentData::from)
+            .as_ref()
+            .map(Encode::<api_models::payments::AdditionalPaymentData>::encode_to_value)
+            .transpose()
+            .change_context(errors::ApiErrorResponse::InternalServerError)
+            .attach_printable("Failed to encode additional pm data")?;
 
         payment_data.payment_attempt = db
             .update_payment_attempt(
@@ -318,6 +339,9 @@ impl<F: Clone> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for Paymen
                     browser_info,
                     connector,
                     payment_token,
+                    payment_method_data: additional_pm_data,
+                    payment_method_type,
+                    payment_experience,
                 },
                 storage_scheme,
             )
diff --git a/crates/router/src/core/payments/operations/payment_create.rs b/crates/router/src/core/payments/operations/payment_create.rs
index 973f3921075..ee20cdc4df5 100644
--- a/crates/router/src/core/payments/operations/payment_create.rs
+++ b/crates/router/src/core/payments/operations/payment_create.rs
@@ -107,7 +107,7 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
                     payment_method_type,
                     request,
                     browser_info,
-                ),
+                )?,
                 storage_scheme,
             )
             .await
@@ -238,7 +238,7 @@ impl<F: Clone + Send> Domain<F, api::PaymentsRequest> for PaymentCreate {
         _storage_scheme: enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
@@ -382,6 +382,7 @@ impl<F: Send + Clone> ValidateRequest<F, api::PaymentsRequest> for PaymentCreate
             helpers::validate_pm_or_token_given(
                 &request.payment_method,
                 &request.payment_method_data,
+                &request.payment_method_type,
                 &mandate_type,
                 &request.payment_token,
             )?;
@@ -412,21 +413,38 @@ impl PaymentCreate {
         payment_id: &str,
         merchant_id: &str,
         money: (api::Amount, enums::Currency),
-        payment_method: Option<enums::PaymentMethodType>,
+        payment_method: Option<enums::PaymentMethod>,
         request: &api::PaymentsRequest,
         browser_info: Option<serde_json::Value>,
-    ) -> storage::PaymentAttemptNew {
+    ) -> RouterResult<storage::PaymentAttemptNew> {
         let created_at @ modified_at @ last_synced = Some(common_utils::date_time::now());
         let status =
             helpers::payment_attempt_status_fsm(&request.payment_method_data, request.confirm);
         let (amount, currency) = (money.0, Some(money.1));
-        storage::PaymentAttemptNew {
+
+        let additional_pm_data = request
+            .payment_method_data
+            .as_ref()
+            .map(api_models::payments::AdditionalPaymentData::from)
+            .as_ref()
+            .map(Encode::<api_models::payments::AdditionalPaymentData>::encode_to_value)
+            .transpose()
+            .change_context(errors::ApiErrorResponse::InternalServerError)
+            .attach_printable("Failed to encode additional pm data")?;
+
+        let connector = request.connector.as_ref().and_then(|connector_vec| {
+            connector_vec
+                .first()
+                .map(|first_connector| first_connector.to_string())
+        });
+
+        Ok(storage::PaymentAttemptNew {
             payment_id: payment_id.to_string(),
             merchant_id: merchant_id.to_string(),
             attempt_id: Uuid::new_v4().simple().to_string(),
             status,
-            amount: amount.into(),
             currency,
+            amount: amount.into(),
             payment_method,
             capture_method: request.capture_method.map(ForeignInto::foreign_into),
             capture_on: request.capture_on,
@@ -437,9 +455,11 @@ impl PaymentCreate {
             authentication_type: request.authentication_type.map(ForeignInto::foreign_into),
             browser_info,
             payment_experience: request.payment_experience.map(ForeignInto::foreign_into),
-            payment_issuer: request.payment_issuer.map(ForeignInto::foreign_into),
+            payment_method_type: request.payment_method_type.map(ForeignInto::foreign_into),
+            payment_method_data: additional_pm_data,
+            connector,
             ..storage::PaymentAttemptNew::default()
-        }
+        })
     }
 
     #[instrument(skip_all)]
diff --git a/crates/router/src/core/payments/operations/payment_method_validate.rs b/crates/router/src/core/payments/operations/payment_method_validate.rs
index f6b18cc9311..dcd3733603d 100644
--- a/crates/router/src/core/payments/operations/payment_method_validate.rs
+++ b/crates/router/src/core/payments/operations/payment_method_validate.rs
@@ -244,7 +244,7 @@ where
         _storage_scheme: storage_enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::VerifyRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
@@ -265,7 +265,7 @@ impl PaymentMethodValidate {
     fn make_payment_attempt(
         payment_id: &str,
         merchant_id: &str,
-        payment_method: Option<api_enums::PaymentMethodType>,
+        payment_method: Option<api_enums::PaymentMethod>,
         _request: &api::VerifyRequest,
     ) -> storage::PaymentAttemptNew {
         let created_at @ modified_at @ last_synced = Some(date_time::now());
diff --git a/crates/router/src/core/payments/operations/payment_session.rs b/crates/router/src/core/payments/operations/payment_session.rs
index e388d6e3d83..de71302582a 100644
--- a/crates/router/src/core/payments/operations/payment_session.rs
+++ b/crates/router/src/core/payments/operations/payment_session.rs
@@ -82,7 +82,7 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsSessionRequest>
 
         let currency = payment_intent.currency.get_required_value("currency")?;
 
-        payment_attempt.payment_method = Some(storage_enums::PaymentMethodType::Wallet);
+        payment_attempt.payment_method = Some(storage_enums::PaymentMethod::Wallet);
 
         let amount = payment_intent.amount.into();
 
@@ -267,7 +267,7 @@ where
         _storage_scheme: storage_enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'b, F, api::PaymentsSessionRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         //No payment method data for this operation
         Ok((Box::new(self), None))
diff --git a/crates/router/src/core/payments/operations/payment_start.rs b/crates/router/src/core/payments/operations/payment_start.rs
index f73529c6291..dc133ef69fd 100644
--- a/crates/router/src/core/payments/operations/payment_start.rs
+++ b/crates/router/src/core/payments/operations/payment_start.rs
@@ -239,7 +239,7 @@ where
         _storage_scheme: storage_enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsStartRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
diff --git a/crates/router/src/core/payments/operations/payment_status.rs b/crates/router/src/core/payments/operations/payment_status.rs
index 635c06df36c..1a37d88423e 100644
--- a/crates/router/src/core/payments/operations/payment_status.rs
+++ b/crates/router/src/core/payments/operations/payment_status.rs
@@ -82,7 +82,7 @@ impl<F: Clone + Send> Domain<F, api::PaymentsRequest> for PaymentStatus {
         _storage_scheme: enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
diff --git a/crates/router/src/core/payments/operations/payment_update.rs b/crates/router/src/core/payments/operations/payment_update.rs
index 5447e721719..7c1d47960af 100644
--- a/crates/router/src/core/payments/operations/payment_update.rs
+++ b/crates/router/src/core/payments/operations/payment_update.rs
@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use async_trait::async_trait;
-use common_utils::ext_traits::AsyncExt;
+use common_utils::ext_traits::{AsyncExt, Encode};
 use error_stack::ResultExt;
 use router_derive::PaymentOperation;
 use router_env::{instrument, tracing};
@@ -148,6 +148,7 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
             helpers::validate_pm_or_token_given(
                 &request.payment_method,
                 &request.payment_method_data,
+                &request.payment_method_type,
                 &mandate_type,
                 &token,
             )?;
@@ -200,6 +201,15 @@ impl<F: Send + Clone> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for Pa
             None => storage_enums::IntentStatus::RequiresPaymentMethod,
         };
 
+        payment_attempt.payment_method_type = request
+            .payment_method_type
+            .map(|pmt| pmt.foreign_into())
+            .or(payment_attempt.payment_method_type);
+
+        payment_attempt.payment_experience = request
+            .payment_experience
+            .map(|experience| experience.foreign_into());
+
         Ok((
             next_operation,
             PaymentData {
@@ -269,7 +279,7 @@ impl<F: Clone + Send> Domain<F, api::PaymentsRequest> for PaymentUpdate {
         _storage_scheme: storage_enums::MerchantStorageScheme,
     ) -> RouterResult<(
         BoxedOperation<'a, F, api::PaymentsRequest>,
-        Option<api::PaymentMethod>,
+        Option<api::PaymentMethodData>,
     )> {
         helpers::make_pm_data(Box::new(self), state, payment_data).await
     }
@@ -323,6 +333,18 @@ impl<F: Clone> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for Paymen
             }
         };
 
+        let additional_pm_data = payment_data
+            .payment_method_data
+            .as_ref()
+            .map(api_models::payments::AdditionalPaymentData::from)
+            .as_ref()
+            .map(Encode::<api_models::payments::AdditionalPaymentData>::encode_to_value)
+            .transpose()
+            .change_context(errors::ApiErrorResponse::InternalServerError)
+            .attach_printable("Failed to encode additional pm data")?;
+
+        let payment_method_type = payment_data.payment_attempt.payment_method_type.clone();
+        let payment_experience = payment_data.payment_attempt.payment_experience.clone();
         payment_data.payment_attempt = db
             .update_payment_attempt(
                 payment_data.payment_attempt,
@@ -333,6 +355,9 @@ impl<F: Clone> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for Paymen
                     authentication_type: None,
                     payment_method,
                     payment_token: payment_data.token.clone(),
+                    payment_method_data: additional_pm_data,
+                    payment_experience,
+                    payment_method_type,
                 },
                 storage_scheme,
             )
diff --git a/crates/router/src/core/payments/transformers.rs b/crates/router/src/core/payments/transformers.rs
index 81dd61d55ff..bb63e5d7e1c 100644
--- a/crates/router/src/core/payments/transformers.rs
+++ b/crates/router/src/core/payments/transformers.rs
@@ -227,7 +227,7 @@ pub fn payments_to_payments_response<R, Op>(
     payment_attempt: storage::PaymentAttempt,
     payment_intent: storage::PaymentIntent,
     refunds: Vec<storage::Refund>,
-    payment_method_data: Option<api::PaymentMethod>,
+    payment_method_data: Option<api::PaymentMethodData>,
     customer: Option<storage::Customer>,
     auth_flow: services::AuthFlow,
     address: PaymentAddress,
@@ -336,7 +336,16 @@ where
                                 .capture_method
                                 .map(ForeignInto::foreign_into),
                         )
-                        .set_metadata(payment_intent.metadata)
+                        .set_payment_experience(
+                            payment_attempt
+                                .payment_experience
+                                .map(ForeignInto::foreign_into),
+                        )
+                        .set_payment_method_type(
+                            payment_attempt
+                                .payment_method_type
+                                .map(ForeignInto::foreign_into),
+                        )
                         .to_owned(),
                 )
             }
@@ -428,8 +437,8 @@ impl<F: Clone> TryFrom<PaymentData<F>> for types::PaymentsAuthorizeData {
             browser_info,
             email: payment_data.email,
             payment_experience: payment_data.payment_attempt.payment_experience,
-            payment_issuer: payment_data.payment_attempt.payment_issuer,
             order_details,
+            payment_method_type: payment_data.payment_attempt.payment_method_type,
         })
     }
 }
diff --git a/crates/router/src/core/refunds/validator.rs b/crates/router/src/core/refunds/validator.rs
index 766dc0206df..833d204599f 100644
--- a/crates/router/src/core/refunds/validator.rs
+++ b/crates/router/src/core/refunds/validator.rs
@@ -148,12 +148,14 @@ pub fn validate_for_valid_refunds(
         .get_required_value("connector")?
         .parse_enum("connector")
         .change_context(errors::ApiErrorResponse::IncorrectConnectorNameGiven)?;
-    let payment_method = payment_attempt
-        .payment_method
-        .get_required_value("payment_method")?;
+    let payment_method_type = payment_attempt
+        .payment_method_type
+        .clone()
+        .get_required_value("payment_method_type")?;
+
     utils::when(
         matches!(
-            (connector, payment_method),
+            (connector, payment_method_type),
             (
                 api_models::enums::Connector::Braintree,
                 storage_models::enums::PaymentMethodType::Paypal
diff --git a/crates/router/src/db/payment_attempt.rs b/crates/router/src/db/payment_attempt.rs
index 83f4bc97266..e4926d05d0f 100644
--- a/crates/router/src/db/payment_attempt.rs
+++ b/crates/router/src/db/payment_attempt.rs
@@ -243,7 +243,8 @@ impl PaymentAttemptInterface for MockDb {
             error_code: payment_attempt.error_code,
             connector_metadata: None,
             payment_experience: payment_attempt.payment_experience,
-            payment_issuer: payment_attempt.payment_issuer,
+            payment_method_type: payment_attempt.payment_method_type,
+            payment_method_data: payment_attempt.payment_method_data,
         };
         payment_attempts.push(payment_attempt.clone());
         Ok(payment_attempt)
@@ -382,7 +383,8 @@ mod storage {
                         error_code: payment_attempt.error_code.clone(),
                         connector_metadata: payment_attempt.connector_metadata.clone(),
                         payment_experience: payment_attempt.payment_experience.clone(),
-                        payment_issuer: payment_attempt.payment_issuer,
+                        payment_method_type: payment_attempt.payment_method_type.clone(),
+                        payment_method_data: payment_attempt.payment_method_data.clone(),
                     };
 
                     let field = format!("pa_{}", created_attempt.attempt_id);
diff --git a/crates/router/src/db_wrapper.rs b/crates/router/src/db_wrapper.rs
new file mode 100644
index 00000000000..17048b2f50a
--- /dev/null
+++ b/crates/router/src/db_wrapper.rs
@@ -0,0 +1,279 @@
+use error_stack::{FutureExt, IntoReport, ResultExt};
+use futures::{
+    future::{join_all, try_join, try_join_all},
+    join,
+};
+use router_derive::Setter;
+use storage_models::enums::MerchantStorageScheme;
+
+use crate::{
+    core::errors::{self, RouterResult, StorageErrorExt},
+    db::StorageInterface,
+    types::storage::{self as storage_types},
+};
+
+pub enum PaymentAttemptDbCall {
+    Query {
+        merchant_id: String,
+        payment_id: String,
+    },
+    Insert(storage_types::PaymentAttemptNew),
+    Update {
+        current_payment_attempt: storage_types::PaymentAttempt,
+        updated_payment_attempt: storage_types::PaymentAttemptUpdate,
+    },
+}
+
+impl PaymentAttemptDbCall {
+    async fn get_db_call(
+        self,
+        db: &dyn StorageInterface,
+        storage_scheme: MerchantStorageScheme,
+    ) -> Result<storage_types::PaymentAttempt, error_stack::Report<errors::ApiErrorResponse>> {
+        match self {
+            PaymentAttemptDbCall::Query {
+                merchant_id,
+                payment_id,
+            } => db
+                .find_payment_attempt_by_payment_id_merchant_id(
+                    &payment_id,
+                    &merchant_id,
+                    storage_scheme,
+                )
+                .await
+                .change_context(errors::ApiErrorResponse::PaymentNotFound),
+            PaymentAttemptDbCall::Insert(payment_attempt_new) => {
+                let payment_id = payment_attempt_new.payment_id.clone();
+                db.insert_payment_attempt(payment_attempt_new, storage_scheme)
+                    .await
+                    .change_context(errors::ApiErrorResponse::DuplicatePayment { payment_id })
+            }
+            PaymentAttemptDbCall::Update {
+                current_payment_attempt,
+                updated_payment_attempt,
+            } => db
+                .update_payment_attempt(
+                    current_payment_attempt,
+                    updated_payment_attempt,
+                    storage_scheme,
+                )
+                .await
+                .change_context(errors::ApiErrorResponse::InternalServerError)
+                .attach_printable("Failed to update payment attempt"),
+        }
+    }
+}
+
+pub enum PaymentIntentDbCall {
+    Insert(storage_types::PaymentIntentNew),
+}
+
+impl PaymentIntentDbCall {
+    async fn get_db_call(
+        self,
+        db: &dyn StorageInterface,
+        storage_scheme: MerchantStorageScheme,
+    ) -> Result<storage_types::PaymentIntent, error_stack::Report<errors::ApiErrorResponse>> {
+        match self {
+            PaymentIntentDbCall::Insert(payment_intent_new) => {
+                let payment_id = payment_intent_new.payment_id.clone();
+                db.insert_payment_intent(payment_intent_new, storage_scheme)
+                    .await
+                    .change_context(errors::ApiErrorResponse::DuplicatePayment { payment_id })
+            }
+        }
+    }
+}
+
+pub enum ConnectorResponseDbCall {
+    Query {
+        merchant_id: String,
+        payment_id: String,
+        attempt_id: String,
+    },
+    Insert(storage_types::ConnectorResponseNew),
+    Update(storage_types::ConnectorResponseUpdate),
+}
+
+pub enum AddressDbCall {
+    Query { address_id: String },
+    Insert(storage_types::AddressNew),
+    Update(storage_types::AddressUpdate),
+}
+
+pub struct DbCall {
+    payment_intent: PaymentIntentDbCall,
+    payment_attempt: PaymentAttemptDbCall,
+    connector_response: ConnectorResponseDbCall,
+    shipping_address: Option<AddressDbCall>,
+    billing_address: Option<AddressDbCall>,
+}
+
+pub enum EntityRequest {
+    PaymentIntent {},
+    PaymentAttempt {
+        payment_id: String,
+        merchant_id: String,
+    },
+    Address {
+        address_id: String,
+    },
+    ConnectorResponse {
+        payment_id: String,
+        attempt_id: String,
+        merchant_id: String,
+    },
+}
+
+#[derive(Debug)]
+pub enum Entity {
+    PaymentIntent(
+        Result<storage_types::PaymentIntent, error_stack::Report<errors::ApiErrorResponse>>,
+    ),
+    PaymentAttempt(
+        Result<storage_types::PaymentAttempt, error_stack::Report<errors::ApiErrorResponse>>,
+    ),
+    Address(Result<storage_types::Address, error_stack::Report<errors::ApiErrorResponse>>),
+    ConnectorResponse(
+        Result<storage_types::ConnectorResponse, error_stack::Report<errors::ApiErrorResponse>>,
+    ),
+    None, //FIXME: for testing purposes only
+}
+
+#[derive(Setter)]
+pub struct EntityResult {
+    pub payment_intent:
+        Result<storage_types::PaymentIntent, error_stack::Report<errors::ApiErrorResponse>>,
+    pub payment_attempt:
+        Result<storage_types::PaymentAttempt, error_stack::Report<errors::ApiErrorResponse>>,
+    pub connector_response:
+        Result<storage_types::ConnectorResponse, error_stack::Report<errors::ApiErrorResponse>>,
+    pub billing_address:
+        Result<Option<storage_types::Address>, error_stack::Report<errors::ApiErrorResponse>>,
+    pub shipping_address:
+        Result<Option<storage_types::Address>, error_stack::Report<errors::ApiErrorResponse>>,
+}
+
+// #[derive(Setter)]
+// pub struct DbCallRequest<T, F: Fn() -> Result<T, errors::ApiErrorResponse>> {
+//     pub payment_attempt: F,
+//     pub connector_response:
+//         Result<storage_types::ConnectorResponse, error_stack::Report<errors::ApiErrorResponse>>,
+//     pub billing_address:
+//         Result<Option<storage_types::Address>, error_stack::Report<errors::ApiErrorResponse>>,
+//     pub shipping_address:
+//         Result<Option<storage_types::Address>, error_stack::Report<errors::ApiErrorResponse>>,
+//     pub mandate:
+//         Result<Option<storage_types::Mandate>, error_stack::Report<errors::ApiErrorResponse>>,
+// }
+
+impl EntityResult {
+    fn new() -> Self {
+        Self {
+            payment_intent: Err(error_stack::report!(
+                errors::ApiErrorResponse::PaymentNotFound
+            )),
+            payment_attempt: Err(error_stack::report!(
+                errors::ApiErrorResponse::PaymentNotFound
+            )),
+            connector_response: Err(error_stack::report!(
+                errors::ApiErrorResponse::PaymentNotFound
+            )),
+            billing_address: Ok(None),
+            shipping_address: Ok(None),
+        }
+    }
+}
+
+impl Default for EntityResult {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+pub trait QueryEntity {
+    async fn query_entity(
+        &self,
+        db: &dyn StorageInterface,
+        storage_scheme: MerchantStorageScheme,
+    ) -> Entity;
+}
+
+#[async_trait::async_trait]
+impl QueryEntity for EntityRequest {
+    async fn query_entity(
+        &self,
+        db: &dyn StorageInterface,
+        storage_scheme: MerchantStorageScheme,
+    ) -> Entity {
+        match self {
+            EntityRequest::PaymentIntent {
+                payment_id,
+                merchant_id,
+            } => Entity::PaymentIntent(
+                db.find_payment_intent_by_payment_id_merchant_id(
+                    payment_id,
+                    merchant_id,
+                    storage_scheme,
+                )
+                .await
+                .change_context(errors::ApiErrorResponse::PaymentNotFound),
+            ),
+            EntityRequest::PaymentAttempt {
+                payment_id,
+                merchant_id,
+            } => Entity::PaymentAttempt(
+                db.find_payment_attempt_by_payment_id_merchant_id(
+                    payment_id,
+                    merchant_id,
+                    storage_scheme,
+                )
+                .await
+                .change_context(errors::ApiErrorResponse::PaymentNotFound),
+            ),
+            EntityRequest::Address { address_id } => Entity::Address(
+                db.find_address(address_id)
+                    .await
+                    .change_context(errors::ApiErrorResponse::AddressNotFound), //FIXME: do not change context
+            ),
+            EntityRequest::ConnectorResponse {
+                payment_id,
+                attempt_id,
+                merchant_id,
+            } => Entity::ConnectorResponse(
+                db.find_connector_response_by_payment_id_merchant_id_attempt_id(
+                    &payment_id,
+                    &merchant_id,
+                    &attempt_id,
+                    storage_scheme,
+                )
+                .await
+                .change_context(errors::ApiErrorResponse::PaymentNotFound),
+            ),
+        }
+    }
+}
+
+pub async fn make_parallel_db_call(
+    db: &dyn StorageInterface,
+    db_calls: DbCall,
+    storage_scheme: MerchantStorageScheme,
+) -> EntityResult {
+    let (payment_intent_res) = join!(
+        db_calls.payment_attempt.get_db_call(db, storage_scheme),
+        db_calls.payment_intent.get_db_call(db, storage_scheme)
+    );
+
+    let mut entities_result = EntityResult::new();
+
+    for entity in combined_res {
+        match entity {
+            Entity::PaymentIntent(pi_res) => entities_result.set_payment_intent(pi_res),
+            Entity::PaymentAttempt(pa_res) => entities_result.set_payment_attempt(pa_res),
+            _ => &mut entities_result,
+        };
+    }
+
+    entities_result
+}
diff --git a/crates/router/src/openapi.rs b/crates/router/src/openapi.rs
index b38997e3465..a399b890652 100644
--- a/crates/router/src/openapi.rs
+++ b/crates/router/src/openapi.rs
@@ -125,8 +125,8 @@ Never share your secret api keys. Keep them guarded and secure.
         crate::types::api::payment_methods::CardDetail,
         api_models::customers::CustomerResponse,
         api_models::enums::RoutingAlgorithm,
+        api_models::enums::PaymentMethod,
         api_models::enums::PaymentMethodType,
-        api_models::enums::PaymentMethodSubType,
         api_models::enums::ConnectorType,
         api_models::enums::Currency,
         api_models::enums::IntentStatus,
@@ -135,12 +135,11 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::enums::AuthenticationType,
         api_models::enums::WalletIssuer,
         api_models::enums::Connector,
-        api_models::enums::PaymentMethodType,
+        api_models::enums::PaymentMethod,
         api_models::enums::SupportedWallets,
         api_models::enums::PaymentMethodIssuerCode,
         api_models::enums::MandateStatus,
         api_models::enums::PaymentExperience,
-        api_models::enums::PaymentIssuer,
         api_models::admin::PaymentConnectorCreate,
         api_models::admin::PaymentMethods,
         api_models::payments::AddressDetails,
@@ -149,14 +148,11 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::payments::NextActionType,
         api_models::payments::Metadata,
         api_models::payments::WalletData,
-        api_models::payments::KlarnaIssuer,
-        api_models::payments::AffirmIssuer,
-        api_models::payments::AfterpayClearpayIssuer,
         api_models::payments::NextAction,
         api_models::payments::PayLaterData,
         api_models::payments::MandateData,
         api_models::payments::PhoneDetails,
-        api_models::payments::PaymentMethod,
+        api_models::payments::PaymentMethodData,
         api_models::payments::MandateType,
         api_models::payments::AcceptanceType,
         api_models::payments::MandateAmountData,
diff --git a/crates/router/src/types.rs b/crates/router/src/types.rs
index 93c68a4ff37..13354aff5b5 100644
--- a/crates/router/src/types.rs
+++ b/crates/router/src/types.rs
@@ -85,7 +85,7 @@ pub struct RouterData<Flow, Request, Response> {
     pub payment_id: String,
     pub attempt_id: String,
     pub status: storage_enums::AttemptStatus,
-    pub payment_method: storage_enums::PaymentMethodType,
+    pub payment_method: storage_enums::PaymentMethod,
     pub connector_auth_type: ConnectorAuthType,
     pub description: Option<String>,
     pub return_url: Option<String>,
@@ -110,7 +110,7 @@ pub struct RouterData<Flow, Request, Response> {
 
 #[derive(Debug, Clone)]
 pub struct PaymentsAuthorizeData {
-    pub payment_method_data: payments::PaymentMethod,
+    pub payment_method_data: payments::PaymentMethodData,
     pub amount: i64,
     pub email: Option<masking::Secret<String, Email>>,
     pub currency: storage_enums::Currency,
@@ -124,8 +124,8 @@ pub struct PaymentsAuthorizeData {
     pub setup_mandate_details: Option<payments::MandateData>,
     pub browser_info: Option<BrowserInformation>,
     pub order_details: Option<api_models::payments::OrderDetails>,
-    pub payment_issuer: Option<storage_enums::PaymentIssuer>,
     pub payment_experience: Option<storage_enums::PaymentExperience>,
+    pub payment_method_type: Option<storage_enums::PaymentMethodType>,
 }
 
 #[derive(Debug, Clone)]
@@ -171,7 +171,7 @@ pub struct PaymentsSessionData {
 #[derive(Debug, Clone)]
 pub struct VerifyRequestData {
     pub currency: storage_enums::Currency,
-    pub payment_method_data: payments::PaymentMethod,
+    pub payment_method_data: payments::PaymentMethodData,
     pub confirm: bool,
     pub statement_descriptor_suffix: Option<String>,
     pub mandate_id: Option<api_models::payments::MandateIds>,
diff --git a/crates/router/src/types/api/mandates.rs b/crates/router/src/types/api/mandates.rs
index 836cec381cf..f5f78a791cf 100644
--- a/crates/router/src/types/api/mandates.rs
+++ b/crates/router/src/types/api/mandates.rs
@@ -47,7 +47,7 @@ impl MandateResponseExt for MandateResponse {
                 error.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)
             })?;
 
-        let card = if payment_method.payment_method == storage_enums::PaymentMethodType::Card {
+        let card = if payment_method.payment_method == storage_enums::PaymentMethod::Card {
             let locker_id = merchant_account
                 .locker_id
                 .to_owned()
diff --git a/crates/router/src/types/api/payment_methods.rs b/crates/router/src/types/api/payment_methods.rs
index 5072ab2f992..9d024f68376 100644
--- a/crates/router/src/types/api/payment_methods.rs
+++ b/crates/router/src/types/api/payment_methods.rs
@@ -20,23 +20,15 @@ use crate::{
 /// Static collection that contains valid Payment Method Type and Payment Method SubType
 /// tuples. Used for validation.
 static PAYMENT_METHOD_TYPE_SET: Lazy<
-    HashMap<api_enums::PaymentMethodType, Vec<api_enums::PaymentMethodSubType>>,
+    HashMap<api_enums::PaymentMethod, Vec<api_enums::PaymentMethodType>>,
 > = Lazy::new(|| {
-    use api_enums::{PaymentMethodSubType as ST, PaymentMethodType as T};
+    use api_enums::{PaymentMethod as T, PaymentMethodType as ST};
 
     hmap! {
         T::Card => vec![
             ST::Credit,
             ST::Debit
         ],
-        T::BankTransfer => vec![],
-        T::Netbanking => vec![],
-        T::Upi => vec![
-            ST::UpiIntent,
-            ST::UpiCollect
-        ],
-        T::OpenBanking => vec![],
-        T::ConsumerFinance => vec![],
         T::Wallet => vec![]
     }
 });
@@ -44,32 +36,20 @@ static PAYMENT_METHOD_TYPE_SET: Lazy<
 /// Static collection that contains valid Payment Method Issuer and Payment Method Issuer
 /// Type tuples. Used for validation.
 static PAYMENT_METHOD_ISSUER_SET: Lazy<
-    HashMap<api_enums::PaymentMethodType, Vec<api_enums::PaymentMethodIssuerCode>>,
+    HashMap<api_enums::PaymentMethod, Vec<api_enums::PaymentMethodIssuerCode>>,
 > = Lazy::new(|| {
-    use api_enums::{PaymentMethodIssuerCode as IC, PaymentMethodType as T};
+    use api_enums::{PaymentMethod as T, PaymentMethodIssuerCode as IC};
 
     hmap! {
         T::Card => vec![
             IC::JpHdfc,
             IC::JpIcici,
         ],
-        T::Upi => vec![
-            IC::JpGooglepay,
-            IC::JpPhonepay
-        ],
-        T::Netbanking => vec![
-            IC::JpSofort,
-            IC::JpGiropay
-        ],
         T::Wallet => vec![
             IC::JpApplepay,
             IC::JpGooglepay,
             IC::JpWechat
         ],
-        T::BankTransfer => vec![
-            IC::JpSepa,
-            IC::JpBacs
-        ]
     }
 });
 
diff --git a/crates/router/src/types/api/payments.rs b/crates/router/src/types/api/payments.rs
index e9320b71030..23e621fcdaf 100644
--- a/crates/router/src/types/api/payments.rs
+++ b/crates/router/src/types/api/payments.rs
@@ -2,8 +2,8 @@ pub use api_models::payments::{
     AcceptanceType, Address, AddressDetails, Amount, AuthenticationForStartResponse, Card,
     CustomerAcceptance, MandateData, MandateTxnType, MandateType, MandateValidationFields,
     NextAction, NextActionType, OnlineMandate, PayLaterData, PaymentIdType, PaymentListConstraints,
-    PaymentListResponse, PaymentMethod, PaymentMethodDataResponse, PaymentOp, PaymentRetrieveBody,
-    PaymentsCancelRequest, PaymentsCaptureRequest, PaymentsRedirectRequest,
+    PaymentListResponse, PaymentMethodData, PaymentMethodDataResponse, PaymentOp,
+    PaymentRetrieveBody, PaymentsCancelRequest, PaymentsCaptureRequest, PaymentsRedirectRequest,
     PaymentsRedirectionResponse, PaymentsRequest, PaymentsResponse, PaymentsResponseForm,
     PaymentsRetrieveRequest, PaymentsSessionRequest, PaymentsSessionResponse, PaymentsStartRequest,
     PgRedirectResponse, PhoneDetails, RedirectionResponse, SessionToken, UrlDetails, VerifyRequest,
@@ -192,6 +192,8 @@ mod payments_test {
             card_exp_year: "99".to_string().into(),
             card_holder_name: "JohnDoe".to_string().into(),
             card_cvc: "123".to_string().into(),
+            card_issuer: Some("HDFC".to_string()),
+            card_network: Some("Visa".to_string()),
         }
     }
 
@@ -199,7 +201,7 @@ mod payments_test {
     fn payments_request() -> PaymentsRequest {
         PaymentsRequest {
             amount: Some(Amount::from(200)),
-            payment_method_data: Some(PaymentMethod::Card(card())),
+            payment_method_data: Some(PaymentMethodData::Card(card())),
             ..PaymentsRequest::default()
         }
     }
diff --git a/crates/router/src/types/transformers.rs b/crates/router/src/types/transformers.rs
index b80ed75eb6b..b9a55b5b994 100644
--- a/crates/router/src/types/transformers.rs
+++ b/crates/router/src/types/transformers.rs
@@ -116,44 +116,32 @@ impl From<F<storage_enums::MandateStatus>> for F<api_enums::MandateStatus> {
     }
 }
 
-impl From<F<api_enums::PaymentMethodType>> for F<storage_enums::PaymentMethodType> {
-    fn from(pm_type: F<api_enums::PaymentMethodType>) -> Self {
+impl From<F<api_enums::PaymentMethod>> for F<storage_enums::PaymentMethod> {
+    fn from(pm_type: F<api_enums::PaymentMethod>) -> Self {
         Self(frunk::labelled_convert_from(pm_type.0))
     }
 }
 
-impl From<F<storage_enums::PaymentMethodType>> for F<api_enums::PaymentMethodType> {
-    fn from(pm_type: F<storage_enums::PaymentMethodType>) -> Self {
+impl From<F<storage_enums::PaymentMethod>> for F<api_enums::PaymentMethod> {
+    fn from(pm_type: F<storage_enums::PaymentMethod>) -> Self {
         Self(frunk::labelled_convert_from(pm_type.0))
     }
 }
 
-impl From<F<api_enums::PaymentMethodSubType>> for F<storage_enums::PaymentMethodSubType> {
-    fn from(pm_subtype: F<api_enums::PaymentMethodSubType>) -> Self {
-        Self(frunk::labelled_convert_from(pm_subtype.0))
-    }
-}
-
-impl From<F<storage_enums::PaymentMethodSubType>> for F<api_enums::PaymentMethodSubType> {
-    fn from(pm_subtype: F<storage_enums::PaymentMethodSubType>) -> Self {
-        Self(frunk::labelled_convert_from(pm_subtype.0))
-    }
-}
-
 impl From<F<storage_enums::PaymentMethodIssuerCode>> for F<api_enums::PaymentMethodIssuerCode> {
     fn from(issuer_code: F<storage_enums::PaymentMethodIssuerCode>) -> Self {
         Self(frunk::labelled_convert_from(issuer_code.0))
     }
 }
 
-impl From<F<api_enums::PaymentIssuer>> for F<storage_enums::PaymentIssuer> {
-    fn from(issuer: F<api_enums::PaymentIssuer>) -> Self {
-        Self(frunk::labelled_convert_from(issuer.0))
+impl From<F<api_enums::PaymentExperience>> for F<storage_enums::PaymentExperience> {
+    fn from(experience: F<api_enums::PaymentExperience>) -> Self {
+        Self(frunk::labelled_convert_from(experience.0))
     }
 }
 
-impl From<F<api_enums::PaymentExperience>> for F<storage_enums::PaymentExperience> {
-    fn from(experience: F<api_enums::PaymentExperience>) -> Self {
+impl From<F<storage_enums::PaymentExperience>> for F<api_enums::PaymentExperience> {
+    fn from(experience: F<storage_enums::PaymentExperience>) -> Self {
         Self(frunk::labelled_convert_from(experience.0))
     }
 }
@@ -380,6 +368,18 @@ impl TryFrom<F<storage::MerchantConnectorAccount>>
     }
 }
 
+impl From<F<api_models::enums::PaymentMethodType>> for F<storage_models::enums::PaymentMethodType> {
+    fn from(payment_method_type: F<api_models::enums::PaymentMethodType>) -> Self {
+        Self(frunk::labelled_convert_from(payment_method_type.0))
+    }
+}
+
+impl From<F<storage_models::enums::PaymentMethodType>> for F<api_models::enums::PaymentMethodType> {
+    fn from(payment_method_type: F<storage_models::enums::PaymentMethodType>) -> Self {
+        Self(frunk::labelled_convert_from(payment_method_type.0))
+    }
+}
+
 impl From<F<api_models::payments::AddressDetails>> for F<storage_models::address::AddressNew> {
     fn from(item: F<api_models::payments::AddressDetails>) -> Self {
         let address = item.0;
diff --git a/crates/router/tests/connectors/aci.rs b/crates/router/tests/connectors/aci.rs
index 9ba5f195009..c99eaeed9dc 100644
--- a/crates/router/tests/connectors/aci.rs
+++ b/crates/router/tests/connectors/aci.rs
@@ -25,7 +25,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
         attempt_id: uuid::Uuid::new_v4().to_string(),
         status: enums::AttemptStatus::default(),
         auth_type: enums::AuthenticationType::NoThreeDs,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         router_return_url: None,
@@ -33,12 +33,14 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
         request: types::PaymentsAuthorizeData {
             amount: 1000,
             currency: enums::Currency::USD,
-            payment_method_data: types::api::PaymentMethod::Card(types::api::Card {
+            payment_method_data: types::api::PaymentMethodData::Card(types::api::Card {
                 card_number: Secret::new("4200000000000000".to_string()),
                 card_exp_month: Secret::new("10".to_string()),
                 card_exp_year: Secret::new("2025".to_string()),
                 card_holder_name: Secret::new("John Doe".to_string()),
                 card_cvc: Secret::new("999".to_string()),
+                card_issuer: None,
+                card_network: None,
             }),
             confirm: true,
             statement_descriptor_suffix: None,
@@ -51,7 +53,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         },
         response: Err(types::ErrorResponse::default()),
         payment_method_id: None,
@@ -77,7 +79,7 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         attempt_id: uuid::Uuid::new_v4().to_string(),
         status: enums::AttemptStatus::default(),
         router_return_url: None,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         auth_type: enums::AuthenticationType::NoThreeDs,
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
@@ -156,13 +158,16 @@ async fn payments_create_failure() {
             types::PaymentsResponseData,
         > = connector.connector.get_connector_integration();
         let mut request = construct_payment_router_data();
-        request.request.payment_method_data = types::api::PaymentMethod::Card(types::api::Card {
-            card_number: Secret::new("420000000000000000".to_string()),
-            card_exp_month: Secret::new("10".to_string()),
-            card_exp_year: Secret::new("2025".to_string()),
-            card_holder_name: Secret::new("John Doe".to_string()),
-            card_cvc: Secret::new("99".to_string()),
-        });
+        request.request.payment_method_data =
+            types::api::PaymentMethodData::Card(types::api::Card {
+                card_number: Secret::new("420000000000000000".to_string()),
+                card_exp_month: Secret::new("10".to_string()),
+                card_exp_year: Secret::new("2025".to_string()),
+                card_holder_name: Secret::new("John Doe".to_string()),
+                card_cvc: Secret::new("99".to_string()),
+                card_issuer: None,
+                card_network: None,
+            });
 
         let response = services::api::execute_connector_processing_step(
             &state,
diff --git a/crates/router/tests/connectors/adyen.rs b/crates/router/tests/connectors/adyen.rs
index 1d2fc73dec1..6c34f2f444e 100644
--- a/crates/router/tests/connectors/adyen.rs
+++ b/crates/router/tests/connectors/adyen.rs
@@ -61,12 +61,14 @@ impl AdyenTest {
         Some(types::PaymentsAuthorizeData {
             amount: 3500,
             currency: enums::Currency::USD,
-            payment_method_data: types::api::PaymentMethod::Card(types::api::Card {
+            payment_method_data: types::api::PaymentMethodData::Card(types::api::Card {
                 card_number: Secret::new(card_number.to_string()),
                 card_exp_month: Secret::new(card_exp_month.to_string()),
                 card_exp_year: Secret::new(card_exp_year.to_string()),
                 card_holder_name: Secret::new("John Doe".to_string()),
                 card_cvc: Secret::new(card_cvc.to_string()),
+                card_issuer: None,
+                card_network: None,
             }),
             confirm: true,
             statement_descriptor_suffix: None,
@@ -79,7 +81,7 @@ impl AdyenTest {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         })
     }
 }
@@ -332,7 +334,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1234567891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -354,7 +356,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("")),
                     ..utils::CCardType::default().0
                 }),
@@ -374,7 +376,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("12345".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -396,7 +398,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("20".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -418,7 +420,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2000".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/airwallex.rs b/crates/router/tests/connectors/airwallex.rs
index e9d40b62fe3..9514402c489 100644
--- a/crates/router/tests/connectors/airwallex.rs
+++ b/crates/router/tests/connectors/airwallex.rs
@@ -53,12 +53,14 @@ fn get_default_payment_info() -> Option<utils::PaymentInfo> {
 }
 fn payment_method_details() -> Option<types::PaymentsAuthorizeData> {
     Some(types::PaymentsAuthorizeData {
-        payment_method_data: types::api::PaymentMethod::Card(api::Card {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
             card_number: Secret::new("4035501000000008".to_string()),
             card_exp_month: Secret::new("02".to_string()),
             card_exp_year: Secret::new("2035".to_string()),
             card_holder_name: Secret::new("John Doe".to_string()),
             card_cvc: Secret::new("123".to_string()),
+            card_issuer: None,
+            card_network: None,
         }),
         capture_method: Some(storage_models::enums::CaptureMethod::Manual),
         ..utils::PaymentAuthorizeType::default().0
@@ -349,7 +351,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1234567891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -372,7 +374,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("")),
                     ..utils::CCardType::default().0
                 }),
@@ -393,7 +395,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("12345".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -416,7 +418,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("20".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -439,7 +441,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2000".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/authorizedotnet.rs b/crates/router/tests/connectors/authorizedotnet.rs
index cadc748be6f..737bda93de1 100644
--- a/crates/router/tests/connectors/authorizedotnet.rs
+++ b/crates/router/tests/connectors/authorizedotnet.rs
@@ -25,7 +25,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
         attempt_id: uuid::Uuid::new_v4().to_string(),
         status: enums::AttemptStatus::default(),
         router_return_url: None,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         connector_auth_type: auth.into(),
         auth_type: enums::AuthenticationType::NoThreeDs,
         description: Some("This is a test".to_string()),
@@ -33,12 +33,14 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
         request: types::PaymentsAuthorizeData {
             amount: 100,
             currency: enums::Currency::USD,
-            payment_method_data: types::api::PaymentMethod::Card(types::api::Card {
+            payment_method_data: types::api::PaymentMethodData::Card(types::api::Card {
                 card_number: Secret::new("5424000000000015".to_string()),
                 card_exp_month: Secret::new("10".to_string()),
                 card_exp_year: Secret::new("2025".to_string()),
                 card_holder_name: Secret::new("John Doe".to_string()),
                 card_cvc: Secret::new("999".to_string()),
+                card_issuer: None,
+                card_network: None,
             }),
             confirm: true,
             statement_descriptor_suffix: None,
@@ -51,7 +53,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         },
         payment_method_id: None,
         response: Err(types::ErrorResponse::default()),
@@ -79,7 +81,7 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         status: enums::AttemptStatus::default(),
         router_return_url: None,
         auth_type: enums::AuthenticationType::NoThreeDs,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
@@ -159,13 +161,16 @@ async fn payments_create_failure() {
         > = connector.connector.get_connector_integration();
         let mut request = construct_payment_router_data();
 
-        request.request.payment_method_data = types::api::PaymentMethod::Card(types::api::Card {
-            card_number: Secret::new("542400000000001".to_string()),
-            card_exp_month: Secret::new("10".to_string()),
-            card_exp_year: Secret::new("2025".to_string()),
-            card_holder_name: Secret::new("John Doe".to_string()),
-            card_cvc: Secret::new("999".to_string()),
-        });
+        request.request.payment_method_data =
+            types::api::PaymentMethodData::Card(types::api::Card {
+                card_number: Secret::new("542400000000001".to_string()),
+                card_exp_month: Secret::new("10".to_string()),
+                card_exp_year: Secret::new("2025".to_string()),
+                card_holder_name: Secret::new("John Doe".to_string()),
+                card_cvc: Secret::new("999".to_string()),
+                card_issuer: None,
+                card_network: None,
+            });
 
         let response = services::api::execute_connector_processing_step(
             &state,
diff --git a/crates/router/tests/connectors/bluesnap.rs b/crates/router/tests/connectors/bluesnap.rs
index f3d82fee687..98135572df0 100644
--- a/crates/router/tests/connectors/bluesnap.rs
+++ b/crates/router/tests/connectors/bluesnap.rs
@@ -364,7 +364,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1234567891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -388,7 +388,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("")),
                     ..utils::CCardType::default().0
                 }),
@@ -413,7 +413,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("12345".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -437,7 +437,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("20".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -461,7 +461,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2000".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/checkout.rs b/crates/router/tests/connectors/checkout.rs
index 113e78b8471..151c1c98ad7 100644
--- a/crates/router/tests/connectors/checkout.rs
+++ b/crates/router/tests/connectors/checkout.rs
@@ -23,19 +23,21 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
         status: enums::AttemptStatus::default(),
         router_return_url: None,
         auth_type: enums::AuthenticationType::NoThreeDs,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
         return_url: None,
         request: types::PaymentsAuthorizeData {
             amount: 100,
             currency: enums::Currency::USD,
-            payment_method_data: types::api::PaymentMethod::Card(api::Card {
+            payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                 card_number: "4242424242424242".to_string().into(),
                 card_exp_month: "10".to_string().into(),
                 card_exp_year: "35".to_string().into(),
                 card_holder_name: "John Doe".to_string().into(),
                 card_cvc: "123".to_string().into(),
+                card_issuer: None,
+                card_network: None,
             }),
             confirm: true,
             statement_descriptor_suffix: None,
@@ -48,7 +50,7 @@ fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         },
         response: Err(types::ErrorResponse::default()),
         payment_method_id: None,
@@ -75,7 +77,7 @@ fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
         attempt_id: uuid::Uuid::new_v4().to_string(),
         status: enums::AttemptStatus::default(),
         router_return_url: None,
-        payment_method: enums::PaymentMethodType::Card,
+        payment_method: enums::PaymentMethod::Card,
         auth_type: enums::AuthenticationType::NoThreeDs,
         connector_auth_type: auth.into(),
         description: Some("This is a test".to_string()),
diff --git a/crates/router/tests/connectors/cybersource.rs b/crates/router/tests/connectors/cybersource.rs
index 3174cb43cf4..7b1ae4d9487 100644
--- a/crates/router/tests/connectors/cybersource.rs
+++ b/crates/router/tests/connectors/cybersource.rs
@@ -152,7 +152,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = Cybersource {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4024007134364111".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -170,7 +170,7 @@ async fn should_fail_payment_for_no_card_number() {
     let response = Cybersource {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -188,7 +188,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = Cybersource {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("13".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -209,7 +209,7 @@ async fn should_fail_payment_for_invalid_exp_year() {
     let response = Cybersource {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2022".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -227,7 +227,7 @@ async fn should_fail_payment_for_invalid_card_cvc() {
     let response = Cybersource {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("2131233213".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/dlocal.rs b/crates/router/tests/connectors/dlocal.rs
index 5e82a791fd8..eae58e3801b 100644
--- a/crates/router/tests/connectors/dlocal.rs
+++ b/crates/router/tests/connectors/dlocal.rs
@@ -287,7 +287,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -308,7 +308,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("")),
                     ..utils::CCardType::default().0
                 }),
@@ -329,7 +329,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("1ad2345".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -350,7 +350,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("201".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -371,7 +371,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("20001".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/fiserv.rs b/crates/router/tests/connectors/fiserv.rs
index 1edbb451903..7bccbb2137a 100644
--- a/crates/router/tests/connectors/fiserv.rs
+++ b/crates/router/tests/connectors/fiserv.rs
@@ -43,12 +43,14 @@ async fn should_only_authorize_payment() {
     let response = Fiserv {}
         .authorize_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4005550000000019".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2035".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("123".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 capture_method: Some(storage_models::enums::CaptureMethod::Manual),
                 ..utils::PaymentAuthorizeType::default().0
@@ -65,12 +67,14 @@ async fn should_authorize_and_capture_payment() {
     let response = Fiserv {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4005550000000019".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2035".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("123".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 ..utils::PaymentAuthorizeType::default().0
             }),
@@ -86,12 +90,14 @@ async fn should_capture_already_authorized_payment() {
     let authorize_response = connector
         .authorize_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4005550000000019".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2035".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("123".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 capture_method: Some(storage_models::enums::CaptureMethod::Manual),
                 ..utils::PaymentAuthorizeType::default().0
@@ -119,12 +125,14 @@ async fn should_fail_payment_for_missing_cvc() {
     let response = Fiserv {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4005550000000019".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2035".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 ..utils::PaymentAuthorizeType::default().0
             }),
diff --git a/crates/router/tests/connectors/globalpay.rs b/crates/router/tests/connectors/globalpay.rs
index 204c300ca2f..22180e825a6 100644
--- a/crates/router/tests/connectors/globalpay.rs
+++ b/crates/router/tests/connectors/globalpay.rs
@@ -124,7 +124,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = Globalpay {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4024007134364842".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/nuvei.rs b/crates/router/tests/connectors/nuvei.rs
index cf4c3c0aef9..ba976513b43 100644
--- a/crates/router/tests/connectors/nuvei.rs
+++ b/crates/router/tests/connectors/nuvei.rs
@@ -40,7 +40,7 @@ static CONNECTOR: NuveiTest = NuveiTest {};
 
 fn get_payment_data() -> Option<types::PaymentsAuthorizeData> {
     Some(types::PaymentsAuthorizeData {
-        payment_method_data: types::api::PaymentMethod::Card(api::Card {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
             card_number: Secret::new(String::from("4000027891380961")),
             ..utils::CCardType::default().0
         }),
@@ -251,7 +251,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1234567891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -273,7 +273,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("")),
                     ..utils::CCardType::default().0
                 }),
@@ -296,7 +296,7 @@ async fn should_fail_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("12345".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -318,7 +318,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("20".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -340,7 +340,7 @@ async fn should_succeed_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new(String::from("4000027891380961")),
                     card_exp_year: Secret::new("2000".to_string()),
                     ..utils::CCardType::default().0
diff --git a/crates/router/tests/connectors/payu.rs b/crates/router/tests/connectors/payu.rs
index 5b6523dcdf5..86ac23f2a74 100644
--- a/crates/router/tests/connectors/payu.rs
+++ b/crates/router/tests/connectors/payu.rs
@@ -85,7 +85,7 @@ async fn should_authorize_card_payment() {
 #[actix_web::test]
 async fn should_authorize_gpay_payment() {
     let authorize_response = Payu {}.authorize_payment(Some(types::PaymentsAuthorizeData{
-            payment_method_data: types::api::PaymentMethod::Wallet(api::WalletData{
+            payment_method_data: types::api::PaymentMethodData::Wallet(api::WalletData{
                     issuer_name: api_models::enums::WalletIssuer::GooglePay,
                     token: Some(r#"{"signature":"MEUCIQD7Ta+d9+buesrH2KKkF+03AqTen+eHHN8KFleHoKaiVAIgGvAXyI0Vg3ws8KlF7agW/gmXJhpJOOPkqiNVbn/4f0Y\u003d","protocolVersion":"ECv1","signedMessage":"{\"encryptedMessage\":\"UcdGP9F/1loU0aXvVj6VqGRPA5EAjHYfJrXD0N+5O13RnaJXKWIjch1zzjpy9ONOZHqEGAqYKIcKcpe5ppN4Fpd0dtbm1H4u+lA+SotCff3euPV6sne22/Pl/MNgbz5QvDWR0UjcXvIKSPNwkds1Ib7QMmH4GfZ3vvn6s534hxAmcv/LlkeM4FFf6py9crJK5fDIxtxRJncfLuuPeAXkyy+u4zE33HmT34Oe5MSW/kYZVz31eWqFy2YCIjbJcC9ElMluoOKSZ305UG7tYGB1LCFGQLtLxphrhPu1lEmGEZE1t2cVDoCzjr3rm1OcfENc7eNC4S+ko6yrXh1ZX06c/F9kunyLn0dAz8K5JLIwLdjw3wPADVSd3L0eM7jkzhH80I6nWkutO0x8BFltxWl+OtzrnAe093OUncH6/DK1pCxtJaHdw1WUWrzULcdaMZmPfA\\u003d\\u003d\",\"ephemeralPublicKey\":\"BH7A1FUBWiePkjh/EYmsjY/63D/6wU+4UmkLh7WW6v7PnoqQkjrFpc4kEP5a1Op4FkIlM9LlEs3wGdFB8xIy9cM\\u003d\",\"tag\":\"e/EOsw2Y2wYpJngNWQqH7J62Fhg/tzmgDl6UFGuAN+A\\u003d\"}"}"#
                     .to_string()) //Generate new GooglePay token this is bound to expire
diff --git a/crates/router/tests/connectors/rapyd.rs b/crates/router/tests/connectors/rapyd.rs
index bf47e064112..30c147581b8 100644
--- a/crates/router/tests/connectors/rapyd.rs
+++ b/crates/router/tests/connectors/rapyd.rs
@@ -38,12 +38,14 @@ async fn should_only_authorize_payment() {
     let response = Rapyd {}
         .authorize_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4111111111111111".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2024".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("123".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 capture_method: Some(storage_models::enums::CaptureMethod::Manual),
                 ..utils::PaymentAuthorizeType::default().0
@@ -60,12 +62,14 @@ async fn should_authorize_and_capture_payment() {
     let response = Rapyd {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4111111111111111".to_string()),
                     card_exp_month: Secret::new("02".to_string()),
                     card_exp_year: Secret::new("2024".to_string()),
                     card_holder_name: Secret::new("John Doe".to_string()),
                     card_cvc: Secret::new("123".to_string()),
+                    card_issuer: None,
+                    card_network: None,
                 }),
                 ..utils::PaymentAuthorizeType::default().0
             }),
@@ -137,7 +141,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = Rapyd {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("0000000000000000".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/shift4.rs b/crates/router/tests/connectors/shift4.rs
index 3d78855b63f..23157d546e2 100644
--- a/crates/router/tests/connectors/shift4.rs
+++ b/crates/router/tests/connectors/shift4.rs
@@ -149,7 +149,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("1234567891011".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -171,7 +171,7 @@ async fn should_fail_payment_for_empty_card_number() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -194,7 +194,7 @@ async fn should_succeed_payment_for_incorrect_cvc() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("asdasd".to_string()), //shift4 accept invalid CVV as it doesn't accept CVV
                     ..utils::CCardType::default().0
                 }),
@@ -213,7 +213,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("20".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -235,7 +235,7 @@ async fn should_fail_payment_for_incorrect_expiry_year() {
     let response = CONNECTOR
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2000".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/stripe.rs b/crates/router/tests/connectors/stripe.rs
index ed256218566..83e2c6bd8dc 100644
--- a/crates/router/tests/connectors/stripe.rs
+++ b/crates/router/tests/connectors/stripe.rs
@@ -33,7 +33,7 @@ impl utils::Connector for Stripe {
 
 fn get_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
     Some(types::PaymentsAuthorizeData {
-        payment_method_data: types::api::PaymentMethod::Card(api::Card {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
             card_number: Secret::new("4242424242424242".to_string()),
             ..utils::CCardType::default().0
         }),
@@ -156,7 +156,7 @@ async fn should_fail_payment_for_incorrect_card_number() {
     let response = Stripe {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("4024007134364842".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -178,7 +178,7 @@ async fn should_fail_payment_for_no_card_number() {
     let response = Stripe {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_number: Secret::new("".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -200,7 +200,7 @@ async fn should_fail_payment_for_invalid_exp_month() {
     let response = Stripe {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_month: Secret::new("13".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -219,7 +219,7 @@ async fn should_fail_payment_for_invalid_exp_year() {
     let response = Stripe {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_exp_year: Secret::new("2022".to_string()),
                     ..utils::CCardType::default().0
                 }),
@@ -238,7 +238,7 @@ async fn should_fail_payment_for_invalid_card_cvc() {
     let response = Stripe {}
         .make_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Card(api::Card {
+                payment_method_data: types::api::PaymentMethodData::Card(api::Card {
                     card_cvc: Secret::new("12".to_string()),
                     ..utils::CCardType::default().0
                 }),
diff --git a/crates/router/tests/connectors/utils.rs b/crates/router/tests/connectors/utils.rs
index d469eebb383..bcbc239dac7 100644
--- a/crates/router/tests/connectors/utils.rs
+++ b/crates/router/tests/connectors/utils.rs
@@ -367,7 +367,7 @@ pub trait ConnectorActions: Connector {
                     a.auth_type
                         .map_or(enums::AuthenticationType::NoThreeDs, |a| a)
                 }),
-            payment_method: enums::PaymentMethodType::Card,
+            payment_method: enums::PaymentMethod::Card,
             connector_auth_type: self.get_auth_token(),
             description: Some("This is a test".to_string()),
             return_url: None,
@@ -461,6 +461,8 @@ impl Default for CCardType {
             card_exp_year: Secret::new("2025".to_string()),
             card_holder_name: Secret::new("John Doe".to_string()),
             card_cvc: Secret::new("999".to_string()),
+            card_issuer: None,
+            card_network: None,
         })
     }
 }
@@ -468,7 +470,7 @@ impl Default for CCardType {
 impl Default for PaymentAuthorizeType {
     fn default() -> Self {
         let data = types::PaymentsAuthorizeData {
-            payment_method_data: types::api::PaymentMethod::Card(CCardType::default().0),
+            payment_method_data: types::api::PaymentMethodData::Card(CCardType::default().0),
             amount: 100,
             currency: enums::Currency::USD,
             confirm: true,
@@ -482,7 +484,7 @@ impl Default for PaymentAuthorizeType {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         };
         Self(data)
     }
diff --git a/crates/router/tests/connectors/worldline.rs b/crates/router/tests/connectors/worldline.rs
index f284baf6dff..6d72b0696bb 100644
--- a/crates/router/tests/connectors/worldline.rs
+++ b/crates/router/tests/connectors/worldline.rs
@@ -63,12 +63,14 @@ impl WorldlineTest {
         Some(types::PaymentsAuthorizeData {
             amount: 3500,
             currency: enums::Currency::USD,
-            payment_method_data: types::api::PaymentMethod::Card(types::api::Card {
+            payment_method_data: types::api::PaymentMethodData::Card(types::api::Card {
                 card_number: Secret::new(card_number.to_string()),
                 card_exp_month: Secret::new(card_exp_month.to_string()),
                 card_exp_year: Secret::new(card_exp_year.to_string()),
                 card_holder_name: Secret::new("John Doe".to_string()),
                 card_cvc: Secret::new(card_cvc.to_string()),
+                card_issuer: None,
+                card_network: None,
             }),
             confirm: true,
             statement_descriptor_suffix: None,
@@ -81,7 +83,7 @@ impl WorldlineTest {
             order_details: None,
             email: None,
             payment_experience: None,
-            payment_issuer: None,
+            payment_method_type: None,
         })
     }
 }
diff --git a/crates/router/tests/connectors/worldpay.rs b/crates/router/tests/connectors/worldpay.rs
index 17e27f1b4fe..8d163bf9195 100644
--- a/crates/router/tests/connectors/worldpay.rs
+++ b/crates/router/tests/connectors/worldpay.rs
@@ -64,7 +64,7 @@ async fn should_authorize_gpay_payment() {
     let response = conn
         .authorize_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Wallet(api::WalletData {
+                payment_method_data: types::api::PaymentMethodData::Wallet(api::WalletData {
                     issuer_name: api_enums::WalletIssuer::GooglePay,
                     token: Some("someToken".to_string()),
                 }),
@@ -89,7 +89,7 @@ async fn should_authorize_applepay_payment() {
     let response = conn
         .authorize_payment(
             Some(types::PaymentsAuthorizeData {
-                payment_method_data: types::api::PaymentMethod::Wallet(api::WalletData {
+                payment_method_data: types::api::PaymentMethodData::Wallet(api::WalletData {
                     issuer_name: api_enums::WalletIssuer::ApplePay,
                     token: Some("someToken".to_string()),
                 }),
diff --git a/crates/router/tests/payments.rs b/crates/router/tests/payments.rs
index 6768003f210..7436180ad68 100644
--- a/crates/router/tests/payments.rs
+++ b/crates/router/tests/payments.rs
@@ -299,14 +299,16 @@ async fn payments_create_core() {
         return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
         setup_future_usage: Some(api_enums::FutureUsage::OnSession),
         authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
-        payment_method_data: Some(api::PaymentMethod::Card(api::Card {
+        payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
             card_number: "4242424242424242".to_string().into(),
             card_exp_month: "10".to_string().into(),
             card_exp_year: "35".to_string().into(),
             card_holder_name: "Arun Raj".to_string().into(),
             card_cvc: "123".to_string().into(),
+            card_issuer: None,
+            card_network: None,
         })),
-        payment_method: Some(api_enums::PaymentMethodType::Card),
+        payment_method: Some(api_enums::PaymentMethod::Card),
         shipping: Some(api::Address {
             address: None,
             phone: None,
@@ -317,18 +319,7 @@ async fn payments_create_core() {
         }),
         statement_descriptor_name: Some("Juspay".to_string()),
         statement_descriptor_suffix: Some("Router".to_string()),
-        payment_token: None,
-        card_cvc: None,
-        phone: None,
-        phone_country_code: None,
-        metadata: None,
-        mandate_data: None,
-        mandate_id: None,
-        off_session: None,
-        client_secret: None,
-        browser_info: None,
-        payment_experience: None,
-        payment_issuer: None,
+        ..Default::default()
     };
 
     let expected_response = api::PaymentsResponse {
@@ -454,14 +445,16 @@ async fn payments_create_core_adyen_no_redirect() {
         return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
         setup_future_usage: Some(api_enums::FutureUsage::OnSession),
         authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
-        payment_method_data: Some(api::PaymentMethod::Card(api::Card {
+        payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
             card_number: "5555 3412 4444 1115".to_string().into(),
             card_exp_month: "03".to_string().into(),
             card_exp_year: "2030".to_string().into(),
             card_holder_name: "JohnDoe".to_string().into(),
             card_cvc: "737".to_string().into(),
+            card_issuer: None,
+            card_network: None,
         })),
-        payment_method: Some(api_enums::PaymentMethodType::Card),
+        payment_method: Some(api_enums::PaymentMethod::Card),
         shipping: Some(api::Address {
             address: None,
             phone: None,
@@ -472,20 +465,7 @@ async fn payments_create_core_adyen_no_redirect() {
         }),
         statement_descriptor_name: Some("Juspay".to_string()),
         statement_descriptor_suffix: Some("Router".to_string()),
-        payment_token: None,
-        card_cvc: None,
-        email: None,
-        name: None,
-        phone: None,
-        phone_country_code: None,
-        metadata: None,
-        mandate_data: None,
-        mandate_id: None,
-        off_session: None,
-        client_secret: None,
-        browser_info: None,
-        payment_experience: None,
-        payment_issuer: None,
+        ..Default::default()
     };
 
     let expected_response = services::ApplicationResponse::Json(api::PaymentsResponse {
diff --git a/crates/router/tests/payments2.rs b/crates/router/tests/payments2.rs
index fea5b65d796..fecf9c9c903 100644
--- a/crates/router/tests/payments2.rs
+++ b/crates/router/tests/payments2.rs
@@ -59,14 +59,16 @@ async fn payments_create_core() {
         return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
         setup_future_usage: None,
         authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
-        payment_method_data: Some(api::PaymentMethod::Card(api::Card {
+        payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
             card_number: "4242424242424242".to_string().into(),
             card_exp_month: "10".to_string().into(),
             card_exp_year: "35".to_string().into(),
             card_holder_name: "Arun Raj".to_string().into(),
             card_cvc: "123".to_string().into(),
+            card_issuer: None,
+            card_network: None,
         })),
-        payment_method: Some(api_enums::PaymentMethodType::Card),
+        payment_method: Some(api_enums::PaymentMethod::Card),
         shipping: Some(api::Address {
             address: None,
             phone: None,
@@ -209,14 +211,16 @@ async fn payments_create_core_adyen_no_redirect() {
         return_url: Some(url::Url::parse("http://example.com/payments").unwrap()),
         setup_future_usage: Some(api_enums::FutureUsage::OffSession),
         authentication_type: Some(api_enums::AuthenticationType::NoThreeDs),
-        payment_method_data: Some(api::PaymentMethod::Card(api::Card {
+        payment_method_data: Some(api::PaymentMethodData::Card(api::Card {
             card_number: "5555 3412 4444 1115".to_string().into(),
             card_exp_month: "03".to_string().into(),
             card_exp_year: "2030".to_string().into(),
             card_holder_name: "JohnDoe".to_string().into(),
             card_cvc: "737".to_string().into(),
+            card_issuer: None,
+            card_network: None,
         })),
-        payment_method: Some(api_enums::PaymentMethodType::Card),
+        payment_method: Some(api_enums::PaymentMethod::Card),
         shipping: Some(api::Address {
             address: None,
             phone: None,
@@ -227,20 +231,7 @@ async fn payments_create_core_adyen_no_redirect() {
         }),
         statement_descriptor_name: Some("Juspay".to_string()),
         statement_descriptor_suffix: Some("Router".to_string()),
-        payment_token: None,
-        card_cvc: None,
-        email: None,
-        name: None,
-        phone: None,
-        phone_country_code: None,
-        metadata: None,
-        mandate_data: None,
-        off_session: None,
-        mandate_id: None,
-        client_secret: None,
-        browser_info: None,
-        payment_experience: None,
-        payment_issuer: None,
+        ..Default::default()
     };
 
     let expected_response = services::ApplicationResponse::Json(api::PaymentsResponse {
diff --git a/crates/storage_models/Cargo.toml b/crates/storage_models/Cargo.toml
index 4852e0888d1..7034e731163 100644
--- a/crates/storage_models/Cargo.toml
+++ b/crates/storage_models/Cargo.toml
@@ -12,7 +12,7 @@ kv_store = []
 [dependencies]
 async-bb8-diesel = { git = "https://github.com/juspay/async-bb8-diesel", rev = "9a71d142726dbc33f41c1fd935ddaa79841c7be5" }
 async-trait = "0.1.63"
-diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time"] }
+diesel = { version = "2.0.3", features = ["postgres", "serde_json", "time", "64-column-tables"] }
 error-stack = "0.2.4"
 frunk = "0.4.1"
 frunk_core = "0.4.1"
diff --git a/crates/storage_models/src/enums.rs b/crates/storage_models/src/enums.rs
index 1c9328bba98..c567d296ddb 100644
--- a/crates/storage_models/src/enums.rs
+++ b/crates/storage_models/src/enums.rs
@@ -8,7 +8,6 @@ pub mod diesel_exports {
         DbMandateStatus as MandateStatus, DbMandateType as MandateType,
         DbMerchantStorageScheme as MerchantStorageScheme,
         DbPaymentMethodIssuerCode as PaymentMethodIssuerCode,
-        DbPaymentMethodSubType as PaymentMethodSubType, DbPaymentMethodType as PaymentMethodType,
         DbProcessTrackerStatus as ProcessTrackerStatus, DbRefundStatus as RefundStatus,
         DbRefundType as RefundType,
     };
@@ -411,31 +410,6 @@ pub enum PaymentMethodIssuerCode {
     JpBacs,
 }
 
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Eq,
-    Hash,
-    PartialEq,
-    serde::Deserialize,
-    serde::Serialize,
-    strum::Display,
-    strum::EnumString,
-    frunk::LabelledGeneric,
-)]
-#[router_derive::diesel_enum(storage_type = "pg_enum")]
-#[serde(rename_all = "snake_case")]
-#[strum(serialize_all = "snake_case")]
-pub enum PaymentMethodSubType {
-    Credit,
-    Debit,
-    UpiIntent,
-    UpiCollect,
-    CreditCardInstallments,
-    PayLaterInstallments,
-}
-
 #[derive(
     Clone,
     Copy,
@@ -450,23 +424,15 @@ pub enum PaymentMethodSubType {
     strum::EnumString,
     frunk::LabelledGeneric,
 )]
-#[router_derive::diesel_enum(storage_type = "pg_enum")]
+#[router_derive::diesel_enum(storage_type = "text")]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
-pub enum PaymentMethodType {
-    Card,
-    PaymentContainer,
+pub enum PaymentMethod {
     #[default]
-    BankTransfer,
-    BankDebit,
+    Card,
     PayLater,
-    Netbanking,
-    Upi,
-    OpenBanking,
-    ConsumerFinance,
     Wallet,
-    Klarna,
-    Paypal,
+    BankRedirect,
 }
 
 #[derive(
@@ -609,7 +575,6 @@ pub enum MandateStatus {
 
 #[derive(
     Clone,
-    Copy,
     Debug,
     Eq,
     Hash,
@@ -623,10 +588,38 @@ pub enum MandateStatus {
 #[router_derive::diesel_enum(storage_type = "text")]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
-pub enum PaymentIssuer {
+pub enum PaymentMethodType {
+    Credit,
+    Debit,
+    Giropay,
+    Ideal,
+    Sofort,
+    Eps,
     Klarna,
     Affirm,
     AfterpayClearpay,
+    GooglePay,
+    ApplePay,
+    Paypal,
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Hash,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    frunk::LabelledGeneric,
+)]
+#[router_derive::diesel_enum(storage_type = "text")]
+#[strum(serialize_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
+pub enum BankNames {
     AmericanExpress,
     BankOfAmerica,
     Barclays,
@@ -638,6 +631,50 @@ pub enum PaymentIssuer {
     PentagonFederalCreditUnion,
     SynchronyBank,
     WellsFargo,
+    AbnAmro,
+    AsnBank,
+    Bunq,
+    Handelsbanken,
+    Ing,
+    Knab,
+    Moneyou,
+    Rabobank,
+    Regiobank,
+    Revolut,
+    SnsBank,
+    TriodosBank,
+    VanLanschot,
+    ArzteUndApothekerBank,
+    AustrianAnadiBankAg,
+    BankAustria,
+    Bank99Ag,
+    BankhausCarlSpangler,
+    BankhausSchelhammerUndSchatteraAg,
+    BawagPskAg,
+    BksBankAg,
+    BrullKallmusBankAg,
+    BtvVierLanderBank,
+    CapitalBankGraweGruppeAg,
+    Dolomitenbank,
+    EasybankAg,
+    ErsteBankUndSparkassen,
+    HypoAlpeadriabankInternationalAg,
+    HypoNoeLbFurNiederosterreichUWien,
+    HypoOberosterreichSalzburgSteiermark,
+    HypoTirolBankAg,
+    HypoVorarlbergBankAg,
+    HypoBankBurgenlandAktiengesellschaft,
+    MarchfelderBank,
+    OberbankAg,
+    OsterreichischeArzteUndApothekerbank,
+    PosojilnicaBankEGen,
+    RaiffeisenBankengruppeOsterreich,
+    SchelhammerCapitalBankAg,
+    SchoellerbankAg,
+    SpardaBankWien,
+    VolksbankGruppe,
+    VolkskreditbankAg,
+    VrBankBraunau,
 }
 
 #[derive(
diff --git a/crates/storage_models/src/payment_attempt.rs b/crates/storage_models/src/payment_attempt.rs
index 175e625c08c..ca23489771c 100644
--- a/crates/storage_models/src/payment_attempt.rs
+++ b/crates/storage_models/src/payment_attempt.rs
@@ -21,7 +21,7 @@ pub struct PaymentAttempt {
     pub surcharge_amount: Option<i64>,
     pub tax_amount: Option<i64>,
     pub payment_method_id: Option<String>,
-    pub payment_method: Option<storage_enums::PaymentMethodType>,
+    pub payment_method: Option<storage_enums::PaymentMethod>,
     pub connector_transaction_id: Option<String>,
     pub capture_method: Option<storage_enums::CaptureMethod>,
     pub capture_on: Option<PrimitiveDateTime>,
@@ -37,8 +37,9 @@ pub struct PaymentAttempt {
     pub error_code: Option<String>,
     pub payment_token: Option<String>,
     pub connector_metadata: Option<serde_json::Value>,
-    pub payment_issuer: Option<storage_enums::PaymentIssuer>,
     pub payment_experience: Option<storage_enums::PaymentExperience>,
+    pub payment_method_type: Option<storage_enums::PaymentMethodType>,
+    pub payment_method_data: Option<serde_json::Value>,
 }
 
 #[derive(
@@ -60,7 +61,7 @@ pub struct PaymentAttemptNew {
     pub surcharge_amount: Option<i64>,
     pub tax_amount: Option<i64>,
     pub payment_method_id: Option<String>,
-    pub payment_method: Option<storage_enums::PaymentMethodType>,
+    pub payment_method: Option<storage_enums::PaymentMethod>,
     pub connector_transaction_id: Option<String>,
     pub capture_method: Option<storage_enums::CaptureMethod>,
     pub capture_on: Option<PrimitiveDateTime>,
@@ -76,8 +77,9 @@ pub struct PaymentAttemptNew {
     pub payment_token: Option<String>,
     pub error_code: Option<String>,
     pub connector_metadata: Option<serde_json::Value>,
-    pub payment_issuer: Option<storage_enums::PaymentIssuer>,
     pub payment_experience: Option<storage_enums::PaymentExperience>,
+    pub payment_method_type: Option<storage_enums::PaymentMethodType>,
+    pub payment_method_data: Option<serde_json::Value>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -87,8 +89,11 @@ pub enum PaymentAttemptUpdate {
         currency: storage_enums::Currency,
         status: storage_enums::AttemptStatus,
         authentication_type: Option<storage_enums::AuthenticationType>,
-        payment_method: Option<storage_enums::PaymentMethodType>,
+        payment_method: Option<storage_enums::PaymentMethod>,
         payment_token: Option<String>,
+        payment_method_data: Option<serde_json::Value>,
+        payment_method_type: Option<storage_enums::PaymentMethodType>,
+        payment_experience: Option<storage_enums::PaymentExperience>,
     },
     UpdateTrackers {
         payment_token: Option<String>,
@@ -102,10 +107,13 @@ pub enum PaymentAttemptUpdate {
         currency: storage_enums::Currency,
         status: storage_enums::AttemptStatus,
         authentication_type: Option<storage_enums::AuthenticationType>,
-        payment_method: Option<storage_enums::PaymentMethodType>,
+        payment_method: Option<storage_enums::PaymentMethod>,
         browser_info: Option<serde_json::Value>,
         connector: Option<String>,
         payment_token: Option<String>,
+        payment_method_data: Option<serde_json::Value>,
+        payment_method_type: Option<storage_enums::PaymentMethodType>,
+        payment_experience: Option<storage_enums::PaymentExperience>,
     },
     VoidUpdate {
         status: storage_enums::AttemptStatus,
@@ -140,7 +148,7 @@ pub struct PaymentAttemptUpdateInternal {
     connector_transaction_id: Option<String>,
     connector: Option<String>,
     authentication_type: Option<storage_enums::AuthenticationType>,
-    payment_method: Option<storage_enums::PaymentMethodType>,
+    payment_method: Option<storage_enums::PaymentMethod>,
     error_message: Option<String>,
     payment_method_id: Option<Option<String>>,
     cancellation_reason: Option<String>,
@@ -150,6 +158,9 @@ pub struct PaymentAttemptUpdateInternal {
     payment_token: Option<String>,
     error_code: Option<String>,
     connector_metadata: Option<serde_json::Value>,
+    payment_method_data: Option<serde_json::Value>,
+    payment_method_type: Option<storage_enums::PaymentMethodType>,
+    payment_experience: Option<storage_enums::PaymentExperience>,
 }
 
 impl PaymentAttemptUpdate {
@@ -188,6 +199,9 @@ impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
                 authentication_type,
                 payment_method,
                 payment_token,
+                payment_method_data,
+                payment_method_type,
+                payment_experience,
             } => Self {
                 amount: Some(amount),
                 currency: Some(currency),
@@ -197,6 +211,9 @@ impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
                 payment_method,
                 payment_token,
                 modified_at: Some(common_utils::date_time::now()),
+                payment_method_data,
+                payment_method_type,
+                payment_experience,
                 ..Default::default()
             },
             PaymentAttemptUpdate::AuthenticationTypeUpdate {
@@ -215,6 +232,9 @@ impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
                 browser_info,
                 connector,
                 payment_token,
+                payment_method_data,
+                payment_method_type,
+                payment_experience,
             } => Self {
                 amount: Some(amount),
                 currency: Some(currency),
@@ -225,6 +245,9 @@ impl From<PaymentAttemptUpdate> for PaymentAttemptUpdateInternal {
                 browser_info,
                 connector,
                 payment_token,
+                payment_method_data,
+                payment_method_type,
+                payment_experience,
                 ..Default::default()
             },
             PaymentAttemptUpdate::VoidUpdate {
diff --git a/crates/storage_models/src/payment_method.rs b/crates/storage_models/src/payment_method.rs
index 386abed0790..49f35e9b942 100644
--- a/crates/storage_models/src/payment_method.rs
+++ b/crates/storage_models/src/payment_method.rs
@@ -25,8 +25,8 @@ pub struct PaymentMethod {
     pub direct_debit_token: Option<String>,
     pub created_at: PrimitiveDateTime,
     pub last_modified: PrimitiveDateTime,
-    pub payment_method: storage_enums::PaymentMethodType,
-    pub payment_method_type: Option<storage_enums::PaymentMethodSubType>,
+    pub payment_method: storage_enums::PaymentMethod,
+    pub payment_method_type: Option<storage_enums::PaymentMethodType>,
     pub payment_method_issuer: Option<String>,
     pub payment_method_issuer_code: Option<storage_enums::PaymentMethodIssuerCode>,
     pub metadata: Option<serde_json::Value>,
@@ -38,8 +38,8 @@ pub struct PaymentMethodNew {
     pub customer_id: String,
     pub merchant_id: String,
     pub payment_method_id: String,
-    pub payment_method: storage_enums::PaymentMethodType,
-    pub payment_method_type: Option<storage_enums::PaymentMethodSubType>,
+    pub payment_method: storage_enums::PaymentMethod,
+    pub payment_method_type: Option<storage_enums::PaymentMethodType>,
     pub payment_method_issuer: Option<String>,
     pub payment_method_issuer_code: Option<storage_enums::PaymentMethodIssuerCode>,
     pub accepted_currency: Option<Vec<storage_enums::Currency>>,
@@ -65,7 +65,7 @@ impl Default for PaymentMethodNew {
             customer_id: String::default(),
             merchant_id: String::default(),
             payment_method_id: String::default(),
-            payment_method: storage_enums::PaymentMethodType::default(),
+            payment_method: storage_enums::PaymentMethod::default(),
             payment_method_type: Option::default(),
             payment_method_issuer: Option::default(),
             payment_method_issuer_code: Option::default(),
diff --git a/crates/storage_models/src/schema.rs b/crates/storage_models/src/schema.rs
index 0cfed2bd421..0edf7288796 100644
--- a/crates/storage_models/src/schema.rs
+++ b/crates/storage_models/src/schema.rs
@@ -218,7 +218,7 @@ diesel::table! {
         surcharge_amount -> Nullable<Int8>,
         tax_amount -> Nullable<Int8>,
         payment_method_id -> Nullable<Varchar>,
-        payment_method -> Nullable<PaymentMethodType>,
+        payment_method -> Nullable<Varchar>,
         connector_transaction_id -> Nullable<Varchar>,
         capture_method -> Nullable<CaptureMethod>,
         capture_on -> Nullable<Timestamp>,
@@ -234,8 +234,9 @@ diesel::table! {
         error_code -> Nullable<Varchar>,
         payment_token -> Nullable<Varchar>,
         connector_metadata -> Nullable<Jsonb>,
-        payment_issuer -> Nullable<Varchar>,
         payment_experience -> Nullable<Varchar>,
+        payment_method_type -> Nullable<Varchar>,
+        payment_method_data -> Nullable<Jsonb>,
     }
 }
 
@@ -290,8 +291,8 @@ diesel::table! {
         direct_debit_token -> Nullable<Varchar>,
         created_at -> Timestamp,
         last_modified -> Timestamp,
-        payment_method -> PaymentMethodType,
-        payment_method_type -> Nullable<PaymentMethodSubType>,
+        payment_method -> Varchar,
+        payment_method_type -> Nullable<Varchar>,
         payment_method_issuer -> Nullable<Varchar>,
         payment_method_issuer_code -> Nullable<PaymentMethodIssuerCode>,
         metadata -> Nullable<Json>,
diff --git a/migrations/2023-02-09-093400_add_bank_redirect/down.sql b/migrations/2023-02-09-093400_add_bank_redirect/down.sql
new file mode 100644
index 00000000000..d0d4ef15e79
--- /dev/null
+++ b/migrations/2023-02-09-093400_add_bank_redirect/down.sql
@@ -0,0 +1,6 @@
+-- This file should undo anything in `up.sql`
+DELETE FROM pg_enum
+WHERE enumlabel = 'bank_redirect'
+AND enumtypid = (
+  SELECT oid FROM pg_type WHERE typname = 'PaymentMethodType'
+)
diff --git a/migrations/2023-02-09-093400_add_bank_redirect/up.sql b/migrations/2023-02-09-093400_add_bank_redirect/up.sql
new file mode 100644
index 00000000000..0382f1f69a5
--- /dev/null
+++ b/migrations/2023-02-09-093400_add_bank_redirect/up.sql
@@ -0,0 +1,2 @@
+-- Your SQL goes here
+ALTER TYPE "PaymentMethodType" ADD VALUE 'bank_redirect' after 'paypal';
diff --git a/migrations/2023-02-10-083146_make_payment_method_type_as_text/down.sql b/migrations/2023-02-10-083146_make_payment_method_type_as_text/down.sql
new file mode 100644
index 00000000000..2badf4f06b7
--- /dev/null
+++ b/migrations/2023-02-10-083146_make_payment_method_type_as_text/down.sql
@@ -0,0 +1,14 @@
+-- This file should undo anything in `up.sql`
+CREATE TYPE "PaymentMethodSubType" AS ENUM (
+    'credit',
+    'debit',
+    'upi_intent',
+    'upi_collect',
+    'credit_card_installments',
+    'pay_later_installments'
+);
+
+ALTER TABLE payment_attempt DROP COLUMN payment_method_type;
+
+ALTER TABLE payment_methods
+ALTER COLUMN payment_method_type TYPE "PaymentMethodSubType" USING payment_method_type::"PaymentMethodSubType";
diff --git a/migrations/2023-02-10-083146_make_payment_method_type_as_text/up.sql b/migrations/2023-02-10-083146_make_payment_method_type_as_text/up.sql
new file mode 100644
index 00000000000..8b896ca2e03
--- /dev/null
+++ b/migrations/2023-02-10-083146_make_payment_method_type_as_text/up.sql
@@ -0,0 +1,8 @@
+-- Your SQL goes here
+ALTER TABLE payment_methods
+ALTER COLUMN payment_method_type TYPE VARCHAR(64);
+
+ALTER TABLE payment_attempt
+ADD COLUMN payment_method_type VARCHAR(64);
+
+DROP TYPE IF EXISTS "PaymentMethodSubType";
diff --git a/migrations/2023-02-22-100331_rename_pm_type_enum/down.sql b/migrations/2023-02-22-100331_rename_pm_type_enum/down.sql
new file mode 100644
index 00000000000..f5986ac5de1
--- /dev/null
+++ b/migrations/2023-02-22-100331_rename_pm_type_enum/down.sql
@@ -0,0 +1,20 @@
+-- This file should undo anything in `up.sql`
+ALTER TABLE payment_attempt
+ADD COLUMN payment_issuer VARCHAR;
+
+CREATE TYPE "PaymentMethodType" AS ENUM (
+    'card',
+    'bank_transfer',
+    'netbanking',
+    'upi',
+    'open_banking',
+    'consumer_finance',
+    'wallet',
+    'pay_later'
+);
+
+ALTER TABLE payment_attempt
+ALTER COLUMN payment_method TYPE "PaymentMethodType" USING payment_method::"PaymentMethodType";
+
+ALTER TABLE payment_methods
+ALTER COLUMN payment_method TYPE "PaymentMethodType" USING payment_method::"PaymentMethodType";
diff --git a/migrations/2023-02-22-100331_rename_pm_type_enum/up.sql b/migrations/2023-02-22-100331_rename_pm_type_enum/up.sql
new file mode 100644
index 00000000000..be42b0b84f3
--- /dev/null
+++ b/migrations/2023-02-22-100331_rename_pm_type_enum/up.sql
@@ -0,0 +1,16 @@
+-- Your SQL goes here
+ALTER TABLE payment_attempt
+ALTER COLUMN payment_method TYPE VARCHAR;
+
+ALTER TABLE payment_methods
+ALTER COLUMN payment_method TYPE VARCHAR;
+
+ALTER TABLE payment_methods
+ALTER COLUMN payment_method_type TYPE VARCHAR;
+
+ALTER TABLE payment_attempt DROP COLUMN payment_issuer;
+
+ALTER TABLE payment_attempt
+ADD COLUMN payment_method_data JSONB;
+
+DROP TYPE "PaymentMethodType";
diff --git a/openapi/generated.json b/openapi/generated.json
index 0d3fc6023a3..1b826c470ad 100644
--- a/openapi/generated.json
+++ b/openapi/generated.json
@@ -22,9 +22,7 @@
   "paths": {
     "/accounts": {
       "post": {
-        "tags": [
-          "Merchant Account"
-        ],
+        "tags": ["Merchant Account"],
         "summary": "",
         "description": "\nCreate a new account for a merchant and the merchant could be a seller or retailer or client who likes to receive and send payments.",
         "operationId": "Create a Merchant Account",
@@ -58,9 +56,7 @@
     },
     "/accounts/{account_id}": {
       "get": {
-        "tags": [
-          "Merchant Account"
-        ],
+        "tags": ["Merchant Account"],
         "summary": "",
         "description": "\nRetrieve a merchant account details.",
         "operationId": "Retrieve a Merchant Account",
@@ -93,9 +89,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Merchant Account"
-        ],
+        "tags": ["Merchant Account"],
         "summary": "",
         "description": "\nTo update an existing merchant account. Helpful in updating merchant details such as email, contact details, or other configuration details like webhook, routing algorithm etc",
         "operationId": "Update a Merchant Account",
@@ -138,9 +132,7 @@
         "deprecated": false
       },
       "delete": {
-        "tags": [
-          "Merchant Account"
-        ],
+        "tags": ["Merchant Account"],
         "summary": "",
         "description": "\nTo delete a merchant account",
         "operationId": "Delete a Merchant Account",
@@ -175,9 +167,7 @@
     },
     "/accounts/{account_id}/connectors": {
       "get": {
-        "tags": [
-          "Merchant Connector Account"
-        ],
+        "tags": ["Merchant Connector Account"],
         "summary": "",
         "description": "\nList Payment Connector Details for the merchant",
         "operationId": "List all Merchant Connectors",
@@ -216,9 +206,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Merchant Connector Account"
-        ],
+        "tags": ["Merchant Connector Account"],
         "summary": "",
         "description": "\nCreate a new Payment Connector for the merchant account. The connector could be a payment processor / facilitator / acquirer or specialized services like Fraud / Accounting etc.\"",
         "operationId": "Create a Merchant Connector",
@@ -252,9 +240,7 @@
     },
     "/accounts/{account_id}/connectors/{connector_id}": {
       "get": {
-        "tags": [
-          "Merchant Connector Account"
-        ],
+        "tags": ["Merchant Connector Account"],
         "summary": "",
         "description": "\nRetrieve Payment Connector Details",
         "operationId": "Retrieve a Merchant Connector",
@@ -300,9 +286,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Merchant Connector Account"
-        ],
+        "tags": ["Merchant Connector Account"],
         "summary": "",
         "description": "\nTo update an existing Payment Connector. Helpful in enabling / disabling different payment methods and other settings for the connector etc.",
         "operationId": "Update a Merchant Connector",
@@ -358,9 +342,7 @@
         "deprecated": false
       },
       "delete": {
-        "tags": [
-          "Merchant Connector Account"
-        ],
+        "tags": ["Merchant Connector Account"],
         "summary": "",
         "description": "\nDelete or Detach a Payment Connector from Merchant Account",
         "operationId": "Delete a Merchant Connector",
@@ -408,9 +390,7 @@
     },
     "/api_keys/{merchant_id)": {
       "post": {
-        "tags": [
-          "API Key"
-        ],
+        "tags": ["API Key"],
         "summary": "API Key - Create",
         "description": "API Key - Create\n\nCreate a new API Key for accessing our APIs from your servers. The plaintext API Key will be\ndisplayed only once on creation, so ensure you store it securely.",
         "operationId": "Create an API Key",
@@ -444,9 +424,7 @@
     },
     "/api_keys/{merchant_id)/{key_id}": {
       "delete": {
-        "tags": [
-          "API Key"
-        ],
+        "tags": ["API Key"],
         "summary": "API Key - Revoke",
         "description": "API Key - Revoke\n\nRevoke the specified API Key. Once revoked, the API Key can no longer be used for\nauthenticating with our APIs.",
         "operationId": "Revoke an API Key",
@@ -481,9 +459,7 @@
     },
     "/api_keys/{merchant_id}/list": {
       "get": {
-        "tags": [
-          "API Key"
-        ],
+        "tags": ["API Key"],
         "summary": "API Key - List",
         "description": "API Key - List\n\nList all API Keys associated with your merchant account.",
         "operationId": "List all API Keys associated with a merchant account",
@@ -529,9 +505,7 @@
     },
     "/api_keys/{merchant_id}/{key_id}": {
       "get": {
-        "tags": [
-          "API Key"
-        ],
+        "tags": ["API Key"],
         "summary": "API Key - Retrieve",
         "description": "API Key - Retrieve\n\nRetrieve information about the specified API Key.",
         "operationId": "Retrieve an API Key",
@@ -564,9 +538,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "API Key"
-        ],
+        "tags": ["API Key"],
         "summary": "API Key - Update",
         "description": "API Key - Update\n\nUpdate information for the specified API Key.",
         "operationId": "Update an API Key",
@@ -611,9 +583,7 @@
     },
     "/customers": {
       "post": {
-        "tags": [
-          "Customers"
-        ],
+        "tags": ["Customers"],
         "summary": "",
         "description": "\nCreate a customer object and store the customer details to be reused for future payments. Incase the customer already exists in the system, this API will respond with the customer details.",
         "operationId": "Create a Customer",
@@ -647,9 +617,7 @@
     },
     "/customers/{customer_id}": {
       "get": {
-        "tags": [
-          "Customers"
-        ],
+        "tags": ["Customers"],
         "summary": "",
         "description": "\nRetrieve a customer's details.",
         "operationId": "Retrieve a Customer",
@@ -682,9 +650,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Customers"
-        ],
+        "tags": ["Customers"],
         "summary": "",
         "description": "\nUpdates the customer's details in a customer object.",
         "operationId": "Update a Customer",
@@ -727,9 +693,7 @@
         "deprecated": false
       },
       "delete": {
-        "tags": [
-          "Customers"
-        ],
+        "tags": ["Customers"],
         "summary": "",
         "description": "\nDelete a customer record.",
         "operationId": "Delete a Customer",
@@ -764,9 +728,7 @@
     },
     "/mandates/revoke/{mandate_id}": {
       "post": {
-        "tags": [
-          "Mandates"
-        ],
+        "tags": ["Mandates"],
         "summary": "",
         "description": "\nRevoke a mandate",
         "operationId": "Revoke a Mandate",
@@ -801,9 +763,7 @@
     },
     "/mandates/{mandate_id}": {
       "get": {
-        "tags": [
-          "Mandates"
-        ],
+        "tags": ["Mandates"],
         "summary": "",
         "description": "\nRetrieve a mandate",
         "operationId": "Retrieve a Mandate",
@@ -838,9 +798,7 @@
     },
     "/payment_methods": {
       "post": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nTo create a payment method against a customer object. In case of cards, this API could be used only by PCI compliant merchants",
         "operationId": "Create a Payment Method",
@@ -874,9 +832,7 @@
     },
     "/payment_methods/{account_id}": {
       "get": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nTo filter and list the applicable payment methods for a particular Merchant ID",
         "operationId": "List all Payment Methods for a Merchant",
@@ -976,9 +932,7 @@
     },
     "/payment_methods/{customer_id}": {
       "get": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nTo filter and list the applicable payment methods for a particular Customer ID",
         "operationId": "List all Payment Methods for a Customer",
@@ -1078,9 +1032,7 @@
     },
     "/payment_methods/{method_id}": {
       "get": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nTo retrieve a payment method",
         "operationId": "Retrieve a Payment method",
@@ -1113,9 +1065,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nTo update an existing payment method attached to a customer object. This API is useful for use cases such as updating the card number for expired cards to prevent discontinuity in recurring payments",
         "operationId": "Update a Payment method",
@@ -1158,9 +1108,7 @@
         "deprecated": false
       },
       "delete": {
-        "tags": [
-          "Payment Methods"
-        ],
+        "tags": ["Payment Methods"],
         "summary": "",
         "description": "\nDelete payment method",
         "operationId": "Delete a Payment method",
@@ -1195,9 +1143,7 @@
     },
     "/payments": {
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo process a payment you will have to create a payment, attach a payment method and confirm. Depending on the user journey you wish to achieve, you may opt to all the steps in a single request or in a sequence of API request using following APIs: (i) Payments - Update, (ii) Payments - Confirm, and (iii) Payments - Capture",
         "operationId": "Create a Payment",
@@ -1231,9 +1177,7 @@
     },
     "/payments/list": {
       "get": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo list the payments",
         "operationId": "List all Payments",
@@ -1339,9 +1283,7 @@
     },
     "/payments/session_tokens": {
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo create the session object or to get session token for wallets",
         "operationId": "Create Session tokens for a Payment",
@@ -1375,9 +1317,7 @@
     },
     "/payments/{payment_id}": {
       "get": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo retrieve the properties of a Payment. This may be used to get the status of a previously initiated payment or next action for an ongoing payment",
         "operationId": "Retrieve a Payment",
@@ -1420,9 +1360,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo update the properties of a PaymentIntent object. This may include attaching a payment method, or attaching customer object or metadata fields after the Payment is created",
         "operationId": "Update a Payment",
@@ -1467,9 +1405,7 @@
     },
     "/payments/{payment_id}/cancel": {
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nA Payment could can be cancelled when it is in one of these statuses: requires_payment_method, requires_capture, requires_confirmation, requires_customer_action",
         "operationId": "Cancel a Payment",
@@ -1507,9 +1443,7 @@
     },
     "/payments/{payment_id}/capture": {
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nTo capture the funds for an uncaptured payment",
         "operationId": "Capture a Payment",
@@ -1554,9 +1488,7 @@
     },
     "/payments/{payment_id}/confirm": {
       "post": {
-        "tags": [
-          "Payments"
-        ],
+        "tags": ["Payments"],
         "summary": "",
         "description": "\nThis API is to confirm the payment request and forward payment to the payment processor. This API provides more granular control upon when the API is forwarded to the payment processor. Alternatively you can confirm the payment within the Payments Create API",
         "operationId": "Confirm a Payment",
@@ -1601,9 +1533,7 @@
     },
     "/refunds": {
       "post": {
-        "tags": [
-          "Refunds"
-        ],
+        "tags": ["Refunds"],
         "summary": "",
         "description": "\nTo create a refund against an already processed payment",
         "operationId": "Create a Refund",
@@ -1637,9 +1567,7 @@
     },
     "/refunds/list": {
       "get": {
-        "tags": [
-          "Refunds"
-        ],
+        "tags": ["Refunds"],
         "summary": "",
         "description": "\nTo list the refunds associated with a payment_id or with the merchant, if payment_id is not provided",
         "operationId": "List all Refunds",
@@ -1734,9 +1662,7 @@
     },
     "/refunds/{refund_id}": {
       "get": {
-        "tags": [
-          "Refunds"
-        ],
+        "tags": ["Refunds"],
         "summary": "",
         "description": "\nTo retrieve the properties of a Refund. This may be used to get the status of a previously initiated payment or next action for an ongoing payment",
         "operationId": "Retrieve a Refund",
@@ -1769,9 +1695,7 @@
         "deprecated": false
       },
       "post": {
-        "tags": [
-          "Refunds"
-        ],
+        "tags": ["Refunds"],
         "summary": "",
         "description": "\nTo update the properties of a Refund object. This may include attaching a reason for the refund or metadata fields",
         "operationId": "Update a Refund",
@@ -1819,10 +1743,7 @@
     "schemas": {
       "AcceptanceType": {
         "type": "string",
-        "enum": [
-          "online",
-          "offline"
-        ]
+        "enum": ["online", "offline"]
       },
       "Address": {
         "type": "object",
@@ -1896,23 +1817,15 @@
       },
       "AffirmIssuer": {
         "type": "string",
-        "enum": [
-          "affirm"
-        ]
+        "enum": ["affirm"]
       },
       "AfterpayClearpayIssuer": {
         "type": "string",
-        "enum": [
-          "afterpay_clearpay"
-        ]
+        "enum": ["afterpay_clearpay"]
       },
       "AmountInfo": {
         "type": "object",
-        "required": [
-          "label",
-          "type",
-          "amount"
-        ],
+        "required": ["label", "type", "amount"],
         "properties": {
           "label": {
             "type": "string",
@@ -1932,9 +1845,7 @@
         "oneOf": [
           {
             "type": "string",
-            "enum": [
-              "never"
-            ]
+            "enum": ["never"]
           },
           {
             "type": "string",
@@ -2046,10 +1957,7 @@
       },
       "ApplepaySessionTokenResponse": {
         "type": "object",
-        "required": [
-          "session_token_data",
-          "payment_request_data"
-        ],
+        "required": ["session_token_data", "payment_request_data"],
         "properties": {
           "session_token_data": {
             "$ref": "#/components/schemas/ApplePaySessionResponse"
@@ -2061,19 +1969,11 @@
       },
       "AuthenticationType": {
         "type": "string",
-        "enum": [
-          "three_ds",
-          "no_three_ds"
-        ]
+        "enum": ["three_ds", "no_three_ds"]
       },
       "CaptureMethod": {
         "type": "string",
-        "enum": [
-          "automatic",
-          "manual",
-          "manual_multiple",
-          "scheduled"
-        ]
+        "enum": ["automatic", "manual", "manual_multiple", "scheduled"]
       },
       "Card": {
         "type": "object",
@@ -2209,10 +2109,7 @@
       "CreateApiKeyRequest": {
         "type": "object",
         "description": "The request body for creating an API Key.",
-        "required": [
-          "name",
-          "expiration"
-        ],
+        "required": ["name", "expiration"],
         "properties": {
           "name": {
             "type": "string",
@@ -2285,9 +2182,7 @@
       },
       "CreateMerchantAccount": {
         "type": "object",
-        "required": [
-          "merchant_id"
-        ],
+        "required": ["merchant_id"],
         "properties": {
           "merchant_id": {
             "type": "string",
@@ -2365,9 +2260,7 @@
       },
       "CreatePaymentMethod": {
         "type": "object",
-        "required": [
-          "payment_method"
-        ],
+        "required": ["payment_method"],
         "properties": {
           "payment_method": {
             "$ref": "#/components/schemas/PaymentMethodType"
@@ -2506,9 +2399,7 @@
       },
       "CustomerAcceptance": {
         "type": "object",
-        "required": [
-          "acceptance_type"
-        ],
+        "required": ["acceptance_type"],
         "properties": {
           "acceptance_type": {
             "$ref": "#/components/schemas/AcceptanceType"
@@ -2605,9 +2496,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentExperience"
             },
-            "example": [
-              "redirect_to_url"
-            ]
+            "example": ["redirect_to_url"]
           },
           "card": {
             "$ref": "#/components/schemas/CardDetailFromLocker"
@@ -2673,10 +2562,7 @@
       },
       "CustomerResponse": {
         "type": "object",
-        "required": [
-          "customer_id",
-          "created_at"
-        ],
+        "required": ["customer_id", "created_at"],
         "properties": {
           "customer_id": {
             "type": "string",
@@ -2730,11 +2616,7 @@
       },
       "DeleteMcaResponse": {
         "type": "object",
-        "required": [
-          "merchant_id",
-          "merchant_connector_id",
-          "deleted"
-        ],
+        "required": ["merchant_id", "merchant_connector_id", "deleted"],
         "properties": {
           "merchant_id": {
             "type": "string",
@@ -2756,10 +2638,7 @@
       },
       "DeleteMerchantAccountResponse": {
         "type": "object",
-        "required": [
-          "merchant_id",
-          "deleted"
-        ],
+        "required": ["merchant_id", "deleted"],
         "properties": {
           "merchant_id": {
             "type": "string",
@@ -2776,10 +2655,7 @@
       },
       "DeletePaymentMethodResponse": {
         "type": "object",
-        "required": [
-          "payment_method_id",
-          "deleted"
-        ],
+        "required": ["payment_method_id", "deleted"],
         "properties": {
           "payment_method_id": {
             "type": "string",
@@ -2795,17 +2671,11 @@
       },
       "FutureUsage": {
         "type": "string",
-        "enum": [
-          "off_session",
-          "on_session"
-        ]
+        "enum": ["off_session", "on_session"]
       },
       "GpayAllowedMethodsParameters": {
         "type": "object",
-        "required": [
-          "allowed_auth_methods",
-          "allowed_card_networks"
-        ],
+        "required": ["allowed_auth_methods", "allowed_card_networks"],
         "properties": {
           "allowed_auth_methods": {
             "type": "array",
@@ -2825,11 +2695,7 @@
       },
       "GpayAllowedPaymentMethods": {
         "type": "object",
-        "required": [
-          "type",
-          "parameters",
-          "tokenization_specification"
-        ],
+        "required": ["type", "parameters", "tokenization_specification"],
         "properties": {
           "type": {
             "type": "string",
@@ -2845,9 +2711,7 @@
       },
       "GpayMerchantInfo": {
         "type": "object",
-        "required": [
-          "merchant_name"
-        ],
+        "required": ["merchant_name"],
         "properties": {
           "merchant_name": {
             "type": "string",
@@ -2879,10 +2743,7 @@
       },
       "GpayTokenParameters": {
         "type": "object",
-        "required": [
-          "gateway",
-          "gateway_merchant_id"
-        ],
+        "required": ["gateway", "gateway_merchant_id"],
         "properties": {
           "gateway": {
             "type": "string",
@@ -2896,10 +2757,7 @@
       },
       "GpayTokenizationSpecification": {
         "type": "object",
-        "required": [
-          "type",
-          "parameters"
-        ],
+        "required": ["type", "parameters"],
         "properties": {
           "type": {
             "type": "string",
@@ -2953,16 +2811,11 @@
       },
       "KlarnaIssuer": {
         "type": "string",
-        "enum": [
-          "klarna"
-        ]
+        "enum": ["klarna"]
       },
       "KlarnaSessionTokenResponse": {
         "type": "object",
-        "required": [
-          "session_token",
-          "session_id"
-        ],
+        "required": ["session_token", "session_id"],
         "properties": {
           "session_token": {
             "type": "string",
@@ -2976,10 +2829,7 @@
       },
       "ListCustomerPaymentMethodsResponse": {
         "type": "object",
-        "required": [
-          "enabled_payment_methods",
-          "customer_payment_methods"
-        ],
+        "required": ["enabled_payment_methods", "customer_payment_methods"],
         "properties": {
           "enabled_payment_methods": {
             "type": "array",
@@ -2990,10 +2840,7 @@
               {
                 "payment_experience": null,
                 "payment_method": "wallet",
-                "payment_method_issuers": [
-                  "labore magna ipsum",
-                  "aute"
-                ]
+                "payment_method_issuers": ["labore magna ipsum", "aute"]
               }
             ]
           },
@@ -3021,9 +2868,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentMethodSubType"
             },
-            "example": [
-              "credit_card"
-            ]
+            "example": ["credit_card"]
           },
           "payment_method_issuers": {
             "type": "array",
@@ -3031,18 +2876,14 @@
               "type": "string",
               "description": "The name of the bank/ provider issuing the payment method to the end user"
             },
-            "example": [
-              "Citibank"
-            ]
+            "example": ["Citibank"]
           },
           "payment_method_issuer_code": {
             "type": "array",
             "items": {
               "$ref": "#/components/schemas/PaymentMethodIssuerCode"
             },
-            "example": [
-              "jp_applepay"
-            ]
+            "example": ["jp_applepay"]
           },
           "payment_schemes": {
             "type": "array",
@@ -3050,11 +2891,7 @@
               "type": "string",
               "description": "List of payment schemes accepted or has the processing capabilities of the processor"
             },
-            "example": [
-              "MASTER",
-              "VISA",
-              "DINERS"
-            ]
+            "example": ["MASTER", "VISA", "DINERS"]
           },
           "accepted_countries": {
             "$ref": "#/components/schemas/admin.AcceptedCountries"
@@ -3089,9 +2926,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentExperience"
             },
-            "example": [
-              "redirect_to_url"
-            ]
+            "example": ["redirect_to_url"]
           },
           "eligible_connectors": {
             "type": "array",
@@ -3099,18 +2934,13 @@
               "type": "string",
               "description": "Eligible connectors for this payment method"
             },
-            "example": [
-              "stripe",
-              "adyen"
-            ]
+            "example": ["stripe", "adyen"]
           }
         }
       },
       "ListPaymentMethodResponse": {
         "type": "object",
-        "required": [
-          "payment_methods"
-        ],
+        "required": ["payment_methods"],
         "properties": {
           "redirect_url": {
             "type": "string",
@@ -3126,10 +2956,7 @@
               {
                 "payment_experience": null,
                 "payment_method": "wallet",
-                "payment_method_issuers": [
-                  "labore magna ipsum",
-                  "aute"
-                ]
+                "payment_method_issuers": ["labore magna ipsum", "aute"]
               }
             ]
           }
@@ -3137,10 +2964,7 @@
       },
       "MandateAmountData": {
         "type": "object",
-        "required": [
-          "amount",
-          "currency"
-        ],
+        "required": ["amount", "currency"],
         "properties": {
           "amount": {
             "type": "integer",
@@ -3192,10 +3016,7 @@
       },
       "MandateData": {
         "type": "object",
-        "required": [
-          "customer_acceptance",
-          "mandate_type"
-        ],
+        "required": ["customer_acceptance", "mandate_type"],
         "properties": {
           "customer_acceptance": {
             "$ref": "#/components/schemas/CustomerAcceptance"
@@ -3239,10 +3060,7 @@
       },
       "MandateRevokedResponse": {
         "type": "object",
-        "required": [
-          "mandate_id",
-          "status"
-        ],
+        "required": ["mandate_id", "status"],
         "properties": {
           "mandate_id": {
             "type": "string",
@@ -3256,20 +3074,13 @@
       "MandateStatus": {
         "type": "string",
         "description": "The status of the mandate, which indicates whether it can be used to initiate a payment",
-        "enum": [
-          "active",
-          "inactive",
-          "pending",
-          "revoked"
-        ]
+        "enum": ["active", "inactive", "pending", "revoked"]
       },
       "MandateType": {
         "oneOf": [
           {
             "type": "object",
-            "required": [
-              "single_use"
-            ],
+            "required": ["single_use"],
             "properties": {
               "single_use": {
                 "$ref": "#/components/schemas/MandateAmountData"
@@ -3278,9 +3089,7 @@
           },
           {
             "type": "object",
-            "required": [
-              "multi_use"
-            ],
+            "required": ["multi_use"],
             "properties": {
               "multi_use": {
                 "$ref": "#/components/schemas/MandateAmountData"
@@ -3375,10 +3184,7 @@
       },
       "MerchantConnectorId": {
         "type": "object",
-        "required": [
-          "merchant_id",
-          "merchant_connector_id"
-        ],
+        "required": ["merchant_id", "merchant_connector_id"],
         "properties": {
           "merchant_id": {
             "type": "string"
@@ -3461,9 +3267,7 @@
       },
       "NextAction": {
         "type": "object",
-        "required": [
-          "type"
-        ],
+        "required": ["type"],
         "properties": {
           "type": {
             "$ref": "#/components/schemas/NextActionType"
@@ -3486,10 +3290,7 @@
       },
       "OnlineMandate": {
         "type": "object",
-        "required": [
-          "ip_address",
-          "user_agent"
-        ],
+        "required": ["ip_address", "user_agent"],
         "properties": {
           "ip_address": {
             "type": "string",
@@ -3504,10 +3305,7 @@
       },
       "OrderDetails": {
         "type": "object",
-        "required": [
-          "product_name",
-          "quantity"
-        ],
+        "required": ["product_name", "quantity"],
         "properties": {
           "product_name": {
             "type": "string",
@@ -3527,17 +3325,12 @@
         "oneOf": [
           {
             "type": "object",
-            "required": [
-              "klarna_redirect"
-            ],
+            "required": ["klarna_redirect"],
             "properties": {
               "klarna_redirect": {
                 "type": "object",
                 "description": "For KlarnaRedirect as PayLater Option",
-                "required": [
-                  "billing_email",
-                  "billing_country"
-                ],
+                "required": ["billing_email", "billing_country"],
                 "properties": {
                   "billing_email": {
                     "type": "string",
@@ -3552,16 +3345,12 @@
           },
           {
             "type": "object",
-            "required": [
-              "klarna_sdk"
-            ],
+            "required": ["klarna_sdk"],
             "properties": {
               "klarna_sdk": {
                 "type": "object",
                 "description": "For Klarna Sdk as PayLater Option",
-                "required": [
-                  "token"
-                ],
+                "required": ["token"],
                 "properties": {
                   "token": {
                     "type": "string",
@@ -3573,9 +3362,7 @@
           },
           {
             "type": "object",
-            "required": [
-              "affirm_redirect"
-            ],
+            "required": ["affirm_redirect"],
             "properties": {
               "affirm_redirect": {
                 "type": "object",
@@ -3585,17 +3372,12 @@
           },
           {
             "type": "object",
-            "required": [
-              "afterpay_clearpay_redirect"
-            ],
+            "required": ["afterpay_clearpay_redirect"],
             "properties": {
               "afterpay_clearpay_redirect": {
                 "type": "object",
                 "description": "For AfterpayClearpay redirect as PayLater Option",
-                "required": [
-                  "billing_email",
-                  "billing_name"
-                ],
+                "required": ["billing_email", "billing_name"],
                 "properties": {
                   "billing_email": {
                     "type": "string",
@@ -3614,10 +3396,7 @@
       "PaymentConnectorCreate": {
         "type": "object",
         "description": "Create a new Payment Connector for the merchant account. The connector could be a payment processor / facilitator / acquirer or specialized services like Fraud / Accounting etc.\"",
-        "required": [
-          "connector_type",
-          "connector_name"
-        ],
+        "required": ["connector_type", "connector_name"],
         "properties": {
           "connector_type": {
             "$ref": "#/components/schemas/ConnectorType"
@@ -3655,46 +3434,22 @@
             "example": [
               {
                 "accepted_countries": {
-                  "disable_only": [
-                    "FR",
-                    "DE",
-                    "IN"
-                  ],
+                  "disable_only": ["FR", "DE", "IN"],
                   "enable_all": false,
-                  "enable_only": [
-                    "UK",
-                    "AU"
-                  ]
+                  "enable_only": ["UK", "AU"]
                 },
                 "accepted_currencies": {
-                  "disable_only": [
-                    "INR",
-                    "CAD",
-                    "AED",
-                    "JPY"
-                  ],
+                  "disable_only": ["INR", "CAD", "AED", "JPY"],
                   "enable_all": false,
-                  "enable_only": [
-                    "EUR",
-                    "USD"
-                  ]
+                  "enable_only": ["EUR", "USD"]
                 },
                 "installment_payment_enabled": true,
                 "maximum_amount": 68607706,
                 "minimum_amount": 1,
                 "payment_method": "wallet",
-                "payment_method_issuers": [
-                  "labore magna ipsum",
-                  "aute"
-                ],
-                "payment_method_types": [
-                  "upi_collect",
-                  "upi_intent"
-                ],
-                "payment_schemes": [
-                  "Discover",
-                  "Discover"
-                ],
+                "payment_method_issuers": ["labore magna ipsum", "aute"],
+                "payment_method_types": ["upi_collect", "upi_intent"],
+                "payment_schemes": ["Discover", "Discover"],
                 "recurring_enabled": true
               }
             ]
@@ -3719,9 +3474,7 @@
         "oneOf": [
           {
             "type": "object",
-            "required": [
-              "PaymentIntentId"
-            ],
+            "required": ["PaymentIntentId"],
             "properties": {
               "PaymentIntentId": {
                 "type": "string",
@@ -3731,9 +3484,7 @@
           },
           {
             "type": "object",
-            "required": [
-              "ConnectorTransactionId"
-            ],
+            "required": ["ConnectorTransactionId"],
             "properties": {
               "ConnectorTransactionId": {
                 "type": "string",
@@ -3743,9 +3494,7 @@
           },
           {
             "type": "object",
-            "required": [
-              "PaymentAttemptId"
-            ],
+            "required": ["PaymentAttemptId"],
             "properties": {
               "PaymentAttemptId": {
                 "type": "string",
@@ -3823,10 +3572,7 @@
       },
       "PaymentListResponse": {
         "type": "object",
-        "required": [
-          "size",
-          "data"
-        ],
+        "required": ["size", "data"],
         "properties": {
           "size": {
             "type": "integer",
@@ -3844,9 +3590,7 @@
         "oneOf": [
           {
             "type": "object",
-            "required": [
-              "card"
-            ],
+            "required": ["card"],
             "properties": {
               "card": {
                 "$ref": "#/components/schemas/Card"
@@ -3855,15 +3599,11 @@
           },
           {
             "type": "string",
-            "enum": [
-              "bank_transfer"
-            ]
+            "enum": ["bank_transfer"]
           },
           {
             "type": "object",
-            "required": [
-              "wallet"
-            ],
+            "required": ["wallet"],
             "properties": {
               "wallet": {
                 "$ref": "#/components/schemas/WalletData"
@@ -3872,9 +3612,7 @@
           },
           {
             "type": "object",
-            "required": [
-              "pay_later"
-            ],
+            "required": ["pay_later"],
             "properties": {
               "pay_later": {
                 "$ref": "#/components/schemas/PayLaterData"
@@ -3883,9 +3621,7 @@
           },
           {
             "type": "string",
-            "enum": [
-              "paypal"
-            ]
+            "enum": ["paypal"]
           }
         ]
       },
@@ -3961,9 +3697,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentExperience"
             },
-            "example": [
-              "redirect_to_url"
-            ]
+            "example": ["redirect_to_url"]
           },
           "metadata": {
             "type": "object"
@@ -4021,9 +3755,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentMethodSubType"
             },
-            "example": [
-              "credit"
-            ]
+            "example": ["credit"]
           },
           "payment_method_issuers": {
             "type": "array",
@@ -4031,9 +3763,7 @@
               "type": "string",
               "description": "List of payment method issuers to be enabled for this payment method"
             },
-            "example": [
-              "HDFC"
-            ]
+            "example": ["HDFC"]
           },
           "payment_schemes": {
             "type": "array",
@@ -4041,11 +3771,7 @@
               "type": "string",
               "description": "List of payment schemes accepted or has the processing capabilities of the processor"
             },
-            "example": [
-              "MASTER",
-              "VISA",
-              "DINERS"
-            ]
+            "example": ["MASTER", "VISA", "DINERS"]
           },
           "accepted_currencies": {
             "$ref": "#/components/schemas/AcceptedCurrencies"
@@ -4082,9 +3808,7 @@
             "items": {
               "$ref": "#/components/schemas/PaymentExperience"
             },
-            "example": [
-              "redirect_to_url"
-            ]
+            "example": ["redirect_to_url"]
           }
         }
       },
@@ -4303,12 +4027,7 @@
       },
       "PaymentsResponse": {
         "type": "object",
-        "required": [
-          "status",
-          "amount",
-          "currency",
-          "payment_method"
-        ],
+        "required": ["status", "amount", "currency", "payment_method"],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -4487,10 +4206,7 @@
       },
       "PaymentsRetrieveRequest": {
         "type": "object",
-        "required": [
-          "resource_id",
-          "force_sync"
-        ],
+        "required": ["resource_id", "force_sync"],
         "properties": {
           "resource_id": {
             "$ref": "#/components/schemas/PaymentIdType"
@@ -4515,11 +4231,7 @@
       },
       "PaymentsSessionRequest": {
         "type": "object",
-        "required": [
-          "payment_id",
-          "client_secret",
-          "wallets"
-        ],
+        "required": ["payment_id", "client_secret", "wallets"],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -4539,11 +4251,7 @@
       },
       "PaymentsSessionResponse": {
         "type": "object",
-        "required": [
-          "payment_id",
-          "client_secret",
-          "session_token"
-        ],
+        "required": ["payment_id", "client_secret", "session_token"],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -4563,11 +4271,7 @@
       },
       "PaymentsStartRequest": {
         "type": "object",
-        "required": [
-          "payment_id",
-          "merchant_id",
-          "attempt_id"
-        ],
+        "required": ["payment_id", "merchant_id", "attempt_id"],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -4585,9 +4289,7 @@
       },
       "PaypalSessionTokenResponse": {
         "type": "object",
-        "required": [
-          "session_token"
-        ],
+        "required": ["session_token"],
         "properties": {
           "session_token": {
             "type": "string",
@@ -4651,9 +4353,7 @@
       },
       "RefundListResponse": {
         "type": "object",
-        "required": [
-          "data"
-        ],
+        "required": ["data"],
         "properties": {
           "data": {
             "type": "array",
@@ -4665,9 +4365,7 @@
       },
       "RefundRequest": {
         "type": "object",
-        "required": [
-          "payment_id"
-        ],
+        "required": ["payment_id"],
         "properties": {
           "refund_id": {
             "type": "string",
@@ -4712,13 +4410,7 @@
       },
       "RefundResponse": {
         "type": "object",
-        "required": [
-          "refund_id",
-          "payment_id",
-          "amount",
-          "currency",
-          "status"
-        ],
+        "required": ["refund_id", "payment_id", "amount", "currency", "status"],
         "properties": {
           "refund_id": {
             "type": "string",
@@ -4770,19 +4462,11 @@
       "RefundStatus": {
         "type": "string",
         "description": "The status for refunds",
-        "enum": [
-          "succeeded",
-          "failed",
-          "pending",
-          "review"
-        ]
+        "enum": ["succeeded", "failed", "pending", "review"]
       },
       "RefundType": {
         "type": "string",
-        "enum": [
-          "scheduled",
-          "instant"
-        ]
+        "enum": ["scheduled", "instant"]
       },
       "RefundUpdateRequest": {
         "type": "object",
@@ -4853,10 +4537,7 @@
       "RevokeApiKeyResponse": {
         "type": "object",
         "description": "The response body for revoking an API Key.",
-        "required": [
-          "key_id",
-          "revoked"
-        ],
+        "required": ["key_id", "revoked"],
         "properties": {
           "key_id": {
             "type": "string",
@@ -4874,12 +4555,7 @@
       "RoutingAlgorithm": {
         "type": "string",
         "description": "The routing algorithm to be used to process the incoming request from merchant to outgoing payment processor or payment method. The default is 'Custom'",
-        "enum": [
-          "round_robin",
-          "max_conversion",
-          "min_cost",
-          "custom"
-        ],
+        "enum": ["round_robin", "max_conversion", "min_cost", "custom"],
         "example": "custom"
       },
       "SessionToken": {
@@ -4891,15 +4567,11 @@
               },
               {
                 "type": "object",
-                "required": [
-                  "wallet_name"
-                ],
+                "required": ["wallet_name"],
                 "properties": {
                   "wallet_name": {
                     "type": "string",
-                    "enum": [
-                      "gpay"
-                    ]
+                    "enum": ["gpay"]
                   }
                 }
               }
@@ -4912,15 +4584,11 @@
               },
               {
                 "type": "object",
-                "required": [
-                  "wallet_name"
-                ],
+                "required": ["wallet_name"],
                 "properties": {
                   "wallet_name": {
                     "type": "string",
-                    "enum": [
-                      "klarna"
-                    ]
+                    "enum": ["klarna"]
                   }
                 }
               }
@@ -4933,15 +4601,11 @@
               },
               {
                 "type": "object",
-                "required": [
-                  "wallet_name"
-                ],
+                "required": ["wallet_name"],
                 "properties": {
                   "wallet_name": {
                     "type": "string",
-                    "enum": [
-                      "paypal"
-                    ]
+                    "enum": ["paypal"]
                   }
                 }
               }
@@ -4954,15 +4618,11 @@
               },
               {
                 "type": "object",
-                "required": [
-                  "wallet_name"
-                ],
+                "required": ["wallet_name"],
                 "properties": {
                   "wallet_name": {
                     "type": "string",
-                    "enum": [
-                      "applepay"
-                    ]
+                    "enum": ["applepay"]
                   }
                 }
               }
@@ -4976,12 +4636,7 @@
       "SupportedWallets": {
         "type": "string",
         "description": "Wallets which support obtaining session object",
-        "enum": [
-          "paypal",
-          "apple_pay",
-          "klarna",
-          "gpay"
-        ]
+        "enum": ["paypal", "apple_pay", "klarna", "gpay"]
       },
       "UpdateApiKeyRequest": {
         "type": "object",
@@ -5017,9 +4672,7 @@
       },
       "WalletData": {
         "type": "object",
-        "required": [
-          "issuer_name"
-        ],
+        "required": ["issuer_name"],
         "properties": {
           "issuer_name": {
             "$ref": "#/components/schemas/WalletIssuer"
@@ -5032,11 +4685,7 @@
       },
       "WalletIssuer": {
         "type": "string",
-        "enum": [
-          "googlepay",
-          "applepay",
-          "paypal"
-        ]
+        "enum": ["googlepay", "applepay", "paypal"]
       },
       "WebhookDetails": {
         "type": "object",
@@ -5117,4 +4766,4 @@
       "description": "Create and manage API Keys"
     }
   ]
-}
\ No newline at end of file
+}

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

- [x] New feature

## Description
<!-- Describe your changes in detail -->
Support EPS, Giropay and iDeal through stripe


## 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 its an obvious bug or documentation fix
that will have little conversation).
-->
All the flows are redirection flows which provide the status in redirect url, we update it in the database using that.

## 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)?
-->
- EPS
![Screenshot 2023-02-09 at 11 35 37 PM](https://user-images.githubusercontent.com/48803246/217899840-c0b0d17d-cc58-40b2-a028-9ae9ae9d38b8.png)

- Giropay
![Screenshot 2023-02-09 at 11 36 01 PM](https://user-images.githubusercontent.com/48803246/217899910-319fad85-de9d-4a35-81bc-489f98758611.png)

- iDeal
![Screenshot 2023-02-09 at 11 36 36 PM](https://user-images.githubusercontent.com/48803246/217900052-65f86146-9f24-4bf3-b17d-c1ec6af936ae.png)


## 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 submitted code
- [ ] I added unit tests for my changes where possible
- [ ] I added a [CHANGELOG](/CHANGELOG.md) entry if applicable
