Bug: [FEATURE] List payment_methods with the required fields in each method



### Feature Description

When /payments API call is made from merchant server, payment is created. Assume that customer hasn't sent the required field in this call. But when a `confirm` API call is made, since customer has missed to send the required filed during `create`, this triggers an error. 

### Possible Implementation

After `Payment create` call is made, when `list_payment_methods` call will be made, along with the payment_methods we need to send the required fields for each method, so that it could be sent during `confirm` call.

### Have you spent some time to check if this feature request has been raised before?

- [X] I checked and didn't find similar issue

### Have you read the Contributing Guidelines?

- [X] I have read the [Contributing Guidelines](https://github.com/juspay/hyperswitch/blob/main/docs/CONTRIBUTING.md)

### Are you willing to submit a PR?

Yes I am willing to submit a PR!
diff --git a/config/config.example.toml b/config/config.example.toml
index 2d43669ea1d..cbe1af472fd 100644
--- a/config/config.example.toml
+++ b/config/config.example.toml
@@ -286,3 +286,12 @@ refund_duration = 1000           # Fake delay duration for dummy connector refun
 refund_tolerance = 100           # Fake delay tolerance for dummy connector refund
 refund_retrieve_duration = 500   # Fake delay duration for dummy connector refund sync
 refund_retrieve_tolerance = 100  # Fake delay tolerance for dummy connector refund sync
+
+# Required fields info used while listing the payment_method_data
+[required_fields.pay_later] # payment_method = "pay_later"
+afterpay_clearpay = {fields = {stripe = [  # payment_method_type = afterpay_clearpay, connector = "stripe"
+            # Required fields vector with its respective display name in front-end and field_type
+            { required_field = "shipping.address.first_name", display_name = "first_name", field_type = "text" },
+            { required_field = "shipping.address.last_name", display_name = "last_name", field_type = "text" },
+            { required_field = "shipping.address.country", display_name = "country", field_type = { drop_down = { options = [ "US", "IN" ] } } },
+        ] } }
diff --git a/crates/api_models/src/enums.rs b/crates/api_models/src/enums.rs
index 10aabb0b592..28ef808c77f 100644
--- a/crates/api_models/src/enums.rs
+++ b/crates/api_models/src/enums.rs
@@ -974,6 +974,26 @@ pub struct UnresolvedResponseReason {
     pub message: String,
 }
 
+/// Possible field type of required fields in payment_method_data
+#[derive(
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+    ToSchema,
+    Hash,
+)]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum FieldType {
+    Text,
+    DropDown { options: Vec<String> },
+}
+
 #[derive(
     Debug,
     serde::Deserialize,
diff --git a/crates/api_models/src/payment_methods.rs b/crates/api_models/src/payment_methods.rs
index a3d6c85f154..ef794ccfa85 100644
--- a/crates/api_models/src/payment_methods.rs
+++ b/crates/api_models/src/payment_methods.rs
@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use cards::CardNumber;
 use common_utils::{crypto::OptionalEncryptableName, pii};
 use serde::de;
@@ -214,6 +216,23 @@ pub struct ResponsePaymentMethodTypes {
     pub bank_debits: Option<BankDebitTypes>,
     /// The Bank transfer payment method information, if applicable for a payment method type.
     pub bank_transfers: Option<BankTransferTypes>,
+
+    /// Required fields for the payment_method_type.
+    pub required_fields: Option<HashSet<RequiredFieldInfo>>,
+}
+
+/// Required fields info used while listing the payment_method_data
+#[derive(Debug, serde::Deserialize, serde::Serialize, Clone, PartialEq, Eq, ToSchema, Hash)]
+pub struct RequiredFieldInfo {
+    /// Required field for a payment_method through a payment_method_type
+    pub required_field: String,
+
+    /// Display name of the required field in the front-end
+    pub display_name: String,
+
+    /// Possible field type of required field
+    #[schema(value_type = FieldType)]
+    pub field_type: api_enums::FieldType,
 }
 
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize, ToSchema)]
diff --git a/crates/router/src/configs/defaults.rs b/crates/router/src/configs/defaults.rs
index 7fae1d65acb..19e1f980e47 100644
--- a/crates/router/src/configs/defaults.rs
+++ b/crates/router/src/configs/defaults.rs
@@ -1,3 +1,9 @@
+use std::collections::HashMap;
+
+use api_models::{enums, payment_methods::RequiredFieldInfo};
+
+use super::settings::{ConnectorFields, PaymentMethodType};
+
 impl Default for super::settings::Server {
     fn default() -> Self {
         Self {
@@ -137,6 +143,811 @@ impl Default for super::settings::DrainerSettings {
     }
 }
 
+impl Default for super::settings::RequiredFields {
+    fn default() -> Self {
+        Self(HashMap::from([
+            (
+                enums::PaymentMethod::Card,
+                PaymentMethodType(HashMap::from([(
+                    enums::PaymentMethodType::Debit,
+                    ConnectorFields {
+                        fields: HashMap::from([
+                            (
+                                enums::Connector::Aci,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Bluesnap,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Bambora,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Cybersource,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.phone.number".to_string(),
+                                        display_name: "phone_number".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.phone.country_code".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.line1".to_string(),
+                                        display_name: "line1".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.city".to_string(),
+                                        display_name: "city".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.state".to_string(),
+                                        display_name: "state".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.zip".to_string(),
+                                        display_name: "zip".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Dlocal,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "card.card_holder_name".to_string(),
+                                        display_name: "card_holder_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Forte,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "card.card_holder_name".to_string(),
+                                        display_name: "card_holder_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Globalpay,
+                                vec![RequiredFieldInfo {
+                                    required_field: "billing.address.country".to_string(),
+                                    display_name: "country".to_string(),
+                                    field_type: enums::FieldType::DropDown {
+                                        options: vec!["US".to_string(), "IN".to_string()],
+                                    },
+                                }],
+                            ),
+                            (
+                                enums::Connector::Iatapay,
+                                vec![RequiredFieldInfo {
+                                    required_field: "billing.address.country".to_string(),
+                                    display_name: "country".to_string(),
+                                    field_type: enums::FieldType::DropDown {
+                                        options: vec!["US".to_string(), "IN".to_string()],
+                                    },
+                                }],
+                            ),
+                            (
+                                enums::Connector::Multisafepay,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.line1".to_string(),
+                                        display_name: "line1".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.line2".to_string(),
+                                        display_name: "line2".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.city".to_string(),
+                                        display_name: "city".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.zip".to_string(),
+                                        display_name: "zip".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Noon,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Opennode,
+                                vec![RequiredFieldInfo {
+                                    required_field: "description".to_string(),
+                                    display_name: "description".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Payu,
+                                vec![RequiredFieldInfo {
+                                    required_field: "description".to_string(),
+                                    display_name: "description".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Rapyd,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Shift4,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Trustpay,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "card.card_holder_name".to_string(),
+                                        display_name: "card_holder_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.line1".to_string(),
+                                        display_name: "line1".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.city".to_string(),
+                                        display_name: "city".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.zip".to_string(),
+                                        display_name: "zip".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "browser_info".to_string(),
+                                        display_name: "browser_info".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                ],
+                            ),
+                            (
+                                enums::Connector::Worldline,
+                                vec![RequiredFieldInfo {
+                                    required_field: "card.card_holder_name".to_string(),
+                                    display_name: "card_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            ),
+                            (
+                                enums::Connector::Zen,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "browser_info".to_string(),
+                                        display_name: "browser_info".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "description".to_string(),
+                                        display_name: "description".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "metadata.order_details".to_string(),
+                                        display_name: "order_details".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                ],
+                            ),
+                        ]),
+                    },
+                )])),
+            ),
+            (
+                enums::PaymentMethod::BankRedirect,
+                PaymentMethodType(HashMap::from([
+                    (
+                        enums::PaymentMethodType::Ach,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "currency".to_string(),
+                                        display_name: "currency".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                                (
+                                    enums::Connector::Adyen,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "card_holder_name".to_string(),
+                                        display_name: "card_holder_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Przelewy24,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Stripe,
+                                vec![RequiredFieldInfo {
+                                    required_field: "bank_name".to_string(),
+                                    display_name: "bank_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            )]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::BancontactCard,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "bancontact_card.billing_name".to_string(),
+                                        display_name: "billing_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                                (
+                                    enums::Connector::Adyen,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "bancontact_card.card_number"
+                                                .to_string(),
+                                            display_name: "card_number".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "bancontact_card.card_exp_month"
+                                                .to_string(),
+                                            display_name: "card_exp_month".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "bancontact_card.card_exp_year"
+                                                .to_string(),
+                                            display_name: "card_exp_year".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "bancontact_card.card_holder_name"
+                                                .to_string(),
+                                            display_name: "card_holder_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                    ],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Sepa,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Adyen,
+                                vec![RequiredFieldInfo {
+                                    required_field: "bank_account_holder_name".to_string(),
+                                    display_name: "bank_account_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            )]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Bacs,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Adyen,
+                                vec![RequiredFieldInfo {
+                                    required_field: "bank_account_holder_name".to_string(),
+                                    display_name: "bank_account_holder_name".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            )]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Giropay,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Worldline,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "giropay.billing_details.billing_name"
+                                            .to_string(),
+                                        display_name: "billing_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                                (
+                                    enums::Connector::Nuvei,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "email".to_string(),
+                                            display_name: "email".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                    ],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Ideal,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Worldline,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "ideal.bank_name".to_string(),
+                                        display_name: "bank_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                                (
+                                    enums::Connector::Nuvei,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "ideal.bank_name".to_string(),
+                                            display_name: "bank_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.first_name"
+                                                .to_string(),
+                                            display_name: "first_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.last_name".to_string(),
+                                            display_name: "last_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "email".to_string(),
+                                            display_name: "email".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                    ],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Sofort,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Nuvei,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                ],
+                            )]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Eps,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Nuvei,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                ],
+                            )]),
+                        },
+                    ),
+                ])),
+            ),
+            (
+                enums::PaymentMethod::Wallet,
+                PaymentMethodType(HashMap::from([
+                    (
+                        enums::PaymentMethodType::ApplePay,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Bluesnap,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "billing_address".to_string(),
+                                        display_name: "billing_address".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                                (
+                                    enums::Connector::Zen,
+                                    vec![RequiredFieldInfo {
+                                        required_field: "metadata.order_details".to_string(),
+                                        display_name: "order_details".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    }],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Paypal,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Mollie,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "billing_address".to_string(),
+                                            display_name: "billing_address".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping_address".to_string(),
+                                            display_name: "shipping_address".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                    ],
+                                ),
+                                (
+                                    enums::Connector::Nuvei,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "email".to_string(),
+                                            display_name: "email".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                    ],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::GooglePay,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Zen,
+                                vec![RequiredFieldInfo {
+                                    required_field: "metadata.order_details".to_string(),
+                                    display_name: "order_details".to_string(),
+                                    field_type: enums::FieldType::Text,
+                                }],
+                            )]),
+                        },
+                    ),
+                ])),
+            ),
+            (
+                enums::PaymentMethod::PayLater,
+                PaymentMethodType(HashMap::from([
+                    (
+                        enums::PaymentMethodType::AfterpayClearpay,
+                        ConnectorFields {
+                            fields: HashMap::from([
+                                (
+                                    enums::Connector::Stripe,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.first_name"
+                                                .to_string(),
+                                            display_name: "first_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.line1".to_string(),
+                                            display_name: "line1".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.zip".to_string(),
+                                            display_name: "zip".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                    ],
+                                ),
+                                (
+                                    enums::Connector::Adyen,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.first_name"
+                                                .to_string(),
+                                            display_name: "first_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.line1".to_string(),
+                                            display_name: "line1".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "shipping.address.zip".to_string(),
+                                            display_name: "zip".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                    ],
+                                ),
+                                (
+                                    enums::Connector::Nuvei,
+                                    vec![
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.first_name"
+                                                .to_string(),
+                                            display_name: "first_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.last_name".to_string(),
+                                            display_name: "last_name".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "email".to_string(),
+                                            display_name: "email".to_string(),
+                                            field_type: enums::FieldType::Text,
+                                        },
+                                        RequiredFieldInfo {
+                                            required_field: "billing.address.country".to_string(),
+                                            display_name: "country".to_string(),
+                                            field_type: enums::FieldType::DropDown {
+                                                options: vec!["US".to_string(), "IN".to_string()],
+                                            },
+                                        },
+                                    ],
+                                ),
+                            ]),
+                        },
+                    ),
+                    (
+                        enums::PaymentMethodType::Klarna,
+                        ConnectorFields {
+                            fields: HashMap::from([(
+                                enums::Connector::Nuvei,
+                                vec![
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.first_name".to_string(),
+                                        display_name: "first_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.last_name".to_string(),
+                                        display_name: "last_name".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "email".to_string(),
+                                        display_name: "email".to_string(),
+                                        field_type: enums::FieldType::Text,
+                                    },
+                                    RequiredFieldInfo {
+                                        required_field: "billing.address.country".to_string(),
+                                        display_name: "country".to_string(),
+                                        field_type: enums::FieldType::DropDown {
+                                            options: vec!["US".to_string(), "IN".to_string()],
+                                        },
+                                    },
+                                ],
+                            )]),
+                        },
+                    ),
+                ])),
+            ),
+        ]))
+    }
+}
+
 #[allow(clippy::derivable_impls)]
 impl Default for super::settings::ApiKeys {
     fn default() -> Self {
diff --git a/crates/router/src/configs/settings.rs b/crates/router/src/configs/settings.rs
index c494ee0a7c7..9e317bbae98 100644
--- a/crates/router/src/configs/settings.rs
+++ b/crates/router/src/configs/settings.rs
@@ -4,7 +4,7 @@ use std::{
     str::FromStr,
 };
 
-use api_models::enums;
+use api_models::{enums, payment_methods::RequiredFieldInfo};
 use common_utils::ext_traits::ConfigExt;
 use config::{Environment, File};
 #[cfg(feature = "email")]
@@ -83,6 +83,7 @@ pub struct Settings {
     pub dummy_connector: DummyConnector,
     #[cfg(feature = "email")]
     pub email: EmailSettings,
+    pub required_fields: RequiredFields,
     pub delayed_session_response: DelayedSessionConfig,
 }
 
@@ -223,6 +224,17 @@ pub struct NotAvailableFlows {
     pub capture_method: Option<enums::CaptureMethod>,
 }
 
+#[derive(Debug, Deserialize, Clone)]
+pub struct RequiredFields(pub HashMap<enums::PaymentMethod, PaymentMethodType>);
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct PaymentMethodType(pub HashMap<enums::PaymentMethodType, ConnectorFields>);
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct ConnectorFields {
+    pub fields: HashMap<enums::Connector, Vec<RequiredFieldInfo>>,
+}
+
 fn string_set_deser<'a, D>(
     deserializer: D,
 ) -> Result<Option<HashSet<api_models::enums::CountryAlpha2>>, D::Error>
diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs
index c790f6bb2d9..cf2d396ebd3 100644
--- a/crates/router/src/core/payment_methods/cards.rs
+++ b/crates/router/src/core/payment_methods/cards.rs
@@ -1,10 +1,13 @@
-use std::collections::{HashMap, HashSet};
+use std::{
+    collections::{HashMap, HashSet},
+    str::FromStr,
+};
 
 use api_models::{
     admin::{self, PaymentMethodsEnabled},
     enums::{self as api_enums},
     payment_methods::{
-        CardNetworkTypes, PaymentExperienceTypes, RequestPaymentMethodTypes,
+        CardNetworkTypes, PaymentExperienceTypes, RequestPaymentMethodTypes, RequiredFieldInfo,
         ResponsePaymentMethodIntermediate, ResponsePaymentMethodTypes,
         ResponsePaymentMethodsEnabled,
     },
@@ -860,11 +863,56 @@ pub async fn list_payment_methods(
     let mut bank_transfer_consolidated_hm =
         HashMap::<api_enums::PaymentMethodType, Vec<String>>::new();
 
+    let mut required_fields_hm = HashMap::<
+        api_enums::PaymentMethod,
+        HashMap<api_enums::PaymentMethodType, HashSet<RequiredFieldInfo>>,
+    >::new();
+
     for element in response.clone() {
         let payment_method = element.payment_method;
         let payment_method_type = element.payment_method_type;
         let connector = element.connector.clone();
 
+        let connector_variant = api_enums::Connector::from_str(connector.as_str())
+            .into_report()
+            .change_context(errors::ConnectorError::InvalidConnectorName)
+            .change_context(errors::ApiErrorResponse::InvalidDataValue {
+                field_name: "connector",
+            })
+            .attach_printable_lazy(|| format!("unable to parse connector name {connector:?}"))?;
+        state.conf.required_fields.0.get(&payment_method).map(
+            |required_fields_hm_for_each_payment_method_type| {
+                required_fields_hm_for_each_payment_method_type
+                    .0
+                    .get(&payment_method_type)
+                    .map(|required_fields_hm_for_each_connector| {
+                        required_fields_hm
+                            .entry(payment_method)
+                            .or_insert(HashMap::new());
+                        required_fields_hm_for_each_connector
+                            .fields
+                            .get(&connector_variant)
+                            .map(|required_fields_vec| {
+                                // If payment_method_type already exist in required_fields_hm, extend the required_fields hs to existing hs.
+                                let required_fields_hs =
+                                    HashSet::from_iter(required_fields_vec.iter().cloned());
+
+                                let existing_req_fields_hs = required_fields_hm
+                                    .get_mut(&payment_method)
+                                    .and_then(|inner_hm| inner_hm.get_mut(&payment_method_type));
+
+                                if let Some(inner_hs) = existing_req_fields_hs {
+                                    inner_hs.extend(required_fields_hs);
+                                } else {
+                                    required_fields_hm.get_mut(&payment_method).map(|inner_hm| {
+                                        inner_hm.insert(payment_method_type, required_fields_hs)
+                                    });
+                                }
+                            })
+                    })
+            },
+        );
+
         if let Some(payment_experience) = element.payment_experience {
             if let Some(payment_method_hm) =
                 payment_experiences_consolidated_hm.get_mut(&payment_method)
@@ -993,6 +1041,11 @@ pub async fn list_payment_methods(
                 bank_names: None,
                 bank_debits: None,
                 bank_transfers: None,
+                // Required fields for PayLater payment method
+                required_fields: required_fields_hm
+                    .get(key.0)
+                    .and_then(|inner_hm| inner_hm.get(payment_method_types_hm.0))
+                    .cloned(),
             })
         }
 
@@ -1020,6 +1073,11 @@ pub async fn list_payment_methods(
                 bank_names: None,
                 bank_debits: None,
                 bank_transfers: None,
+                // Required fields for Card payment method
+                required_fields: required_fields_hm
+                    .get(key.0)
+                    .and_then(|inner_hm| inner_hm.get(payment_method_types_hm.0))
+                    .cloned(),
             })
         }
 
@@ -1043,6 +1101,11 @@ pub async fn list_payment_methods(
                 card_networks: None,
                 bank_debits: None,
                 bank_transfers: None,
+                // Required fields for BankRedirect payment method
+                required_fields: required_fields_hm
+                    .get(&api_enums::PaymentMethod::BankRedirect)
+                    .and_then(|inner_hm| inner_hm.get(key.0))
+                    .cloned(),
             }
         })
     }
@@ -1069,6 +1132,11 @@ pub async fn list_payment_methods(
                     eligible_connectors: connectors.clone(),
                 }),
                 bank_transfers: None,
+                // Required fields for BankDebit payment method
+                required_fields: required_fields_hm
+                    .get(&api_enums::PaymentMethod::BankDebit)
+                    .and_then(|inner_hm| inner_hm.get(key.0))
+                    .cloned(),
             }
         })
     }
@@ -1095,6 +1163,11 @@ pub async fn list_payment_methods(
                 bank_transfers: Some(api_models::payment_methods::BankTransferTypes {
                     eligible_connectors: connectors,
                 }),
+                // Required fields for BankTransfer payment method
+                required_fields: required_fields_hm
+                    .get(&api_enums::PaymentMethod::BankTransfer)
+                    .and_then(|inner_hm| inner_hm.get(key.0))
+                    .cloned(),
             }
         })
     }
diff --git a/crates/router/src/openapi.rs b/crates/router/src/openapi.rs
index 40e7d32a1be..2c0643d3fe3 100644
--- a/crates/router/src/openapi.rs
+++ b/crates/router/src/openapi.rs
@@ -150,6 +150,7 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::enums::DisputeStage,
         api_models::enums::DisputeStatus,
         api_models::enums::CountryAlpha2,
+        api_models::enums::FieldType,
         api_models::enums::FrmAction,
         api_models::enums::FrmPreferredFlowTypes,
         api_models::enums::RetryAction,
@@ -249,6 +250,7 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::payments::SepaBankTransferInstructions,
         api_models::payments::BacsBankTransferInstructions,
         api_models::payments::RedirectResponse,
+        api_models::payment_methods::RequiredFieldInfo,
         api_models::refunds::RefundListRequest,
         api_models::refunds::RefundListResponse,
         api_models::refunds::TimeRange,
diff --git a/openapi/openapi_spec.json b/openapi/openapi_spec.json
index 72ebee8100d..240cf9698c1 100644
--- a/openapi/openapi_spec.json
+++ b/openapi/openapi_spec.json
@@ -2740,6 +2740,12 @@
               }
             ],
             "nullable": true
+          },
+          "nick_name": {
+            "type": "string",
+            "description": "The card holder's nick name",
+            "example": "John Test",
+            "nullable": true
           }
         }
       },
@@ -2771,6 +2777,12 @@
             "type": "string",
             "description": "Card Holder Name",
             "example": "John Doe"
+          },
+          "nick_name": {
+            "type": "string",
+            "description": "Card Holder's Nick Name",
+            "example": "John Doe",
+            "nullable": true
           }
         }
       },
@@ -2808,6 +2820,10 @@
           "card_fingerprint": {
             "type": "string",
             "nullable": true
+          },
+          "nick_name": {
+            "type": "string",
+            "nullable": true
           }
         }
       },
@@ -3861,6 +3877,39 @@
           }
         }
       },
+      "FieldType": {
+        "oneOf": [
+          {
+            "type": "string",
+            "enum": [
+              "text"
+            ]
+          },
+          {
+            "type": "object",
+            "required": [
+              "drop_down"
+            ],
+            "properties": {
+              "drop_down": {
+                "type": "object",
+                "required": [
+                  "options"
+                ],
+                "properties": {
+                  "options": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        ],
+        "description": "Possible field type of required fields in payment_method_data"
+      },
       "FrmAction": {
         "type": "string",
         "enum": [
@@ -6340,8 +6389,7 @@
         "type": "object",
         "required": [
           "amount",
-          "currency",
-          "manual_retry"
+          "currency"
         ],
         "properties": {
           "payment_id": {
@@ -6652,9 +6700,13 @@
             "description": "Business sub label for the payment",
             "nullable": true
           },
-          "manual_retry": {
-            "type": "boolean",
-            "description": "If enabled payment can be retried from the client side until the payment is successful or payment expires or the attempts(configured by the merchant) for payment are exhausted."
+          "retry_action": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/RetryAction"
+              }
+            ],
+            "nullable": true
           },
           "udf": {
             "type": "object",
@@ -6974,9 +7026,13 @@
             "description": "Business sub label for the payment",
             "nullable": true
           },
-          "manual_retry": {
-            "type": "boolean",
-            "description": "If enabled payment can be retried from the client side until the payment is successful or payment expires or the attempts(configured by the merchant) for payment are exhausted."
+          "retry_action": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/RetryAction"
+              }
+            ],
+            "nullable": true
           },
           "udf": {
             "type": "object",
@@ -7302,6 +7358,11 @@
             ],
             "nullable": true
           },
+          "manual_retry_allowed": {
+            "type": "boolean",
+            "description": "If true the payment can be retried with same or different payment method which means the confirm call can be made again.",
+            "nullable": true
+          },
           "udf": {
             "type": "object",
             "description": "Any user defined fields can be passed here.",
@@ -7765,6 +7826,28 @@
           }
         }
       },
+      "RequiredFieldInfo": {
+        "type": "object",
+        "description": "Required fields info used while listing the payment_method_data",
+        "required": [
+          "required_field",
+          "display_name",
+          "field_type"
+        ],
+        "properties": {
+          "required_field": {
+            "type": "string",
+            "description": "Required field for a payment_method through a payment_method_type"
+          },
+          "display_name": {
+            "type": "string",
+            "description": "Display name of the required field in the front-end"
+          },
+          "field_type": {
+            "$ref": "#/components/schemas/FieldType"
+          }
+        }
+      },
       "RetrieveApiKeyResponse": {
         "type": "object",
         "description": "The response body for retrieving an API Key.",
@@ -7818,6 +7901,13 @@
           }
         }
       },
+      "RetryAction": {
+        "type": "string",
+        "enum": [
+          "manual_retry",
+          "requeue"
+        ]
+      },
       "RevokeApiKeyResponse": {
         "type": "object",
         "description": "The response body for revoking an API Key.",

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

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

## Description
<!-- Describe your changes in detail -->
Currently when `/payments` API call is made with `confirm = false` from merchant server, payment is created. Assuming the customer hasn't sent the required field in this call, when a confirm API call is made, since customer has missed to send the required filed during create call, confirm call triggers an error.
So, after Payment create call is made, when payment_methods_list call will be made, along with the payment_methods we need to send the required fields for each method, so that it could be sent during confirm call.

Api changes - Added a new field `required_fields` in `payment_method_data` which lists all the required fields with its appropriate display_name, field_type and field_options. 

`payment_method_data: {"payment_method": {"payment_method_type": "", "required_fields": {} } }`

Config changes - Added `required_fields` in config which is a tuple struct containing a `HashMap<PaymentMethod, PaymentMethodType>`. PaymentMethodType is also tuple struct containing `HashMap<PaymentMethodType, ConnectorFields>`. ConnectorFields is a named field struct containing `HashMap<Connector, HashSet<RequiredFieldInfo>>>>` and RequiredFieldInfo is a struct defined in `api_models` crate, containing info about each required field. The default implementation for the same is provided in `defaults.rs` which contains data of required fields for each payment_method and payment_method_type.

required_fields are added in defaults.rs in connector level. But while listing, it would be in payment_method_type level as we are not sure about which connector the payment is going through during confirm call. So we get a union of all required_fields of connectors for a particular payment_method_type

### Additional Changes

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

## 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).
-->
To avoid failure of payments due to missing required fields

## 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)?
-->
Postman

![image](https://github.com/juspay/hyperswitch/assets/70657455/92c38f1c-f94b-43d9-ba25-b7532871b64f)



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

- [x] I formatted the code `cargo +nightly fmt --all`
- [x] I addressed lints thrown by `cargo clippy`
- [x] I reviewed submitted code
- [ ] I added unit tests for my changes where possible
- [ ] I added a [CHANGELOG](/CHANGELOG.md) entry if applicable
