Issue:
Bug: [BUG] docs: `amount` and `currency` are optional in OpenAPI docs



### Bug Description

The error 
```json
{
    "error": {
        "type": "invalid_request",
        "message": "Missing required param: currency",
        "code": "IR_04"
    }
}
``` 
Is thrown when creating a payment with no fields in the request body.The request is created as per the openapi schema shown [here](https://app.swaggerhub.com/apis-docs/bernard-eugine/HyperswitchAPI/0.0.1)

### Expected Behavior

The openapi schema should accurately tell which fields are mandatory in the request.

### Actual Behavior

Openapi schema lists all fields as optional.

### Steps To Reproduce

Provide an unambiguous set of steps to reproduce this bug. Include code or configuration to reproduce, if relevant.
1. Create a payment with no fields in the request body.


### Context For The Bug

_No response_

### Environment

Local environment.

### Have you spent some time to check if this bug 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!

Pull request description:
## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [x] New feature

## Description
<!-- Describe your changes in detail -->
This PR will allow us to specify which fields are mandatory in `PaymentsRequest` for a particular flow. A new macro is added called `PolymorphicSchema` ( Name is open for discussion ), which will generate different schemas as specified by 
`#[generate_schemas(PaymentsCreateRequest)]` , where we can specify which fields will be mandatory in PaymentsCreateRequest by adding the `mandatory_in` attribute as follows

```rust
#[mandatory_in(PaymentsCreateRequest)]
amount: Option<u64>
```
, this will add the `#[schema( required = true )` for that field when creating the schema.

For more information, you can refer to the macro documentation here.

<!-- 
Provide links to the files with corresponding changes.

Following are the paths where you can find config files:
1. `config`
2. `crates/router/src/configs`
3. `loadtest/config`
-->


## Motivation and Context
<!--
Why is this change required? What problem does it solve?
If it fixes an open issue, please link to the issue here.

If you don't have an issue, we'd recommend starting with one first so the PR
can focus on the implementation (unless its an obvious bug or documentation fix
that will have little conversation).
-->
Make meaningful documentation which is easy to use. Fixes #1118 

## 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)?
-->
Manually. Generate the openapi file and check if fields are marked as mandatory.

## 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


Testing:

Manually. Generate the openapi file and check if fields are marked as mandatory.

Patch:
diff --git a/Cargo.lock b/Cargo.lock
index b504c3db426..6cb3e124104 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2970,7 +2970,7 @@ dependencies = [
 [[package]]
 name = "opentelemetry"
 version = "0.18.0"
-source = "git+https://github.com/open-telemetry/opentelemetry-rust/?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
+source = "git+https://github.com/open-telemetry/opentelemetry-rust?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
 dependencies = [
  "opentelemetry_api",
  "opentelemetry_sdk",
@@ -2979,7 +2979,7 @@ dependencies = [
 [[package]]
 name = "opentelemetry-otlp"
 version = "0.11.0"
-source = "git+https://github.com/open-telemetry/opentelemetry-rust/?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
+source = "git+https://github.com/open-telemetry/opentelemetry-rust?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
 dependencies = [
  "async-trait",
  "futures",
@@ -2996,7 +2996,7 @@ dependencies = [
 [[package]]
 name = "opentelemetry-proto"
 version = "0.1.0"
-source = "git+https://github.com/open-telemetry/opentelemetry-rust/?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
+source = "git+https://github.com/open-telemetry/opentelemetry-rust?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
 dependencies = [
  "futures",
  "futures-util",
@@ -3008,7 +3008,7 @@ dependencies = [
 [[package]]
 name = "opentelemetry_api"
 version = "0.18.0"
-source = "git+https://github.com/open-telemetry/opentelemetry-rust/?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
+source = "git+https://github.com/open-telemetry/opentelemetry-rust?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
 dependencies = [
  "fnv",
  "futures-channel",
@@ -3023,7 +3023,7 @@ dependencies = [
 [[package]]
 name = "opentelemetry_sdk"
 version = "0.18.0"
-source = "git+https://github.com/open-telemetry/opentelemetry-rust/?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
+source = "git+https://github.com/open-telemetry/opentelemetry-rust?rev=44b90202fd744598db8b0ace5b8f0bad7ec45658#44b90202fd744598db8b0ace5b8f0bad7ec45658"
 dependencies = [
  "async-trait",
  "crossbeam-channel",
diff --git a/crates/api_models/src/admin.rs b/crates/api_models/src/admin.rs
index 1d6155b08c8..43677bbd26f 100644
--- a/crates/api_models/src/admin.rs
+++ b/crates/api_models/src/admin.rs
@@ -308,7 +308,9 @@ impl From<StraightThroughAlgorithm> for StraightThroughAlgorithmSerde {
 #[derive(Clone, Debug, Deserialize, ToSchema, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct PrimaryBusinessDetails {
+    #[schema(value_type = CountryAlpha2)]
     pub country: api_enums::CountryAlpha2,
+    #[schema(example = "food")]
     pub business: String,
 }
 
@@ -439,10 +441,12 @@ pub struct MerchantConnectorCreate {
     pub frm_configs: Option<FrmConfigs>,
 
     /// Business Country of the connector
-    #[schema(value_type = CountryAlpha2, example = "US")]
     #[cfg(feature = "multiple_mca")]
+    #[schema(value_type = CountryAlpha2, example = "US")]
     pub business_country: api_enums::CountryAlpha2,
+
     #[cfg(not(feature = "multiple_mca"))]
+    #[schema(value_type = Option<CountryAlpha2>, example = "US")]
     pub business_country: Option<api_enums::CountryAlpha2>,
 
     ///Business Type of the merchant
@@ -620,7 +624,11 @@ pub struct FrmConfigs {
     pub frm_enabled_pms: Option<Vec<String>>,
     pub frm_enabled_pm_types: Option<Vec<String>>,
     pub frm_enabled_gateways: Option<Vec<String>>,
-    pub frm_action: api_enums::FrmAction, //What should be the action if FRM declines the txn (autorefund/cancel txn/manual review)
+    /// What should be the action if FRM declines the txn (autorefund/cancel txn/manual review)
+    #[schema(value_type = FrmAction)]
+    pub frm_action: api_enums::FrmAction,
+    /// Whether to make a call to the FRM before or after the payment
+    #[schema(value_type = FrmPreferredFlowTypes)]
     pub frm_preferred_flow_type: api_enums::FrmPreferredFlowTypes,
 }
 /// Details of all the payment methods enabled for the connector for the given merchant account
@@ -644,7 +652,9 @@ pub struct PaymentMethodsEnabled {
     rename_all = "snake_case"
 )]
 pub enum AcceptedCurrencies {
+    #[schema(value_type = Vec<Currency>)]
     EnableOnly(Vec<api_enums::Currency>),
+    #[schema(value_type = Vec<Currency>)]
     DisableOnly(Vec<api_enums::Currency>),
     AllAccepted,
 }
@@ -657,7 +667,9 @@ pub enum AcceptedCurrencies {
     rename_all = "snake_case"
 )]
 pub enum AcceptedCountries {
+    #[schema(value_type = Vec<CountryAlpha2>)]
     EnableOnly(Vec<api_enums::CountryAlpha2>),
+    #[schema(value_type = Vec<CountryAlpha2>)]
     DisableOnly(Vec<api_enums::CountryAlpha2>),
     AllAccepted,
 }
diff --git a/crates/api_models/src/payments.rs b/crates/api_models/src/payments.rs
index fa44ab63ab7..2c611f11bb0 100644
--- a/crates/api_models/src/payments.rs
+++ b/crates/api_models/src/payments.rs
@@ -40,7 +40,16 @@ pub struct BankCodeResponse {
     pub eligible_connectors: Vec<String>,
 }
 
-#[derive(Default, Debug, serde::Deserialize, serde::Serialize, Clone, ToSchema)]
+#[derive(
+    Default,
+    Debug,
+    serde::Deserialize,
+    serde::Serialize,
+    Clone,
+    ToSchema,
+    router_derive::PolymorphicSchema,
+)]
+#[generate_schemas(PaymentsCreateRequest)]
 #[serde(deny_unknown_fields)]
 pub struct PaymentsRequest {
     /// Unique identifier for the payment. This ensures idempotency for multiple payments
@@ -62,6 +71,8 @@ pub struct PaymentsRequest {
     /// 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")]
+    #[mandatory_in(PaymentsCreateRequest)]
+    // Makes the field mandatory in PaymentsCreateRequest
     pub amount: Option<Amount>,
 
     #[schema(value_type = Option<RoutingAlgorithm>, example = json!({
@@ -76,6 +87,7 @@ pub struct PaymentsRequest {
 
     /// The currency of the payment request can be specified here
     #[schema(value_type = Option<Currency>, example = "USD")]
+    #[mandatory_in(PaymentsCreateRequest)]
     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.
@@ -203,7 +215,7 @@ pub struct PaymentsRequest {
     pub payment_method_type: Option<api_enums::PaymentMethodType>,
 
     /// Business country of the merchant for this payment
-    #[schema(value_type = CountryAlpha2, example = "US")]
+    #[schema(value_type = Option<CountryAlpha2>, example = "US")]
     pub business_country: Option<api_enums::CountryAlpha2>,
 
     /// Business label of the merchant for this payment
@@ -211,6 +223,7 @@ pub struct PaymentsRequest {
     pub business_label: Option<String>,
 
     /// Merchant connector details used to make payments.
+    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 
     /// Allowed Payment Method Types for a given PaymentIntent
@@ -625,7 +638,13 @@ pub enum BankRedirectData {
         /// The billing details for bank redirection
         billing_details: BankRedirectBilling,
         /// Bank account details for Giropay
+
+        #[schema(value_type = Option<String>)]
+        /// Bank account bic code
         bank_account_bic: Option<Secret<String>>,
+
+        /// Bank account iban
+        #[schema(value_type = Option<String>)]
         bank_account_iban: Option<Secret<String>>,
     },
     Ideal {
@@ -641,26 +660,32 @@ pub enum BankRedirectData {
         #[schema(value_type = CountryAlpha2, example = "US")]
         country: api_enums::CountryAlpha2,
 
+        #[schema(value_type = String, example = "john.doe@example.com")]
         email: Email,
     },
     OnlineBankingCzechRepublic {
         // Issuer banks
+        #[schema(value_type = BankNames)]
         issuer: api_enums::BankNames,
     },
     OnlineBankingFinland {
         // Shopper Email
+        #[schema(value_type = Option<String>)]
         email: Option<Email>,
     },
     OnlineBankingPoland {
         // Issuer banks
+        #[schema(value_type = BankNames)]
         issuer: api_enums::BankNames,
     },
     OnlineBankingSlovakia {
         // Issuer value corresponds to the bank
+        #[schema(value_type = BankNames)]
         issuer: api_enums::BankNames,
     },
     Przelewy24 {
         //Issuer banks
+        #[schema(value_type = Option<BankNames>)]
         bank_name: Option<api_enums::BankNames>,
 
         // The billing details for bank redirect
@@ -768,6 +793,7 @@ pub struct MobilePayRedirection {}
 #[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
 pub struct MbWayRedirection {
     /// Telephone number of the shopper. Should be Portuguese phone number.
+    #[schema(value_type = String)]
     pub telephone_number: Secret<String>,
 }
 
@@ -976,6 +1002,7 @@ pub struct PaymentsCaptureRequest {
     /// Concatenated with the statement descriptor suffix that’s set on the account to form the complete statement descriptor.
     pub statement_descriptor_prefix: Option<String>,
     /// Merchant connector details used to make payments.
+    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 }
 
@@ -1175,6 +1202,7 @@ pub struct PaymentsResponse {
     pub connector_label: Option<String>,
 
     /// The business country of merchant for this payment
+    #[schema(value_type = CountryAlpha2)]
     pub business_country: api_enums::CountryAlpha2,
 
     /// The business label of merchant for this payment
@@ -1425,6 +1453,7 @@ pub struct PaymentsRetrieveRequest {
     /// The name of the connector
     pub connector: Option<String>,
     /// Merchant connector details used to make payments.
+    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 }
 
@@ -1448,7 +1477,9 @@ pub struct Metadata {
     #[schema(value_type = Object, example = r#"{ "city": "NY", "unit": "245" }"#)]
     #[serde(flatten)]
     pub data: pii::SecretSerdeValue,
+
     /// Payload coming in request as a metadata field
+    #[schema(value_type = Option<Object>)]
     pub payload: Option<pii::SecretSerdeValue>,
 
     /// Allowed payment method types for a payment intent
@@ -1466,6 +1497,7 @@ pub struct PaymentsSessionRequest {
     #[schema(value_type = Vec<PaymentMethodType>)]
     pub wallets: Vec<api_enums::PaymentMethodType>,
     /// Merchant connector details used to make payments.
+    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 }
 
@@ -1734,6 +1766,7 @@ pub struct PaymentsCancelRequest {
     /// The reason for the payment cancel
     pub cancellation_reason: Option<String>,
     /// Merchant connector details used to make payments.
+    #[schema(value_type = MerchantConnectorDetailsWrap)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 }
 
diff --git a/crates/api_models/src/refunds.rs b/crates/api_models/src/refunds.rs
index d07e7c86b14..2108c8cb1ad 100644
--- a/crates/api_models/src/refunds.rs
+++ b/crates/api_models/src/refunds.rs
@@ -45,6 +45,7 @@ pub struct RefundRequest {
     pub metadata: Option<pii::SecretSerdeValue>,
 
     /// Merchant connector details used to make payments.
+    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
     pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
 }
 
diff --git a/crates/router/src/configs/settings.rs b/crates/router/src/configs/settings.rs
index 40960960551..9a0cd1ec4de 100644
--- a/crates/router/src/configs/settings.rs
+++ b/crates/router/src/configs/settings.rs
@@ -201,6 +201,7 @@ pub struct CurrencyCountryFlowFilter {
     pub country: Option<HashSet<api_models::enums::CountryAlpha2>>,
     pub not_available_flows: Option<NotAvailableFlows>,
 }
+
 #[derive(Debug, Deserialize, Copy, Clone, Default)]
 #[serde(default)]
 pub struct NotAvailableFlows {
diff --git a/crates/router/src/core/payments.rs b/crates/router/src/core/payments.rs
index 1be4c8fb66a..ce26fc1fd4d 100644
--- a/crates/router/src/core/payments.rs
+++ b/crates/router/src/core/payments.rs
@@ -89,6 +89,7 @@ where
             &merchant_account,
         )
         .await?;
+
     authenticate_client_secret(
         req.get_client_secret(),
         &payment_data.payment_intent,
diff --git a/crates/router/src/openapi.rs b/crates/router/src/openapi.rs
index bd5d81d5b4c..a2aecb8aa79 100644
--- a/crates/router/src/openapi.rs
+++ b/crates/router/src/openapi.rs
@@ -29,7 +29,7 @@ Use the following base URLs when making requests to the APIs:
 | Environment   |  Base URL                          |
 |---------------|------------------------------------|
 | Sandbox       | <https://sandbox.hyperswitch.io>   |
-| Production    | Coming Soon!                       |
+| Production    | <https://api.hyperswitch.io>       |
 
 ## Authentication
 
@@ -38,10 +38,10 @@ account, you are given a secret key (also referred as api-key) and a publishable
 You may authenticate all API requests with Hyperswitch server by providing the appropriate key in
 the request Authorization header.
 
-| Key           |  Description                                                                                  |
-|---------------|-----------------------------------------------------------------------------------------------|
-| Sandbox       | Private key. Used to authenticate all API requests from your merchant server                  |
-| Production    | Unique identifier for your account. Used to authenticate API requests from your app's client  |
+| Key             |  Description                                                                                  |
+|-----------------|-----------------------------------------------------------------------------------------------|
+| api-key         | Private key. Used to authenticate all API requests from your merchant server                  |
+| publishable key | Unique identifier for your account. Used to authenticate API requests from your app's client  |
 
 Never share your secret api keys. Keep them guarded and secure.
 "#,
@@ -65,15 +65,16 @@ Never share your secret api keys. Keep them guarded and secure.
         crate::routes::refunds::refunds_retrieve,
         crate::routes::refunds::refunds_update,
         crate::routes::refunds::refunds_list,
-        crate::routes::admin::merchant_account_create,
-        crate::routes::admin::retrieve_merchant_account,
-        crate::routes::admin::update_merchant_account,
-        crate::routes::admin::delete_merchant_account,
-        crate::routes::admin::payment_connector_create,
-        crate::routes::admin::payment_connector_retrieve,
-        crate::routes::admin::payment_connector_list,
-        crate::routes::admin::payment_connector_update,
-        crate::routes::admin::payment_connector_delete,
+        // Commenting this out as these are admin apis and not to be used by the merchant
+        // crate::routes::admin::merchant_account_create,
+        // crate::routes::admin::retrieve_merchant_account,
+        // crate::routes::admin::update_merchant_account,
+        // crate::routes::admin::delete_merchant_account,
+        // crate::routes::admin::payment_connector_create,
+        // crate::routes::admin::payment_connector_retrieve,
+        // crate::routes::admin::payment_connector_list,
+        // crate::routes::admin::payment_connector_update,
+        // crate::routes::admin::payment_connector_delete,
         crate::routes::mandates::get_mandate,
         crate::routes::mandates::revoke_mandate,
         crate::routes::payments::payments_create,
@@ -114,6 +115,7 @@ Never share your secret api keys. Keep them guarded and secure.
         crate::types::api::admin::MerchantAccountUpdate,
         crate::types::api::admin::MerchantAccountDeleteResponse,
         crate::types::api::admin::MerchantConnectorDeleteResponse,
+        crate::types::api::admin::MerchantConnectorResponse,
         crate::types::api::customers::CustomerRequest,
         crate::types::api::customers::CustomerDeleteResponse,
         crate::types::api::payment_methods::PaymentMethodCreate,
@@ -148,10 +150,25 @@ 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::FrmAction,
+        api_models::enums::FrmPreferredFlowTypes,
         api_models::admin::MerchantConnectorCreate,
+        api_models::admin::MerchantConnectorUpdate,
+        api_models::admin::PrimaryBusinessDetails,
+        api_models::admin::FrmConfigs,
         api_models::admin::PaymentMethodsEnabled,
+        api_models::admin::MerchantConnectorDetailsWrap,
+        api_models::admin::MerchantConnectorDetails,
         api_models::disputes::DisputeResponse,
+        api_models::disputes::DisputeResponsePaymentsRetrieve,
         api_models::payments::AddressDetails,
+        api_models::payments::BankDebitData,
+        api_models::payments::AliPayRedirection,
+        api_models::payments::MbWayRedirection,
+        api_models::payments::MobilePayRedirection,
+        api_models::payments::WeChatPayRedirection,
+        api_models::payments::BankDebitBilling,
+        api_models::payments::CryptoData,
         api_models::payments::Address,
         api_models::payments::BankRedirectData,
         api_models::payments::BankRedirectBilling,
@@ -172,6 +189,7 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::payments::Card,
         api_models::payments::CustomerAcceptance,
         api_models::payments::PaymentsRequest,
+        api_models::payments::PaymentsCreateRequest,
         api_models::payments::PaymentsResponse,
         api_models::payments::PaymentsStartRequest,
         api_models::payments::PaymentRetrieveBody,
diff --git a/crates/router/src/routes/admin.rs b/crates/router/src/routes/admin.rs
index cf73f4d536e..94e9c0f49b2 100644
--- a/crates/router/src/routes/admin.rs
+++ b/crates/router/src/routes/admin.rs
@@ -158,9 +158,9 @@ pub async fn delete_merchant_account(
 #[utoipa::path(
     post,
     path = "/accounts/{account_id}/connectors",
-    request_body = MerchantConnector,
+    request_body = MerchantConnectorCreate,
     responses(
-        (status = 200, description = "Merchant Connector Created", body = MerchantConnector),
+        (status = 200, description = "Merchant Connector Created", body = MerchantConnectorResponse),
         (status = 400, description = "Missing Mandatory fields"),
     ),
     tag = "Merchant Connector Account",
@@ -198,7 +198,7 @@ pub async fn payment_connector_create(
         ("connector_id" = i32, Path, description = "The unique identifier for the Merchant Connector")
     ),
     responses(
-        (status = 200, description = "Merchant Connector retrieved successfully", body = MerchantConnector),
+        (status = 200, description = "Merchant Connector retrieved successfully", body = MerchantConnectorResponse),
         (status = 404, description = "Merchant Connector does not exist in records"),
         (status = 401, description = "Unauthorized request")
     ),
@@ -242,7 +242,7 @@ pub async fn payment_connector_retrieve(
         ("account_id" = String, Path, description = "The unique identifier for the merchant account"),
     ),
     responses(
-        (status = 200, description = "Merchant Connector list retrieved successfully", body = Vec<MerchantConnector>),
+        (status = 200, description = "Merchant Connector list retrieved successfully", body = Vec<MerchantConnectorResponse>),
         (status = 404, description = "Merchant Connector does not exist in records"),
         (status = 401, description = "Unauthorized request")
     ),
@@ -275,13 +275,13 @@ pub async fn payment_connector_list(
 #[utoipa::path(
     post,
     path = "/accounts/{account_id}/connectors/{connector_id}",
-    request_body = MerchantConnector,
+    request_body = MerchantConnectorUpdate,
     params(
         ("account_id" = String, Path, description = "The unique identifier for the merchant account"),
         ("connector_id" = i32, Path, description = "The unique identifier for the Merchant Connector")
     ),
     responses(
-        (status = 200, description = "Merchant Connector Updated", body = MerchantConnector),
+        (status = 200, description = "Merchant Connector Updated", body = MerchantConnectorResponse),
         (status = 404, description = "Merchant Connector does not exist in records"),
         (status = 401, description = "Unauthorized request")
     ),
diff --git a/crates/router/src/routes/disputes.rs b/crates/router/src/routes/disputes.rs
index 9b81654a538..4e291d0085b 100644
--- a/crates/router/src/routes/disputes.rs
+++ b/crates/router/src/routes/disputes.rs
@@ -11,7 +11,7 @@ use crate::{
     types::api::disputes as dispute_types,
 };
 
-/// Diputes - Retrieve Dispute
+/// Disputes - Retrieve Dispute
 #[utoipa::path(
     get,
     path = "/disputes/{dispute_id}",
@@ -47,7 +47,7 @@ pub async fn retrieve_dispute(
     .await
 }
 
-/// Diputes - List Disputes
+/// Disputes - List Disputes
 #[utoipa::path(
     get,
     path = "/disputes/list",
@@ -90,7 +90,7 @@ pub async fn retrieve_disputes_list(
     .await
 }
 
-/// Diputes - Accept Dispute
+/// Disputes - Accept Dispute
 #[utoipa::path(
     get,
     path = "/disputes/accept/{dispute_id}",
@@ -126,7 +126,7 @@ pub async fn accept_dispute(
     .await
 }
 
-/// Diputes - Submit Dispute Evidence
+/// Disputes - Submit Dispute Evidence
 #[utoipa::path(
     post,
     path = "/disputes/evidence",
diff --git a/crates/router/src/routes/payment_methods.rs b/crates/router/src/routes/payment_methods.rs
index 7839035ae99..446c51837a4 100644
--- a/crates/router/src/routes/payment_methods.rs
+++ b/crates/router/src/routes/payment_methods.rs
@@ -48,7 +48,7 @@ pub async fn create_payment_method_api(
 /// To filter and list the applicable payment methods for a particular Merchant ID
 #[utoipa::path(
     get,
-    path = "/payment_methods/{account_id}",
+    path = "/account/payment_methods",
     params (
         ("account_id" = String, Path, description = "The unique identifier for the merchant account"),
         ("accepted_country" = Vec<String>, Query, description = "The two-letter ISO currency code"),
@@ -96,7 +96,7 @@ pub async fn list_payment_method_api(
 /// To filter and list the applicable payment methods for a particular Customer ID
 #[utoipa::path(
     get,
-    path = "/payment_methods/{customer_id}",
+    path = "/customer/{customer_id}/payment_methods",
     params (
         ("customer_id" = String, Path, description = "The unique identifier for the customer account"),
         ("accepted_country" = Vec<String>, Query, description = "The two-letter ISO currency code"),
diff --git a/crates/router/src/routes/payments.rs b/crates/router/src/routes/payments.rs
index 92030dcaea9..c2bd36f04be 100644
--- a/crates/router/src/routes/payments.rs
+++ b/crates/router/src/routes/payments.rs
@@ -18,7 +18,7 @@ use crate::{
 #[utoipa::path(
     post,
     path = "/payments",
-    request_body=PaymentsRequest,
+    request_body=PaymentsCreateRequest,
     responses(
         (status = 200, description = "Payment created", body = PaymentsResponse),
         (status = 400, description = "Missing Mandatory fields")
diff --git a/crates/router/src/types/api/admin.rs b/crates/router/src/types/api/admin.rs
index 70f9df7805d..6e573d5f24a 100644
--- a/crates/router/src/types/api/admin.rs
+++ b/crates/router/src/types/api/admin.rs
@@ -1,9 +1,9 @@
 pub use api_models::admin::{
     MerchantAccountCreate, MerchantAccountDeleteResponse, MerchantAccountResponse,
     MerchantAccountUpdate, MerchantConnectorCreate, MerchantConnectorDeleteResponse,
-    MerchantConnectorDetails, MerchantConnectorDetailsWrap, MerchantConnectorId, MerchantDetails,
-    MerchantId, PaymentMethodsEnabled, RoutingAlgorithm, StraightThroughAlgorithm, ToggleKVRequest,
-    ToggleKVResponse, WebhookDetails,
+    MerchantConnectorDetails, MerchantConnectorDetailsWrap, MerchantConnectorId,
+    MerchantConnectorResponse, MerchantDetails, MerchantId, PaymentMethodsEnabled,
+    RoutingAlgorithm, StraightThroughAlgorithm, ToggleKVRequest, ToggleKVResponse, WebhookDetails,
 };
 use common_utils::ext_traits::ValueExt;
 
diff --git a/crates/router_derive/src/lib.rs b/crates/router_derive/src/lib.rs
index 4fe12da088e..789505b66ff 100644
--- a/crates/router_derive/src/lib.rs
+++ b/crates/router_derive/src/lib.rs
@@ -462,3 +462,50 @@ pub fn operation_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
     let input = syn::parse_macro_input!(input as syn::DeriveInput);
     macros::operation_derive_inner(input).unwrap_or_else(|err| err.to_compile_error().into())
 }
+
+/// Generates different schemas with the ability to mark few fields as mandatory for certain schema
+/// Usage
+/// ```
+/// #[derive(PolymorphicSchema)]
+/// #[generate_schemas(PaymentsCreateRequest, PaymentsConfirmRequest)]
+/// struct PaymentsRequest {
+///     #[mandatory_in(PaymentsCreateRequest)]
+///     amount: Option<u64>,
+///     #[mandatory_in(PaymentsCreateRequest)]
+///     currency: Option<String>,
+///     payment_method: String,
+/// }
+/// ```
+///
+/// This will create two structs `PaymentsCreateRequest` and `PaymentsConfirmRequest` as follows
+/// It will retain all the other attributes that are used in the original struct, and only consume
+/// the #[mandatory_in] attribute to generate schemas
+///
+/// ```
+/// #[derive(utoipa::ToSchema)]
+/// struct PaymentsCreateRequest {
+///     #[schema(required = true)]
+///     amount: Option<u64>,
+///
+///     #[schema(required = true)]
+///     currency: Option<String>,
+///
+///     payment_method: String,
+/// }
+///
+/// #[derive(utoipa::ToSchema)]
+/// struct PaymentsConfirmRequest {
+///     amount: Option<u64>,
+///     currency: Option<String>,
+///     payment_method: String,
+/// }
+/// ```
+
+#[proc_macro_derive(PolymorphicSchema, attributes(mandatory_in, generate_schemas))]
+pub fn polymorphic_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(input as syn::DeriveInput);
+
+    macros::polymorphic_macro_derive_inner(input)
+        .unwrap_or_else(|error| error.into_compile_error())
+        .into()
+}
diff --git a/crates/router_derive/src/macros.rs b/crates/router_derive/src/macros.rs
index f9dfa3e741d..b451eb972e5 100644
--- a/crates/router_derive/src/macros.rs
+++ b/crates/router_derive/src/macros.rs
@@ -1,8 +1,10 @@
 pub(crate) mod api_error;
 pub(crate) mod diesel;
-mod helpers;
+pub(crate) mod generate_schema;
 pub(crate) mod operation;
 
+mod helpers;
+
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::DeriveInput;
@@ -12,6 +14,7 @@ pub(crate) use self::{
     diesel::{
         diesel_enum_attribute_inner, diesel_enum_derive_inner, diesel_enum_text_derive_inner,
     },
+    generate_schema::polymorphic_macro_derive_inner,
     operation::operation_derive_inner,
 };
 
diff --git a/crates/router_derive/src/macros/generate_schema.rs b/crates/router_derive/src/macros/generate_schema.rs
new file mode 100644
index 00000000000..478d955c724
--- /dev/null
+++ b/crates/router_derive/src/macros/generate_schema.rs
@@ -0,0 +1,140 @@
+use std::collections::{HashMap, HashSet};
+
+use syn::{self, parse_quote, punctuated::Punctuated, Token};
+
+use crate::macros::helpers;
+
+/// Parse schemas from attribute
+/// Example
+///
+/// #[mandatory_in(PaymentsCreateRequest, PaymentsUpdateRequest)]
+/// would return
+///
+/// [PaymentsCreateRequest, PaymentsUpdateRequest]
+fn get_inner_path_ident(attribute: &syn::Attribute) -> syn::Result<Vec<syn::Ident>> {
+    Ok(attribute
+        .parse_args_with(Punctuated::<syn::Ident, Token![,]>::parse_terminated)?
+        .into_iter()
+        .collect::<Vec<_>>())
+}
+
+fn get_struct_fields(data: syn::Data) -> syn::Result<Punctuated<syn::Field, syn::token::Comma>> {
+    if let syn::Data::Struct(syn::DataStruct {
+        fields: syn::Fields::Named(syn::FieldsNamed { ref named, .. }),
+        ..
+    }) = data
+    {
+        Ok(named.to_owned())
+    } else {
+        Err(syn::Error::new(
+            proc_macro2::Span::call_site(),
+            "This macro cannot be used on structs with no fields",
+        ))
+    }
+}
+
+pub fn polymorphic_macro_derive_inner(
+    input: syn::DeriveInput,
+) -> syn::Result<proc_macro2::TokenStream> {
+    let schemas_to_create =
+        helpers::get_metadata_inner::<syn::Ident>("generate_schemas", &input.attrs)?;
+
+    let fields = get_struct_fields(input.data)
+        .map_err(|error| syn::Error::new(proc_macro2::Span::call_site(), error))?;
+
+    // Go through all the fields and create a mapping of required fields for a schema
+    // PaymentsCreate -> ["amount","currency"]
+    // This will be stored in a hashset
+    // mandatory_hashset -> ((PaymentsCreate, amount), (PaymentsCreate,currency))
+    let mut mandatory_hashset = HashSet::<(syn::Ident, syn::Ident)>::new();
+    let mut other_fields_hm = HashMap::<syn::Field, Vec<syn::Attribute>>::new();
+
+    fields.iter().for_each(|field| {
+        // Partition the attributes of a field into two vectors
+        // One with #[mandatory_in] attributes present
+        // Rest of the attributes ( include only the schema attribute, serde is not required)
+        let (mandatory_attribute, other_attributes) = field
+            .attrs
+            .iter()
+            .partition::<Vec<_>, _>(|attribute| attribute.path.is_ident("mandatory_in"));
+
+        // Other attributes ( schema ) are to be printed as is
+        other_attributes
+            .iter()
+            .filter(|attribute| attribute.path.is_ident("schema") || attribute.path.is_ident("doc"))
+            .for_each(|attribute| {
+                // Since attributes will be modified, the field should not contain any attributes
+                // So create a field, with previous attributes removed
+                let mut field_without_attributes = field.clone();
+                field_without_attributes.attrs.clear();
+
+                other_fields_hm
+                    .entry(field_without_attributes.to_owned())
+                    .or_insert(vec![])
+                    .push(attribute.to_owned().to_owned());
+            });
+
+        // Mandatory attributes are to be inserted into hashset
+        // The hashset will store it in this format
+        // (PaymentsCreateRequest, "amount")
+        // (PaymentsConfirmRequest, "currency")
+        //
+        // For these attributes, we need to later add #[schema(required = true)] attribute
+        _ = mandatory_attribute
+            .iter()
+            // Filter only #[mandatory_in] attributes
+            .map(|&attribute| get_inner_path_ident(attribute))
+            .try_for_each(|schemas| {
+                let res = schemas
+                    .map_err(|error| syn::Error::new(proc_macro2::Span::call_site(), error))?
+                    .iter()
+                    .filter_map(|schema| field.ident.to_owned().zip(Some(schema.to_owned())))
+                    .collect::<HashSet<_>>();
+
+                mandatory_hashset.extend(res);
+                Ok::<_, syn::Error>(())
+            });
+    });
+
+    let schemas = schemas_to_create
+        .iter()
+        .map(|schema| {
+            let fields = other_fields_hm
+                .iter()
+                .flat_map(|(field, value)| {
+                    let mut attributes = value
+                        .iter()
+                        .map(|attribute| quote::quote!(#attribute))
+                        .collect::<Vec<_>>();
+
+                    // If the field is required for this schema, then add
+                    // #[schema(required = true)] for this field
+                    let required_attribute: syn::Attribute =
+                        parse_quote!(#[schema(required = true)]);
+
+                    // Can be none, because tuple fields have no ident
+                    field.ident.to_owned().and_then(|field_ident| {
+                        mandatory_hashset
+                            .contains(&(field_ident, schema.to_owned()))
+                            .then(|| attributes.push(quote::quote!(#required_attribute)))
+                    });
+
+                    quote::quote! {
+                        #(#attributes)*
+                        #field,
+                    }
+                })
+                .collect::<Vec<_>>();
+            quote::quote! {
+                #[derive(utoipa::ToSchema)]
+                pub struct #schema {
+                    #(#fields)*
+                }
+            }
+        })
+        .collect::<Vec<_>>();
+
+    Ok(quote::quote! {
+        #(#schemas)*
+    })
+}
diff --git a/openapi/generated.json b/openapi/generated.json
index 51e9f4e99f7..711f1cba104 100644
--- a/openapi/generated.json
+++ b/openapi/generated.json
@@ -2,7 +2,7 @@
   "openapi": "3.0.3",
   "info": {
     "title": "Hyperswitch - API Documentation",
-    "description": "\n## Get started\n\nHyperswitch provides a collection of APIs that enable you to process and manage payments.\nOur APIs accept and return JSON in the HTTP body, and return standard HTTP response codes.\n\nYou can consume the APIs directly using your favorite HTTP/REST library.\n\nWe have a testing environment referred to \"sandbox\", which you can setup to test API calls without\naffecting production data.\nCurrently, our sandbox environment is live while our production environment is under development\nand will be available soon.\nYou can sign up on our Dashboard to get API keys to access Hyperswitch API.\n\n### Environment\n\nUse the following base URLs when making requests to the APIs:\n\n| Environment   |  Base URL                          |\n|---------------|------------------------------------|\n| Sandbox       | <https://sandbox.hyperswitch.io>   |\n| Production    | Coming Soon!                       |\n\n## Authentication\n\nWhen you sign up on our [dashboard](https://app.hyperswitch.io) and create a merchant\naccount, you are given a secret key (also referred as api-key) and a publishable key.\nYou may authenticate all API requests with Hyperswitch server by providing the appropriate key in\nthe request Authorization header.\n\n| Key           |  Description                                                                                  |\n|---------------|-----------------------------------------------------------------------------------------------|\n| Sandbox       | Private key. Used to authenticate all API requests from your merchant server                  |\n| Production    | Unique identifier for your account. Used to authenticate API requests from your app's client  |\n\nNever share your secret api keys. Keep them guarded and secure.\n",
+    "description": "\n## Get started\n\nHyperswitch provides a collection of APIs that enable you to process and manage payments.\nOur APIs accept and return JSON in the HTTP body, and return standard HTTP response codes.\n\nYou can consume the APIs directly using your favorite HTTP/REST library.\n\nWe have a testing environment referred to \"sandbox\", which you can setup to test API calls without\naffecting production data.\nCurrently, our sandbox environment is live while our production environment is under development\nand will be available soon.\nYou can sign up on our Dashboard to get API keys to access Hyperswitch API.\n\n### Environment\n\nUse the following base URLs when making requests to the APIs:\n\n| Environment   |  Base URL                          |\n|---------------|------------------------------------|\n| Sandbox       | <https://sandbox.hyperswitch.io>   |\n| Production    | <https://api.hyperswitch.io>       |\n\n## Authentication\n\nWhen you sign up on our [dashboard](https://app.hyperswitch.io) and create a merchant\naccount, you are given a secret key (also referred as api-key) and a publishable key.\nYou may authenticate all API requests with Hyperswitch server by providing the appropriate key in\nthe request Authorization header.\n\n| Key             |  Description                                                                                  |\n|-----------------|-----------------------------------------------------------------------------------------------|\n| api-key         | Private key. Used to authenticate all API requests from your merchant server                  |\n| publishable key | Unique identifier for your account. Used to authenticate API requests from your app's client  |\n\nNever share your secret api keys. Keep them guarded and secure.\n",
     "contact": {
       "name": "Hyperswitch Support",
       "url": "https://hyperswitch.io",
@@ -20,105 +20,231 @@
     }
   ],
   "paths": {
-    "/accounts": {
-      "post": {
-        "tags": ["Merchant Account"],
-        "summary": "Merchant Account - Create",
-        "description": "Merchant Account - Create\n\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",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/MerchantAccountCreate"
+    "/account/payment_methods": {
+      "get": {
+        "tags": ["Payment Methods"],
+        "summary": "List payment methods for a Merchant",
+        "description": "List payment methods for a Merchant\n\nTo filter and list the applicable payment methods for a particular Merchant ID",
+        "operationId": "List all Payment Methods for a Merchant",
+        "parameters": [
+          {
+            "name": "account_id",
+            "in": "path",
+            "description": "The unique identifier for the merchant account",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "accepted_country",
+            "in": "query",
+            "description": "The two-letter ISO currency code",
+            "required": true,
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
               }
             }
           },
-          "required": true
-        },
+          {
+            "name": "accepted_currency",
+            "in": "path",
+            "description": "The three-letter ISO currency code",
+            "required": true,
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "#/components/schemas/Currency"
+              }
+            }
+          },
+          {
+            "name": "minimum_amount",
+            "in": "query",
+            "description": "The minimum amount accepted for processing by the particular payment method.",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int64"
+            }
+          },
+          {
+            "name": "maximum_amount",
+            "in": "query",
+            "description": "The maximum amount amount accepted for processing by the particular payment method.",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int64"
+            }
+          },
+          {
+            "name": "recurring_payment_enabled",
+            "in": "query",
+            "description": "Indicates whether the payment method is eligible for recurring payments",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "name": "installment_payment_enabled",
+            "in": "query",
+            "description": "Indicates whether the payment method is eligible for installment payments",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
         "responses": {
           "200": {
-            "description": "Merchant Account Created",
+            "description": "Payment Methods retrieved",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantAccountResponse"
+                  "$ref": "#/components/schemas/PaymentMethodListResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Invalid data"
+            "description": "Invalid Data"
+          },
+          "404": {
+            "description": "Payment Methods does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
+          },
+          {
+            "publishable_key": []
           }
         ]
       }
     },
-    "/accounts/{account_id}": {
+    "/customer/{customer_id}/payment_methods": {
       "get": {
-        "tags": ["Merchant Account"],
-        "summary": "Merchant Account - Retrieve",
-        "description": "Merchant Account - Retrieve\n\nRetrieve a merchant account details.",
-        "operationId": "Retrieve a Merchant Account",
+        "tags": ["Payment Methods"],
+        "summary": "List payment methods for a Customer",
+        "description": "List payment methods for a Customer\n\nTo filter and list the applicable payment methods for a particular Customer ID",
+        "operationId": "List all Payment Methods for a Customer",
         "parameters": [
           {
-            "name": "account_id",
+            "name": "customer_id",
             "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "description": "The unique identifier for the customer account",
             "required": true,
             "schema": {
               "type": "string"
             }
+          },
+          {
+            "name": "accepted_country",
+            "in": "query",
+            "description": "The two-letter ISO currency code",
+            "required": true,
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "name": "accepted_currency",
+            "in": "path",
+            "description": "The three-letter ISO currency code",
+            "required": true,
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "#/components/schemas/Currency"
+              }
+            }
+          },
+          {
+            "name": "minimum_amount",
+            "in": "query",
+            "description": "The minimum amount accepted for processing by the particular payment method.",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int64"
+            }
+          },
+          {
+            "name": "maximum_amount",
+            "in": "query",
+            "description": "The maximum amount amount accepted for processing by the particular payment method.",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int64"
+            }
+          },
+          {
+            "name": "recurring_payment_enabled",
+            "in": "query",
+            "description": "Indicates whether the payment method is eligible for recurring payments",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
+          },
+          {
+            "name": "installment_payment_enabled",
+            "in": "query",
+            "description": "Indicates whether the payment method is eligible for installment payments",
+            "required": true,
+            "schema": {
+              "type": "boolean"
+            }
           }
         ],
         "responses": {
           "200": {
-            "description": "Merchant Account Retrieved",
+            "description": "Payment Methods retrieved",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantAccountResponse"
+                  "$ref": "#/components/schemas/CustomerPaymentMethodsListResponse"
                 }
               }
             }
           },
+          "400": {
+            "description": "Invalid Data"
+          },
           "404": {
-            "description": "Merchant account not found"
+            "description": "Payment Methods does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
+          },
+          {
+            "ephemeral_key": []
           }
         ]
-      },
+      }
+    },
+    "/customers": {
       "post": {
-        "tags": ["Merchant Account"],
-        "summary": "Merchant Account - Update",
-        "description": "Merchant Account - Update\n\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",
-        "parameters": [
-          {
-            "name": "account_id",
-            "in": "path",
-            "description": "The unique identifier for the merchant account",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
+        "tags": ["Customers"],
+        "summary": "Create Customer",
+        "description": "Create Customer\n\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",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/MerchantAccountUpdate"
+                "$ref": "#/components/schemas/CustomerRequest"
               }
             }
           },
@@ -126,36 +252,37 @@
         },
         "responses": {
           "200": {
-            "description": "Merchant Account Updated",
+            "description": "Customer Created",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantAccountResponse"
+                  "$ref": "#/components/schemas/CustomerResponse"
                 }
               }
             }
           },
-          "404": {
-            "description": "Merchant account not found"
+          "400": {
+            "description": "Invalid data"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
-      },
-      "delete": {
-        "tags": ["Merchant Account"],
-        "summary": "Merchant Account - Delete",
-        "description": "Merchant Account - Delete\n\nTo delete a merchant account",
-        "operationId": "Delete a Merchant Account",
+      }
+    },
+    "/customers/{customer_id}": {
+      "get": {
+        "tags": ["Customers"],
+        "summary": "Retrieve Customer",
+        "description": "Retrieve Customer\n\nRetrieve a customer's details.",
+        "operationId": "Retrieve a Customer",
         "parameters": [
           {
-            "name": "account_id",
+            "name": "customer_id",
             "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "description": "The unique identifier for the Customer",
             "required": true,
             "schema": {
               "type": "string"
@@ -164,286 +291,388 @@
         ],
         "responses": {
           "200": {
-            "description": "Merchant Account Deleted",
+            "description": "Customer Retrieved",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantAccountDeleteResponse"
+                  "$ref": "#/components/schemas/CustomerResponse"
                 }
               }
             }
           },
           "404": {
-            "description": "Merchant account not found"
+            "description": "Customer was not found"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
+          },
+          {
+            "ephemeral_key": []
           }
         ]
-      }
-    },
-    "/accounts/{account_id}/connectors": {
-      "get": {
-        "tags": ["Merchant Connector Account"],
-        "summary": "Merchant Connector - List",
-        "description": "Merchant Connector - List\n\nList Merchant Connector Details for the merchant",
-        "operationId": "List all Merchant Connectors",
+      },
+      "post": {
+        "tags": ["Customers"],
+        "summary": "Update Customer",
+        "description": "Update Customer\n\nUpdates the customer's details in a customer object.",
+        "operationId": "Update a Customer",
         "parameters": [
           {
-            "name": "account_id",
+            "name": "customer_id",
             "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "description": "The unique identifier for the Customer",
             "required": true,
             "schema": {
               "type": "string"
             }
           }
         ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CustomerRequest"
+              }
+            }
+          },
+          "required": true
+        },
         "responses": {
           "200": {
-            "description": "Merchant Connector list retrieved successfully",
+            "description": "Customer was Updated",
             "content": {
               "application/json": {
                 "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/MerchantConnector"
-                  }
+                  "$ref": "#/components/schemas/CustomerResponse"
                 }
               }
             }
           },
-          "401": {
-            "description": "Unauthorized request"
-          },
           "404": {
-            "description": "Merchant Connector does not exist in records"
+            "description": "Customer was not found"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
       },
-      "post": {
-        "tags": ["Merchant Connector Account"],
-        "summary": "PaymentsConnectors - Create",
-        "description": "PaymentsConnectors - Create\n\nCreate a new Merchant 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",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/MerchantConnector"
-              }
+      "delete": {
+        "tags": ["Customers"],
+        "summary": "Delete Customer",
+        "description": "Delete Customer\n\nDelete a customer record.",
+        "operationId": "Delete a Customer",
+        "parameters": [
+          {
+            "name": "customer_id",
+            "in": "path",
+            "description": "The unique identifier for the Customer",
+            "required": true,
+            "schema": {
+              "type": "string"
             }
-          },
-          "required": true
-        },
+          }
+        ],
         "responses": {
           "200": {
-            "description": "Merchant Connector Created",
+            "description": "Customer was Deleted",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantConnector"
+                  "$ref": "#/components/schemas/CustomerDeleteResponse"
                 }
               }
             }
           },
-          "400": {
-            "description": "Missing Mandatory fields"
+          "404": {
+            "description": "Customer was not found"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
       }
     },
-    "/accounts/{account_id}/connectors/{connector_id}": {
+    "/disputes/list": {
       "get": {
-        "tags": ["Merchant Connector Account"],
-        "summary": "Merchant Connector - Retrieve",
-        "description": "Merchant Connector - Retrieve\n\nRetrieve Merchant Connector Details",
-        "operationId": "Retrieve a Merchant Connector",
+        "tags": ["Disputes"],
+        "summary": "Disputes - List Disputes",
+        "description": "Disputes - List Disputes",
+        "operationId": "List Disputes",
         "parameters": [
           {
-            "name": "account_id",
-            "in": "path",
-            "description": "The unique identifier for the merchant account",
-            "required": true,
+            "name": "limit",
+            "in": "query",
+            "description": "The maximum number of Dispute Objects to include in the response",
+            "required": false,
             "schema": {
-              "type": "string"
+              "type": "integer",
+              "format": "int64",
+              "nullable": true
             }
           },
           {
-            "name": "connector_id",
-            "in": "path",
-            "description": "The unique identifier for the Merchant Connector",
-            "required": true,
+            "name": "dispute_status",
+            "in": "query",
+            "description": "The status of dispute",
+            "required": false,
             "schema": {
-              "type": "integer",
-              "format": "int32"
+              "allOf": [
+                {
+                  "$ref": "#/components/schemas/DisputeStatus"
+                }
+              ],
+              "nullable": true
+            }
+          },
+          {
+            "name": "dispute_stage",
+            "in": "query",
+            "description": "The stage of dispute",
+            "required": false,
+            "schema": {
+              "allOf": [
+                {
+                  "$ref": "#/components/schemas/DisputeStage"
+                }
+              ],
+              "nullable": true
+            }
+          },
+          {
+            "name": "reason",
+            "in": "query",
+            "description": "The reason for dispute",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "nullable": true
+            }
+          },
+          {
+            "name": "connector",
+            "in": "query",
+            "description": "The connector linked to dispute",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "nullable": true
+            }
+          },
+          {
+            "name": "received_time",
+            "in": "query",
+            "description": "The time at which dispute is received",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time",
+              "nullable": true
+            }
+          },
+          {
+            "name": "received_time.lt",
+            "in": "query",
+            "description": "Time less than the dispute received time",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time",
+              "nullable": true
+            }
+          },
+          {
+            "name": "received_time.gt",
+            "in": "query",
+            "description": "Time greater than the dispute received time",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time",
+              "nullable": true
+            }
+          },
+          {
+            "name": "received_time.lte",
+            "in": "query",
+            "description": "Time less than or equals to the dispute received time",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time",
+              "nullable": true
+            }
+          },
+          {
+            "name": "received_time.gte",
+            "in": "query",
+            "description": "Time greater than or equals to the dispute received time",
+            "required": false,
+            "schema": {
+              "type": "string",
+              "format": "date-time",
+              "nullable": true
             }
           }
         ],
         "responses": {
           "200": {
-            "description": "Merchant Connector retrieved successfully",
+            "description": "The dispute list was retrieved successfully",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantConnector"
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DisputeResponse"
+                  }
                 }
               }
             }
           },
           "401": {
             "description": "Unauthorized request"
-          },
-          "404": {
-            "description": "Merchant Connector does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
-      },
-      "post": {
-        "tags": ["Merchant Connector Account"],
-        "summary": "Merchant Connector - Update",
-        "description": "Merchant Connector - Update\n\nTo update an existing Merchant Connector. Helpful in enabling / disabling different payment methods and other settings for the connector etc.",
-        "operationId": "Update a Merchant Connector",
+      }
+    },
+    "/disputes/{dispute_id}": {
+      "get": {
+        "tags": ["Disputes"],
+        "summary": "Disputes - Retrieve Dispute",
+        "description": "Disputes - Retrieve Dispute",
+        "operationId": "Retrieve a Dispute",
         "parameters": [
           {
-            "name": "account_id",
+            "name": "dispute_id",
             "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "description": "The identifier for dispute",
             "required": true,
             "schema": {
               "type": "string"
             }
-          },
-          {
-            "name": "connector_id",
-            "in": "path",
-            "description": "The unique identifier for the Merchant Connector",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int32"
-            }
           }
         ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/MerchantConnector"
-              }
-            }
-          },
-          "required": true
-        },
         "responses": {
           "200": {
-            "description": "Merchant Connector Updated",
+            "description": "The dispute was retrieved successfully",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantConnector"
+                  "$ref": "#/components/schemas/DisputeResponse"
                 }
               }
             }
           },
-          "401": {
-            "description": "Unauthorized request"
-          },
           "404": {
-            "description": "Merchant Connector does not exist in records"
+            "description": "Dispute does not exist in our records"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
-      },
-      "delete": {
-        "tags": ["Merchant Connector Account"],
-        "summary": "Merchant Connector - Delete",
-        "description": "Merchant Connector - Delete\n\nDelete or Detach a Merchant Connector from Merchant Account",
-        "operationId": "Delete a Merchant Connector",
+      }
+    },
+    "/mandates/revoke/{mandate_id}": {
+      "post": {
+        "tags": ["Mandates"],
+        "summary": "Mandates - Revoke Mandate",
+        "description": "Mandates - Revoke Mandate\n\nRevoke a mandate",
+        "operationId": "Revoke a Mandate",
         "parameters": [
           {
-            "name": "account_id",
+            "name": "mandate_id",
             "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "description": "The identifier for mandate",
             "required": true,
             "schema": {
               "type": "string"
             }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "The mandate was revoked successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/MandateRevokedResponse"
+                }
+              }
+            }
           },
+          "400": {
+            "description": "Mandate does not exist in our records"
+          }
+        },
+        "security": [
+          {
+            "api_key": []
+          }
+        ]
+      }
+    },
+    "/mandates/{mandate_id}": {
+      "get": {
+        "tags": ["Mandates"],
+        "summary": "Mandates - Retrieve Mandate",
+        "description": "Mandates - Retrieve Mandate\n\nRetrieve a mandate",
+        "operationId": "Retrieve a Mandate",
+        "parameters": [
           {
-            "name": "connector_id",
+            "name": "mandate_id",
             "in": "path",
-            "description": "The unique identifier for the Merchant Connector",
+            "description": "The identifier for mandate",
             "required": true,
             "schema": {
-              "type": "integer",
-              "format": "int32"
+              "type": "string"
             }
           }
         ],
         "responses": {
           "200": {
-            "description": "Merchant Connector Deleted",
+            "description": "The mandate was retrieved successfully",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/MerchantConnectorDeleteResponse"
+                  "$ref": "#/components/schemas/MandateResponse"
                 }
               }
             }
           },
-          "401": {
-            "description": "Unauthorized request"
-          },
           "404": {
-            "description": "Merchant Connector does not exist in records"
+            "description": "Mandate does not exist in our records"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "admin_api_key": []
+            "api_key": []
           }
         ]
       }
     },
-    "/customers": {
+    "/payment_methods": {
       "post": {
-        "tags": ["Customers"],
-        "summary": "Create Customer",
-        "description": "Create Customer\n\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",
+        "tags": ["Payment Methods"],
+        "summary": "PaymentMethods - Create",
+        "description": "PaymentMethods - Create\n\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",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/CustomerRequest"
+                "$ref": "#/components/schemas/PaymentMethodCreate"
               }
             }
           },
@@ -451,20 +680,19 @@
         },
         "responses": {
           "200": {
-            "description": "Customer Created",
+            "description": "Payment Method Created",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/CustomerResponse"
+                  "$ref": "#/components/schemas/PaymentMethodResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Invalid data"
+            "description": "Invalid Data"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
@@ -472,17 +700,17 @@
         ]
       }
     },
-    "/customers/{customer_id}": {
+    "/payment_methods/{method_id}": {
       "get": {
-        "tags": ["Customers"],
-        "summary": "Retrieve Customer",
-        "description": "Retrieve Customer\n\nRetrieve a customer's details.",
-        "operationId": "Retrieve a Customer",
+        "tags": ["Payment Methods"],
+        "summary": "Payment Method - Retrieve",
+        "description": "Payment Method - Retrieve\n\nTo retrieve a payment method",
+        "operationId": "Retrieve a Payment method",
         "parameters": [
           {
-            "name": "customer_id",
+            "name": "method_id",
             "in": "path",
-            "description": "The unique identifier for the Customer",
+            "description": "The unique identifier for the Payment Method",
             "required": true,
             "schema": {
               "type": "string"
@@ -491,39 +719,35 @@
         ],
         "responses": {
           "200": {
-            "description": "Customer Retrieved",
+            "description": "Payment Method retrieved",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/CustomerResponse"
+                  "$ref": "#/components/schemas/PaymentMethodResponse"
                 }
               }
             }
           },
           "404": {
-            "description": "Customer was not found"
+            "description": "Payment Method does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
-          },
-          {
-            "ephemeral_key": []
           }
         ]
       },
       "post": {
-        "tags": ["Customers"],
-        "summary": "Update Customer",
-        "description": "Update Customer\n\nUpdates the customer's details in a customer object.",
-        "operationId": "Update a Customer",
+        "tags": ["Payment Methods"],
+        "summary": "Payment Method - Update",
+        "description": "Payment Method - Update\n\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",
         "parameters": [
           {
-            "name": "customer_id",
+            "name": "method_id",
             "in": "path",
-            "description": "The unique identifier for the Customer",
+            "description": "The unique identifier for the Payment Method",
             "required": true,
             "schema": {
               "type": "string"
@@ -534,7 +758,7 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/CustomerRequest"
+                "$ref": "#/components/schemas/PaymentMethodUpdate"
               }
             }
           },
@@ -542,20 +766,19 @@
         },
         "responses": {
           "200": {
-            "description": "Customer was Updated",
+            "description": "Payment Method updated",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/CustomerResponse"
+                  "$ref": "#/components/schemas/PaymentMethodResponse"
                 }
               }
             }
           },
           "404": {
-            "description": "Customer was not found"
+            "description": "Payment Method does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
@@ -563,15 +786,15 @@
         ]
       },
       "delete": {
-        "tags": ["Customers"],
-        "summary": "Delete Customer",
-        "description": "Delete Customer\n\nDelete a customer record.",
-        "operationId": "Delete a Customer",
+        "tags": ["Payment Methods"],
+        "summary": "Payment Method - Delete",
+        "description": "Payment Method - Delete\n\nDelete payment method",
+        "operationId": "Delete a Payment method",
         "parameters": [
           {
-            "name": "customer_id",
+            "name": "method_id",
             "in": "path",
-            "description": "The unique identifier for the Customer",
+            "description": "The unique identifier for the Payment Method",
             "required": true,
             "schema": {
               "type": "string"
@@ -580,20 +803,19 @@
         ],
         "responses": {
           "200": {
-            "description": "Customer was Deleted",
+            "description": "Payment Method deleted",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/CustomerDeleteResponse"
+                  "$ref": "#/components/schemas/PaymentMethodDeleteResponse"
                 }
               }
             }
           },
           "404": {
-            "description": "Customer was not found"
+            "description": "Payment Method does not exist in records"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
@@ -601,97 +823,17 @@
         ]
       }
     },
-    "/mandates/revoke/{mandate_id}": {
-      "post": {
-        "tags": ["Mandates"],
-        "summary": "Mandates - Revoke Mandate",
-        "description": "Mandates - Revoke Mandate\n\nRevoke a mandate",
-        "operationId": "Revoke a Mandate",
-        "parameters": [
-          {
-            "name": "mandate_id",
-            "in": "path",
-            "description": "The identifier for mandate",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "The mandate was revoked successfully",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/MandateRevokedResponse"
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Mandate does not exist in our records"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/mandates/{mandate_id}": {
-      "get": {
-        "tags": ["Mandates"],
-        "summary": "Mandates - Retrieve Mandate",
-        "description": "Mandates - Retrieve Mandate\n\nRetrieve a mandate",
-        "operationId": "Retrieve a Mandate",
-        "parameters": [
-          {
-            "name": "mandate_id",
-            "in": "path",
-            "description": "The identifier for mandate",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "The mandate was retrieved successfully",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/MandateResponse"
-                }
-              }
-            }
-          },
-          "404": {
-            "description": "Mandate does not exist in our records"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/payment_methods": {
+    "/payments": {
       "post": {
-        "tags": ["Payment Methods"],
-        "summary": "PaymentMethods - Create",
-        "description": "PaymentMethods - Create\n\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",
+        "tags": ["Payments"],
+        "summary": "Payments - Create",
+        "description": "Payments - Create\n\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",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/PaymentMethodCreate"
+                "$ref": "#/components/schemas/PaymentsCreateRequest"
               }
             }
           },
@@ -699,20 +841,19 @@
         },
         "responses": {
           "200": {
-            "description": "Payment Method Created",
+            "description": "Payment created",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentMethodResponse"
+                  "$ref": "#/components/schemas/PaymentsResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Invalid Data"
+            "description": "Missing Mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
@@ -720,50 +861,44 @@
         ]
       }
     },
-    "/payment_methods/{account_id}": {
+    "/payments/list": {
       "get": {
-        "tags": ["Payment Methods"],
-        "summary": "List payment methods for a Merchant",
-        "description": "List payment methods for a Merchant\n\nTo filter and list the applicable payment methods for a particular Merchant ID",
-        "operationId": "List all Payment Methods for a Merchant",
+        "tags": ["Payments"],
+        "summary": "Payments - List",
+        "description": "Payments - List\n\nTo list the payments",
+        "operationId": "List all Payments",
         "parameters": [
           {
-            "name": "account_id",
-            "in": "path",
-            "description": "The unique identifier for the merchant account",
+            "name": "customer_id",
+            "in": "query",
+            "description": "The identifier for the customer",
             "required": true,
             "schema": {
               "type": "string"
             }
           },
           {
-            "name": "accepted_country",
+            "name": "starting_after",
             "in": "query",
-            "description": "The two-letter ISO currency code",
+            "description": "A cursor for use in pagination, fetch the next list after some object",
             "required": true,
             "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
+              "type": "string"
             }
           },
           {
-            "name": "accepted_currency",
-            "in": "path",
-            "description": "The three-letter ISO currency code",
+            "name": "ending_before",
+            "in": "query",
+            "description": "A cursor for use in pagination, fetch the previous list before some object",
             "required": true,
             "schema": {
-              "type": "array",
-              "items": {
-                "$ref": "#/components/schemas/Currency"
-              }
+              "type": "string"
             }
           },
           {
-            "name": "minimum_amount",
+            "name": "limit",
             "in": "query",
-            "description": "The minimum amount accepted for processing by the particular payment method.",
+            "description": "Limit on the number of objects to return",
             "required": true,
             "schema": {
               "type": "integer",
@@ -771,220 +906,264 @@
             }
           },
           {
-            "name": "maximum_amount",
+            "name": "created",
             "in": "query",
-            "description": "The maximum amount amount accepted for processing by the particular payment method.",
+            "description": "The time at which payment is created",
             "required": true,
             "schema": {
-              "type": "integer",
-              "format": "int64"
+              "type": "string",
+              "format": "date-time"
             }
           },
           {
-            "name": "recurring_payment_enabled",
+            "name": "created_lt",
             "in": "query",
-            "description": "Indicates whether the payment method is eligible for recurring payments",
+            "description": "Time less than the payment created time",
             "required": true,
             "schema": {
-              "type": "boolean"
+              "type": "string",
+              "format": "date-time"
             }
           },
           {
-            "name": "installment_payment_enabled",
+            "name": "created_gt",
             "in": "query",
-            "description": "Indicates whether the payment method is eligible for installment payments",
+            "description": "Time greater than the payment created time",
             "required": true,
             "schema": {
-              "type": "boolean"
+              "type": "string",
+              "format": "date-time"
+            }
+          },
+          {
+            "name": "created_lte",
+            "in": "query",
+            "description": "Time less than or equals to the payment created time",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          },
+          {
+            "name": "created_gte",
+            "in": "query",
+            "description": "Time greater than or equals to the payment created time",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "date-time"
             }
           }
         ],
         "responses": {
           "200": {
-            "description": "Payment Methods retrieved",
+            "description": "Received payment list"
+          },
+          "404": {
+            "description": "No payments found"
+          }
+        },
+        "security": [
+          {
+            "api_key": []
+          }
+        ]
+      }
+    },
+    "/payments/session_tokens": {
+      "post": {
+        "tags": ["Payments"],
+        "summary": "Payments - Session token",
+        "description": "Payments - Session token\n\nTo create the session object or to get session token for wallets",
+        "operationId": "Create Session tokens for a Payment",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PaymentsSessionRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Payment session object created or session token was retrieved from wallets",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentMethodListResponse"
+                  "$ref": "#/components/schemas/PaymentsSessionResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Invalid Data"
-          },
-          "404": {
-            "description": "Payment Methods does not exist in records"
+            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
-          {
-            "api_key": []
-          },
           {
             "publishable_key": []
           }
         ]
       }
     },
-    "/payment_methods/{customer_id}": {
+    "/payments/{payment_id}": {
       "get": {
-        "tags": ["Payment Methods"],
-        "summary": "List payment methods for a Customer",
-        "description": "List payment methods for a Customer\n\nTo filter and list the applicable payment methods for a particular Customer ID",
-        "operationId": "List all Payment Methods for a Customer",
+        "tags": ["Payments"],
+        "summary": "Payments - Retrieve",
+        "description": "Payments - Retrieve\n\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",
         "parameters": [
           {
-            "name": "customer_id",
+            "name": "payment_id",
             "in": "path",
-            "description": "The unique identifier for the customer account",
+            "description": "The identifier for payment",
             "required": true,
             "schema": {
               "type": "string"
             }
-          },
-          {
-            "name": "accepted_country",
-            "in": "query",
-            "description": "The two-letter ISO currency code",
-            "required": true,
-            "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PaymentRetrieveBody"
               }
             }
           },
-          {
-            "name": "accepted_currency",
-            "in": "path",
-            "description": "The three-letter ISO currency code",
-            "required": true,
-            "schema": {
-              "type": "array",
-              "items": {
-                "$ref": "#/components/schemas/Currency"
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Gets the payment with final status",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PaymentsResponse"
+                }
               }
             }
           },
+          "404": {
+            "description": "No payment found"
+          }
+        },
+        "security": [
           {
-            "name": "minimum_amount",
-            "in": "query",
-            "description": "The minimum amount accepted for processing by the particular payment method.",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int64"
-            }
-          },
-          {
-            "name": "maximum_amount",
-            "in": "query",
-            "description": "The maximum amount amount accepted for processing by the particular payment method.",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int64"
-            }
+            "api_key": []
           },
           {
-            "name": "recurring_payment_enabled",
-            "in": "query",
-            "description": "Indicates whether the payment method is eligible for recurring payments",
-            "required": true,
-            "schema": {
-              "type": "boolean"
-            }
-          },
+            "publishable_key": []
+          }
+        ]
+      },
+      "post": {
+        "tags": ["Payments"],
+        "summary": "Payments - Update",
+        "description": "Payments - Update\n\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",
+        "parameters": [
           {
-            "name": "installment_payment_enabled",
-            "in": "query",
-            "description": "Indicates whether the payment method is eligible for installment payments",
+            "name": "payment_id",
+            "in": "path",
+            "description": "The identifier for payment",
             "required": true,
             "schema": {
-              "type": "boolean"
+              "type": "string"
             }
           }
         ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PaymentsRequest"
+              }
+            }
+          },
+          "required": true
+        },
         "responses": {
           "200": {
-            "description": "Payment Methods retrieved",
+            "description": "Payment updated",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/CustomerPaymentMethodsListResponse"
+                  "$ref": "#/components/schemas/PaymentsResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Invalid Data"
-          },
-          "404": {
-            "description": "Payment Methods does not exist in records"
+            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
           },
           {
-            "ephemeral_key": []
+            "publishable_key": []
           }
         ]
       }
     },
-    "/payment_methods/{method_id}": {
-      "get": {
-        "tags": ["Payment Methods"],
-        "summary": "Payment Method - Retrieve",
-        "description": "Payment Method - Retrieve\n\nTo retrieve a payment method",
-        "operationId": "Retrieve a Payment method",
+    "/payments/{payment_id}/cancel": {
+      "post": {
+        "tags": ["Payments"],
+        "summary": "Payments - Cancel",
+        "description": "Payments - Cancel\n\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",
         "parameters": [
           {
-            "name": "method_id",
+            "name": "payment_id",
             "in": "path",
-            "description": "The unique identifier for the Payment Method",
+            "description": "The identifier for payment",
             "required": true,
             "schema": {
               "type": "string"
             }
           }
         ],
-        "responses": {
-          "200": {
-            "description": "Payment Method retrieved",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PaymentMethodResponse"
-                }
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PaymentsCancelRequest"
               }
             }
           },
-          "404": {
-            "description": "Payment Method does not exist in records"
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Payment canceled"
+          },
+          "400": {
+            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
           }
         ]
-      },
+      }
+    },
+    "/payments/{payment_id}/capture": {
       "post": {
-        "tags": ["Payment Methods"],
-        "summary": "Payment Method - Update",
-        "description": "Payment Method - Update\n\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",
+        "tags": ["Payments"],
+        "summary": "Payments - Capture",
+        "description": "Payments - Capture\n\nTo capture the funds for an uncaptured payment",
+        "operationId": "Capture a Payment",
         "parameters": [
           {
-            "name": "method_id",
+            "name": "payment_id",
             "in": "path",
-            "description": "The unique identifier for the Payment Method",
+            "description": "The identifier for payment",
             "required": true,
             "schema": {
               "type": "string"
@@ -995,7 +1174,7 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/PaymentMethodUpdate"
+                "$ref": "#/components/schemas/PaymentsCaptureRequest"
               }
             }
           },
@@ -1003,76 +1182,89 @@
         },
         "responses": {
           "200": {
-            "description": "Payment Method updated",
+            "description": "Payment captured",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentMethodResponse"
+                  "$ref": "#/components/schemas/PaymentsResponse"
                 }
               }
             }
           },
-          "404": {
-            "description": "Payment Method does not exist in records"
+          "400": {
+            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
           }
         ]
-      },
-      "delete": {
-        "tags": ["Payment Methods"],
-        "summary": "Payment Method - Delete",
-        "description": "Payment Method - Delete\n\nDelete payment method",
-        "operationId": "Delete a Payment method",
+      }
+    },
+    "/payments/{payment_id}/confirm": {
+      "post": {
+        "tags": ["Payments"],
+        "summary": "Payments - Confirm",
+        "description": "Payments - Confirm\n\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",
         "parameters": [
           {
-            "name": "method_id",
+            "name": "payment_id",
             "in": "path",
-            "description": "The unique identifier for the Payment Method",
+            "description": "The identifier for payment",
             "required": true,
             "schema": {
               "type": "string"
             }
           }
         ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PaymentsRequest"
+              }
+            }
+          },
+          "required": true
+        },
         "responses": {
           "200": {
-            "description": "Payment Method deleted",
+            "description": "Payment confirmed",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentMethodDeleteResponse"
+                  "$ref": "#/components/schemas/PaymentsResponse"
                 }
               }
             }
           },
-          "404": {
-            "description": "Payment Method does not exist in records"
+          "400": {
+            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
+          },
+          {
+            "publishable_key": []
           }
         ]
       }
     },
-    "/payments": {
+    "/refunds": {
       "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Create",
-        "description": "Payments - Create\n\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",
+        "tags": ["Refunds"],
+        "summary": "Refunds - Create",
+        "description": "Refunds - Create\n\nTo create a refund against an already processed payment",
+        "operationId": "Create a Refund",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/PaymentsRequest"
+                "$ref": "#/components/schemas/RefundRequest"
               }
             }
           },
@@ -1080,11 +1272,11 @@
         },
         "responses": {
           "200": {
-            "description": "Payment created",
+            "description": "Refund created",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentsResponse"
+                  "$ref": "#/components/schemas/RefundResponse"
                 }
               }
             }
@@ -1093,7 +1285,6 @@
             "description": "Missing Mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
@@ -1101,35 +1292,17 @@
         ]
       }
     },
-    "/payments/list": {
+    "/refunds/list": {
       "get": {
-        "tags": ["Payments"],
-        "summary": "Payments - List",
-        "description": "Payments - List\n\nTo list the payments",
-        "operationId": "List all Payments",
+        "tags": ["Refunds"],
+        "summary": "Refunds - List",
+        "description": "Refunds - List\n\nTo list the refunds associated with a payment_id or with the merchant, if payment_id is not provided",
+        "operationId": "List all Refunds",
         "parameters": [
           {
-            "name": "customer_id",
-            "in": "query",
-            "description": "The identifier for the customer",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "starting_after",
-            "in": "query",
-            "description": "A cursor for use in pagination, fetch the next list after some object",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "ending_before",
+            "name": "payment_id",
             "in": "query",
-            "description": "A cursor for use in pagination, fetch the previous list before some object",
+            "description": "The identifier for the payment",
             "required": true,
             "schema": {
               "type": "string"
@@ -1148,7 +1321,7 @@
           {
             "name": "created",
             "in": "query",
-            "description": "The time at which payment is created",
+            "description": "The time at which refund is created",
             "required": true,
             "schema": {
               "type": "string",
@@ -1158,7 +1331,7 @@
           {
             "name": "created_lt",
             "in": "query",
-            "description": "Time less than the payment created time",
+            "description": "Time less than the refund created time",
             "required": true,
             "schema": {
               "type": "string",
@@ -1168,7 +1341,7 @@
           {
             "name": "created_gt",
             "in": "query",
-            "description": "Time greater than the payment created time",
+            "description": "Time greater than the refund created time",
             "required": true,
             "schema": {
               "type": "string",
@@ -1178,7 +1351,7 @@
           {
             "name": "created_lte",
             "in": "query",
-            "description": "Time less than or equals to the payment created time",
+            "description": "Time less than or equals to the refund created time",
             "required": true,
             "schema": {
               "type": "string",
@@ -1188,7 +1361,7 @@
           {
             "name": "created_gte",
             "in": "query",
-            "description": "Time greater than or equals to the payment created time",
+            "description": "Time greater than or equals to the refund created time",
             "required": true,
             "schema": {
               "type": "string",
@@ -1198,121 +1371,71 @@
         ],
         "responses": {
           "200": {
-            "description": "Received payment list"
-          },
-          "404": {
-            "description": "No payments found"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/payments/session_tokens": {
-      "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Session token",
-        "description": "Payments - Session token\n\nTo create the session object or to get session token for wallets",
-        "operationId": "Create Session tokens for a Payment",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/PaymentsSessionRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Payment session object created or session token was retrieved from wallets",
+            "description": "List of refunds",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentsSessionResponse"
+                  "$ref": "#/components/schemas/RefundListResponse"
                 }
               }
             }
-          },
-          "400": {
-            "description": "Missing mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
-            "publishable_key": []
+            "api_key": []
           }
         ]
       }
     },
-    "/payments/{payment_id}": {
+    "/refunds/{refund_id}": {
       "get": {
-        "tags": ["Payments"],
-        "summary": "Payments - Retrieve",
-        "description": "Payments - Retrieve\n\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",
+        "tags": ["Refunds"],
+        "summary": "Refunds - Retrieve (GET)",
+        "description": "Refunds - Retrieve (GET)\n\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",
         "parameters": [
           {
-            "name": "payment_id",
+            "name": "refund_id",
             "in": "path",
-            "description": "The identifier for payment",
+            "description": "The identifier for refund",
             "required": true,
             "schema": {
               "type": "string"
             }
           }
         ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/PaymentRetrieveBody"
-              }
-            }
-          },
-          "required": true
-        },
         "responses": {
           "200": {
-            "description": "Gets the payment with final status",
+            "description": "Refund retrieved",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentsResponse"
+                  "$ref": "#/components/schemas/RefundResponse"
                 }
               }
             }
           },
           "404": {
-            "description": "No payment found"
+            "description": "Refund does not exist in our records"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
-          },
-          {
-            "publishable_key": []
           }
         ]
       },
       "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Update",
-        "description": "Payments - Update\n\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",
+        "tags": ["Refunds"],
+        "summary": "Refunds - Update",
+        "description": "Refunds - Update\n\nTo update the properties of a Refund object. This may include attaching a reason for the refund or metadata fields",
+        "operationId": "Update a Refund",
         "parameters": [
           {
-            "name": "payment_id",
+            "name": "refund_id",
             "in": "path",
-            "description": "The identifier for payment",
+            "description": "The identifier for refund",
             "required": true,
             "schema": {
               "type": "string"
@@ -1323,7 +1446,7 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/PaymentsRequest"
+                "$ref": "#/components/schemas/RefundUpdateRequest"
               }
             }
           },
@@ -1331,1502 +1454,2577 @@
         },
         "responses": {
           "200": {
-            "description": "Payment updated",
+            "description": "Refund updated",
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/PaymentsResponse"
+                  "$ref": "#/components/schemas/RefundResponse"
                 }
               }
             }
           },
           "400": {
-            "description": "Missing mandatory fields"
+            "description": "Missing Mandatory fields"
           }
         },
-        "deprecated": false,
         "security": [
           {
             "api_key": []
-          },
-          {
-            "publishable_key": []
           }
         ]
       }
-    },
-    "/payments/{payment_id}/cancel": {
-      "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Cancel",
-        "description": "Payments - Cancel\n\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",
-        "parameters": [
+    }
+  },
+  "components": {
+    "schemas": {
+      "AcceptanceType": {
+        "type": "string",
+        "enum": ["online", "offline"]
+      },
+      "AcceptedCountries": {
+        "oneOf": [
           {
-            "name": "payment_id",
-            "in": "path",
-            "description": "The identifier for payment",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/PaymentsCancelRequest"
+            "type": "object",
+            "required": ["type", "list"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["enable_only"]
+              },
+              "list": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/CountryAlpha2"
+                }
               }
             }
           },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Payment canceled"
-          },
-          "400": {
-            "description": "Missing mandatory fields"
-          }
-        },
-        "deprecated": false,
-        "security": [
           {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/payments/{payment_id}/capture": {
-      "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Capture",
-        "description": "Payments - Capture\n\nTo capture the funds for an uncaptured payment",
-        "operationId": "Capture a Payment",
-        "parameters": [
+            "type": "object",
+            "required": ["type", "list"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["disable_only"]
+              },
+              "list": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/CountryAlpha2"
+                }
+              }
+            }
+          },
           {
-            "name": "payment_id",
-            "in": "path",
-            "description": "The identifier for payment",
-            "required": true,
-            "schema": {
-              "type": "string"
+            "type": "object",
+            "required": ["type"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["all_accepted"]
+              }
             }
           }
         ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/PaymentsCaptureRequest"
+        "discriminator": {
+          "propertyName": "type"
+        }
+      },
+      "AcceptedCurrencies": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["type", "list"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["enable_only"]
+              },
+              "list": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/Currency"
+                }
               }
             }
           },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Payment captured",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PaymentsResponse"
+          {
+            "type": "object",
+            "required": ["type", "list"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["disable_only"]
+              },
+              "list": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/Currency"
                 }
               }
             }
           },
-          "400": {
-            "description": "Missing mandatory fields"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/payments/{payment_id}/confirm": {
-      "post": {
-        "tags": ["Payments"],
-        "summary": "Payments - Confirm",
-        "description": "Payments - Confirm\n\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",
-        "parameters": [
           {
-            "name": "payment_id",
-            "in": "path",
-            "description": "The identifier for payment",
-            "required": true,
-            "schema": {
-              "type": "string"
+            "type": "object",
+            "required": ["type"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["all_accepted"]
+              }
             }
           }
         ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/PaymentsRequest"
+        "discriminator": {
+          "propertyName": "type"
+        }
+      },
+      "Address": {
+        "type": "object",
+        "properties": {
+          "address": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AddressDetails"
               }
-            }
+            ],
+            "nullable": true
           },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Payment confirmed",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/PaymentsResponse"
-                }
+          "phone": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PhoneDetails"
               }
-            }
-          },
-          "400": {
-            "description": "Missing mandatory fields"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          },
-          {
-            "publishable_key": []
+            ],
+            "nullable": true
           }
-        ]
-      }
-    },
-    "/refunds": {
-      "post": {
-        "tags": ["Refunds"],
-        "summary": "Refunds - Create",
-        "description": "Refunds - Create\n\nTo create a refund against an already processed payment",
-        "operationId": "Create a Refund",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/RefundRequest"
-              }
-            }
+        }
+      },
+      "AddressDetails": {
+        "type": "object",
+        "properties": {
+          "city": {
+            "type": "string",
+            "description": "The address city",
+            "example": "New York",
+            "nullable": true,
+            "maxLength": 50
           },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Refund created",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/RefundResponse"
-                }
+          "country": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CountryAlpha2"
               }
-            }
+            ],
+            "nullable": true
           },
-          "400": {
-            "description": "Missing Mandatory fields"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/refunds/list": {
-      "get": {
-        "tags": ["Refunds"],
-        "summary": "Refunds - List",
-        "description": "Refunds - List\n\nTo list the refunds associated with a payment_id or with the merchant, if payment_id is not provided",
-        "operationId": "List all Refunds",
-        "parameters": [
-          {
-            "name": "payment_id",
-            "in": "query",
-            "description": "The identifier for the payment",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
+          "line1": {
+            "type": "string",
+            "description": "The first line of the address",
+            "example": "123, King Street",
+            "nullable": true,
+            "maxLength": 200
           },
-          {
-            "name": "limit",
-            "in": "query",
-            "description": "Limit on the number of objects to return",
-            "required": true,
-            "schema": {
-              "type": "integer",
-              "format": "int64"
-            }
+          "line2": {
+            "type": "string",
+            "description": "The second line of the address",
+            "example": "Powelson Avenue",
+            "nullable": true,
+            "maxLength": 50
           },
-          {
-            "name": "created",
-            "in": "query",
-            "description": "The time at which refund is created",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "date-time"
-            }
+          "line3": {
+            "type": "string",
+            "description": "The third line of the address",
+            "example": "Bridgewater",
+            "nullable": true,
+            "maxLength": 50
           },
-          {
-            "name": "created_lt",
-            "in": "query",
-            "description": "Time less than the refund created time",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "date-time"
-            }
+          "zip": {
+            "type": "string",
+            "description": "The zip/postal code for the address",
+            "example": "08807",
+            "nullable": true,
+            "maxLength": 50
           },
-          {
-            "name": "created_gt",
-            "in": "query",
-            "description": "Time greater than the refund created time",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "date-time"
-            }
+          "state": {
+            "type": "string",
+            "description": "The address state",
+            "example": "New York",
+            "nullable": true
           },
-          {
-            "name": "created_lte",
-            "in": "query",
-            "description": "Time less than or equals to the refund created time",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "date-time"
-            }
+          "first_name": {
+            "type": "string",
+            "description": "The first name for the address",
+            "example": "John",
+            "nullable": true,
+            "maxLength": 255
           },
-          {
-            "name": "created_gte",
-            "in": "query",
-            "description": "Time greater than or equals to the refund created time",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "date-time"
-            }
+          "last_name": {
+            "type": "string",
+            "description": "The last name for the address",
+            "example": "Doe",
+            "nullable": true,
+            "maxLength": 255
           }
-        ],
-        "responses": {
-          "200": {
-            "description": "List of refunds",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/RefundListResponse"
-                }
-              }
-            }
+        }
+      },
+      "AliPayRedirection": {
+        "type": "object"
+      },
+      "AmountInfo": {
+        "type": "object",
+        "required": ["label", "type", "amount"],
+        "properties": {
+          "label": {
+            "type": "string",
+            "description": "The label must be the name of the merchant."
           },
-          "404": {
-            "description": "Refund does not exist in our records"
+          "type": {
+            "type": "string",
+            "description": "A value that indicates whether the line item(Ex: total, tax, discount, or grand total) is final or pending."
+          },
+          "amount": {
+            "type": "string",
+            "description": "The total amount for the payment"
           }
-        },
-        "deprecated": false,
-        "security": [
+        }
+      },
+      "ApiKeyExpiration": {
+        "oneOf": [
           {
-            "api_key": []
-          }
-        ]
-      }
-    },
-    "/refunds/{refund_id}": {
-      "get": {
-        "tags": ["Refunds"],
-        "summary": "Refunds - Retrieve",
-        "description": "Refunds - Retrieve\n\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",
-        "parameters": [
+            "type": "string",
+            "enum": ["never"]
+          },
           {
-            "name": "refund_id",
-            "in": "path",
-            "description": "The identifier for refund",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
+            "type": "string",
+            "format": "date-time"
           }
+        ]
+      },
+      "ApplePayPaymentRequest": {
+        "type": "object",
+        "required": [
+          "country_code",
+          "currency_code",
+          "total",
+          "merchant_capabilities",
+          "supported_networks",
+          "merchant_identifier"
         ],
-        "responses": {
-          "200": {
-            "description": "Refund retrieved",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/RefundResponse"
-                }
-              }
-            }
+        "properties": {
+          "country_code": {
+            "$ref": "#/components/schemas/CountryAlpha2"
           },
-          "404": {
-            "description": "Refund does not exist in our records"
+          "currency_code": {
+            "type": "string",
+            "description": "The code for currency"
+          },
+          "total": {
+            "$ref": "#/components/schemas/AmountInfo"
+          },
+          "merchant_capabilities": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "The list of merchant capabilities(ex: whether capable of 3ds or no-3ds)"
+          },
+          "supported_networks": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "The list of supported networks"
+          },
+          "merchant_identifier": {
+            "type": "string"
           }
-        },
-        "deprecated": false,
-        "security": [
+        }
+      },
+      "ApplePaySessionResponse": {
+        "type": "object",
+        "required": [
+          "epoch_timestamp",
+          "expires_at",
+          "merchant_session_identifier",
+          "nonce",
+          "merchant_identifier",
+          "domain_name",
+          "display_name",
+          "signature",
+          "operational_analytics_identifier",
+          "retries",
+          "psp_id"
+        ],
+        "properties": {
+          "epoch_timestamp": {
+            "type": "integer",
+            "format": "int64",
+            "description": "Timestamp at which session is requested",
+            "minimum": 0.0
+          },
+          "expires_at": {
+            "type": "integer",
+            "format": "int64",
+            "description": "Timestamp at which session expires",
+            "minimum": 0.0
+          },
+          "merchant_session_identifier": {
+            "type": "string",
+            "description": "The identifier for the merchant session"
+          },
+          "nonce": {
+            "type": "string",
+            "description": "Apple pay generated unique ID (UUID) value"
+          },
+          "merchant_identifier": {
+            "type": "string",
+            "description": "The identifier for the merchant"
+          },
+          "domain_name": {
+            "type": "string",
+            "description": "The domain name of the merchant which is registered in Apple Pay"
+          },
+          "display_name": {
+            "type": "string",
+            "description": "The name to be displayed on Apple Pay button"
+          },
+          "signature": {
+            "type": "string",
+            "description": "A string which represents the properties of a payment"
+          },
+          "operational_analytics_identifier": {
+            "type": "string",
+            "description": "The identifier for the operational analytics"
+          },
+          "retries": {
+            "type": "integer",
+            "format": "int32",
+            "description": "The number of retries to get the session response",
+            "minimum": 0.0
+          },
+          "psp_id": {
+            "type": "string",
+            "description": "The identifier for the connector transaction"
+          }
+        }
+      },
+      "ApplePayWalletData": {
+        "type": "object",
+        "required": [
+          "payment_data",
+          "payment_method",
+          "transaction_identifier"
+        ],
+        "properties": {
+          "payment_data": {
+            "type": "string",
+            "description": "The payment data of Apple pay"
+          },
+          "payment_method": {
+            "$ref": "#/components/schemas/ApplepayPaymentMethod"
+          },
+          "transaction_identifier": {
+            "type": "string",
+            "description": "The unique identifier for the transaction"
+          }
+        }
+      },
+      "ApplepayPaymentMethod": {
+        "type": "object",
+        "required": ["display_name", "network", "type"],
+        "properties": {
+          "display_name": {
+            "type": "string",
+            "description": "The name to be displayed on Apple Pay button"
+          },
+          "network": {
+            "type": "string",
+            "description": "The network of the Apple pay payment method"
+          },
+          "type": {
+            "type": "string",
+            "description": "The type of the payment method"
+          }
+        }
+      },
+      "ApplepaySessionTokenResponse": {
+        "type": "object",
+        "required": ["session_token_data", "payment_request_data", "connector"],
+        "properties": {
+          "session_token_data": {
+            "$ref": "#/components/schemas/ApplePaySessionResponse"
+          },
+          "payment_request_data": {
+            "$ref": "#/components/schemas/ApplePayPaymentRequest"
+          },
+          "connector": {
+            "type": "string"
+          }
+        }
+      },
+      "AuthenticationType": {
+        "type": "string",
+        "enum": ["three_ds", "no_three_ds"]
+      },
+      "BankDebitBilling": {
+        "type": "object",
+        "required": ["name", "email"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "The billing name for bank debits",
+            "example": "John Doe"
+          },
+          "email": {
+            "type": "string",
+            "description": "The billing email for bank debits",
+            "example": "example@example.com"
+          },
+          "address": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AddressDetails"
+              }
+            ],
+            "nullable": true
+          }
+        }
+      },
+      "BankDebitData": {
+        "oneOf": [
           {
-            "api_key": []
+            "type": "object",
+            "required": ["ach_bank_debit"],
+            "properties": {
+              "ach_bank_debit": {
+                "type": "object",
+                "description": "Payment Method data for Ach bank debit",
+                "required": [
+                  "billing_details",
+                  "account_number",
+                  "routing_number",
+                  "card_holder_name",
+                  "bank_account_holder_name"
+                ],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankDebitBilling"
+                  },
+                  "account_number": {
+                    "type": "string",
+                    "description": "Account number for ach bank debit payment",
+                    "example": "000123456789"
+                  },
+                  "routing_number": {
+                    "type": "string",
+                    "description": "Routing number for ach bank debit payment",
+                    "example": "110000000"
+                  },
+                  "card_holder_name": {
+                    "type": "string",
+                    "example": "John Test"
+                  },
+                  "bank_account_holder_name": {
+                    "type": "string",
+                    "example": "John Doe"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["sepa_bank_debit"],
+            "properties": {
+              "sepa_bank_debit": {
+                "type": "object",
+                "required": [
+                  "billing_details",
+                  "iban",
+                  "bank_account_holder_name"
+                ],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankDebitBilling"
+                  },
+                  "iban": {
+                    "type": "string",
+                    "description": "International bank account number (iban) for SEPA",
+                    "example": "DE89370400440532013000"
+                  },
+                  "bank_account_holder_name": {
+                    "type": "string",
+                    "description": "Owner name for bank debit",
+                    "example": "A. Schneider"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["becs_bank_debit"],
+            "properties": {
+              "becs_bank_debit": {
+                "type": "object",
+                "required": ["billing_details", "account_number", "bsb_number"],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankDebitBilling"
+                  },
+                  "account_number": {
+                    "type": "string",
+                    "description": "Account number for Becs payment method",
+                    "example": "000123456"
+                  },
+                  "bsb_number": {
+                    "type": "string",
+                    "description": "Bank-State-Branch (bsb) number",
+                    "example": "000000"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["bacs_bank_debit"],
+            "properties": {
+              "bacs_bank_debit": {
+                "type": "object",
+                "required": [
+                  "billing_details",
+                  "account_number",
+                  "sort_code",
+                  "bank_account_holder_name"
+                ],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankDebitBilling"
+                  },
+                  "account_number": {
+                    "type": "string",
+                    "description": "Account number for Bacs payment method",
+                    "example": "00012345"
+                  },
+                  "sort_code": {
+                    "type": "string",
+                    "description": "Sort code for Bacs payment method",
+                    "example": "108800"
+                  },
+                  "bank_account_holder_name": {
+                    "type": "string",
+                    "description": "holder name for bank debit",
+                    "example": "A. Schneider"
+                  }
+                }
+              }
+            }
           }
         ]
       },
-      "post": {
-        "tags": ["Refunds"],
-        "summary": "Refunds - Update",
-        "description": "Refunds - Update\n\nTo update the properties of a Refund object. This may include attaching a reason for the refund or metadata fields",
-        "operationId": "Update a Refund",
-        "parameters": [
-          {
-            "name": "refund_id",
-            "in": "path",
-            "description": "The identifier for refund",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
+      "BankNames": {
+        "type": "string",
+        "description": "Name of banks supported by Hyperswitch",
+        "enum": [
+          "american_express",
+          "bank_of_america",
+          "barclays",
+          "BLIK - PSP",
+          "capital_one",
+          "chase",
+          "citi",
+          "discover",
+          "navy_federal_credit_union",
+          "pentagon_federal_credit_union",
+          "synchrony_bank",
+          "wells_fargo",
+          "abn_amro",
+          "asn_bank",
+          "bunq",
+          "handelsbanken",
+          "ing",
+          "knab",
+          "moneyou",
+          "rabobank",
+          "regiobank",
+          "revolut",
+          "sns_bank",
+          "triodos_bank",
+          "van_lanschot",
+          "arzte_und_apotheker_bank",
+          "austrian_anadi_bank_ag",
+          "bank_austria",
+          "bank99_ag",
+          "bankhaus_carl_spangler",
+          "bankhaus_schelhammer_und_schattera_ag",
+          "Bank Millennium",
+          "Bank PEKAO S.A.",
+          "bawag_psk_ag",
+          "bks_bank_ag",
+          "brull_kallmus_bank_ag",
+          "btv_vier_lander_bank",
+          "capital_bank_grawe_gruppe_ag",
+          "Česká spořitelna",
+          "dolomitenbank",
+          "easybank_ag",
+          "ePlatby VÚB",
+          "erste_bank_und_sparkassen",
+          "friesland_bank",
+          "hypo_alpeadriabank_international_ag",
+          "hypo_noe_lb_fur_niederosterreich_u_wien",
+          "hypo_oberosterreich_salzburg_steiermark",
+          "hypo_tirol_bank_ag",
+          "hypo_vorarlberg_bank_ag",
+          "hypo_bank_burgenland_aktiengesellschaft",
+          "Komercní banka",
+          "mBank - mTransfer",
+          "marchfelder_bank",
+          "oberbank_ag",
+          "osterreichische_arzte_und_apothekerbank",
+          "Pay with ING",
+          "Płacę z iPKO",
+          "Płatność online kartą płatniczą",
+          "posojilnica_bank_e_gen",
+          "Poštová banka",
+          "raiffeisen_bankengruppe_osterreich",
+          "schelhammer_capital_bank_ag",
+          "schoellerbank_ag",
+          "sparda_bank_wien",
+          "sporo_pay",
+          "Santander-Przelew24",
+          "tatra_pay",
+          "viamo",
+          "volksbank_gruppe",
+          "volkskreditbank_ag",
+          "vr_bank_braunau",
+          "Pay with Alior Bank",
+          "Banki Spółdzielcze",
+          "Pay with Inteligo",
+          "BNP Paribas Poland",
+          "Bank Nowy S.A.",
+          "Credit Agricole",
+          "Pay with BOŚ",
+          "Pay with CitiHandlowy",
+          "Pay with Plus Bank",
+          "Toyota Bank",
+          "velo_bank",
+          "e-transfer Pocztowy24",
+          "plus_bank",
+          "etransfer_pocztowy24",
+          "banki_spbdzielcze",
+          "bank_nowy_bfg_sa",
+          "getin_bank",
+          "blik",
+          "noble_pay",
+          "idea_bank",
+          "envelo_bank",
+          "nest_przelew",
+          "mbank_mtransfer",
+          "inteligo",
+          "pbac_z_ipko",
+          "bnp_paribas",
+          "bank_pekao_sa",
+          "volkswagen_bank",
+          "alior_bank",
+          "boz"
+        ]
+      },
+      "BankRedirectBilling": {
+        "type": "object",
+        "required": ["billing_name", "email"],
+        "properties": {
+          "billing_name": {
+            "type": "string",
+            "description": "The name for which billing is issued",
+            "example": "John Doe"
+          },
+          "email": {
+            "type": "string",
+            "description": "The billing email for bank redirect",
+            "example": "example@example.com"
+          }
+        }
+      },
+      "BankRedirectData": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["bancontact_card"],
+            "properties": {
+              "bancontact_card": {
+                "type": "object",
+                "required": [
+                  "card_number",
+                  "card_exp_month",
+                  "card_exp_year",
+                  "card_holder_name"
+                ],
+                "properties": {
+                  "card_number": {
+                    "type": "string",
+                    "description": "The card number",
+                    "example": "4242424242424242"
+                  },
+                  "card_exp_month": {
+                    "type": "string",
+                    "description": "The card's expiry month",
+                    "example": "24"
+                  },
+                  "card_exp_year": {
+                    "type": "string",
+                    "description": "The card's expiry year",
+                    "example": "24"
+                  },
+                  "card_holder_name": {
+                    "type": "string",
+                    "description": "The card holder's name",
+                    "example": "John Test"
+                  },
+                  "billing_details": {
+                    "allOf": [
+                      {
+                        "$ref": "#/components/schemas/BankRedirectBilling"
+                      }
+                    ],
+                    "nullable": true
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["blik"],
+            "properties": {
+              "blik": {
+                "type": "object",
+                "required": ["blik_code"],
+                "properties": {
+                  "blik_code": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["eps"],
+            "properties": {
+              "eps": {
+                "type": "object",
+                "required": ["billing_details", "bank_name"],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankRedirectBilling"
+                  },
+                  "bank_name": {
+                    "$ref": "#/components/schemas/BankNames"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["giropay"],
+            "properties": {
+              "giropay": {
+                "type": "object",
+                "required": ["billing_details"],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankRedirectBilling"
+                  },
+                  "bank_account_bic": {
+                    "type": "string",
+                    "description": "Bank account details for Giropay\nBank account bic code",
+                    "nullable": true
+                  },
+                  "bank_account_iban": {
+                    "type": "string",
+                    "description": "Bank account iban",
+                    "nullable": true
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["ideal"],
+            "properties": {
+              "ideal": {
+                "type": "object",
+                "required": ["billing_details", "bank_name"],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankRedirectBilling"
+                  },
+                  "bank_name": {
+                    "$ref": "#/components/schemas/BankNames"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["interac"],
+            "properties": {
+              "interac": {
+                "type": "object",
+                "required": ["country", "email"],
+                "properties": {
+                  "country": {
+                    "$ref": "#/components/schemas/CountryAlpha2"
+                  },
+                  "email": {
+                    "type": "string",
+                    "example": "john.doe@example.com"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["online_banking_czech_republic"],
+            "properties": {
+              "online_banking_czech_republic": {
+                "type": "object",
+                "required": ["issuer"],
+                "properties": {
+                  "issuer": {
+                    "$ref": "#/components/schemas/BankNames"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["online_banking_finland"],
+            "properties": {
+              "online_banking_finland": {
+                "type": "object",
+                "properties": {
+                  "email": {
+                    "type": "string",
+                    "nullable": true
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["online_banking_poland"],
+            "properties": {
+              "online_banking_poland": {
+                "type": "object",
+                "required": ["issuer"],
+                "properties": {
+                  "issuer": {
+                    "$ref": "#/components/schemas/BankNames"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["online_banking_slovakia"],
+            "properties": {
+              "online_banking_slovakia": {
+                "type": "object",
+                "required": ["issuer"],
+                "properties": {
+                  "issuer": {
+                    "$ref": "#/components/schemas/BankNames"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["przelewy24"],
+            "properties": {
+              "przelewy24": {
+                "type": "object",
+                "required": ["billing_details"],
+                "properties": {
+                  "bank_name": {
+                    "allOf": [
+                      {
+                        "$ref": "#/components/schemas/BankNames"
+                      }
+                    ],
+                    "nullable": true
+                  },
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankRedirectBilling"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["sofort"],
+            "properties": {
+              "sofort": {
+                "type": "object",
+                "required": [
+                  "billing_details",
+                  "country",
+                  "preferred_language"
+                ],
+                "properties": {
+                  "billing_details": {
+                    "$ref": "#/components/schemas/BankRedirectBilling"
+                  },
+                  "country": {
+                    "$ref": "#/components/schemas/CountryAlpha2"
+                  },
+                  "preferred_language": {
+                    "type": "string",
+                    "description": "The preferred language",
+                    "example": "en"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["swish"],
+            "properties": {
+              "swish": {
+                "type": "object"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["trustly"],
+            "properties": {
+              "trustly": {
+                "type": "object",
+                "required": ["country"],
+                "properties": {
+                  "country": {
+                    "$ref": "#/components/schemas/CountryAlpha2"
+                  }
+                }
+              }
+            }
+          }
+        ]
+      },
+      "CaptureMethod": {
+        "type": "string",
+        "enum": ["automatic", "manual", "manual_multiple", "scheduled"]
+      },
+      "Card": {
+        "type": "object",
+        "required": [
+          "card_number",
+          "card_exp_month",
+          "card_exp_year",
+          "card_holder_name",
+          "card_cvc"
+        ],
+        "properties": {
+          "card_number": {
+            "type": "string",
+            "description": "The card number",
+            "example": "4242424242424242"
+          },
+          "card_exp_month": {
+            "type": "string",
+            "description": "The card's expiry month",
+            "example": "24"
+          },
+          "card_exp_year": {
+            "type": "string",
+            "description": "The card's expiry year",
+            "example": "24"
+          },
+          "card_holder_name": {
+            "type": "string",
+            "description": "The card holder's name",
+            "example": "John Test"
+          },
+          "card_cvc": {
+            "type": "string",
+            "description": "The CVC number for the card",
+            "example": "242"
+          },
+          "card_issuer": {
+            "type": "string",
+            "description": "The name of the issuer of card",
+            "example": "chase",
+            "nullable": true
+          },
+          "card_network": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CardNetwork"
+              }
+            ],
+            "nullable": true
+          }
+        }
+      },
+      "CardDetail": {
+        "type": "object",
+        "required": [
+          "card_number",
+          "card_exp_month",
+          "card_exp_year",
+          "card_holder_name"
+        ],
+        "properties": {
+          "card_number": {
+            "type": "string",
+            "description": "Card Number",
+            "example": "4111111145551142"
+          },
+          "card_exp_month": {
+            "type": "string",
+            "description": "Card Expiry Month",
+            "example": "10"
+          },
+          "card_exp_year": {
+            "type": "string",
+            "description": "Card Expiry Year",
+            "example": "25"
+          },
+          "card_holder_name": {
+            "type": "string",
+            "description": "Card Holder Name",
+            "example": "John Doe"
+          }
+        }
+      },
+      "CardDetailFromLocker": {
+        "type": "object",
+        "properties": {
+          "scheme": {
+            "type": "string",
+            "nullable": true
+          },
+          "issuer_country": {
+            "type": "string",
+            "nullable": true
+          },
+          "last4_digits": {
+            "type": "string",
+            "nullable": true
+          },
+          "expiry_month": {
+            "type": "string",
+            "nullable": true
+          },
+          "expiry_year": {
+            "type": "string",
+            "nullable": true
+          },
+          "card_token": {
+            "type": "string",
+            "nullable": true
+          },
+          "card_holder_name": {
+            "type": "string",
+            "nullable": true
+          },
+          "card_fingerprint": {
+            "type": "string",
+            "nullable": true
+          }
+        }
+      },
+      "CardNetwork": {
+        "type": "string",
+        "enum": [
+          "Visa",
+          "Mastercard",
+          "AmericanExpress",
+          "JCB",
+          "DinersClub",
+          "Discover",
+          "CartesBancaires",
+          "UnionPay",
+          "Interac",
+          "RuPay",
+          "Maestro"
+        ]
+      },
+      "Connector": {
+        "type": "string",
+        "enum": [
+          "aci",
+          "adyen",
+          "airwallex",
+          "applepay",
+          "authorizedotnet",
+          "bitpay",
+          "bluesnap",
+          "braintree",
+          "checkout",
+          "coinbase",
+          "cybersource",
+          "dummy",
+          "iatapay",
+          "dummyconnector1",
+          "dummyconnector2",
+          "dummyconnector3",
+          "opennode",
+          "bambora",
+          "dlocal",
+          "fiserv",
+          "forte",
+          "globalpay",
+          "klarna",
+          "mollie",
+          "multisafepay",
+          "nexinets",
+          "nmi",
+          "nuvei",
+          "paypal",
+          "payu",
+          "rapyd",
+          "shift4",
+          "stripe",
+          "trustpay",
+          "worldline",
+          "worldpay",
+          "zen"
+        ]
+      },
+      "ConnectorType": {
+        "type": "string",
+        "enum": [
+          "payment_processor",
+          "payment_vas",
+          "fin_operations",
+          "fiz_operations",
+          "networks",
+          "banking_entities",
+          "non_banking_finance"
+        ]
+      },
+      "CountryAlpha2": {
+        "type": "string",
+        "enum": [
+          "AF",
+          "AX",
+          "AL",
+          "DZ",
+          "AS",
+          "AD",
+          "AO",
+          "AI",
+          "AQ",
+          "AG",
+          "AR",
+          "AM",
+          "AW",
+          "AU",
+          "AT",
+          "AZ",
+          "BS",
+          "BH",
+          "BD",
+          "BB",
+          "BY",
+          "BE",
+          "BZ",
+          "BJ",
+          "BM",
+          "BT",
+          "BO",
+          "BQ",
+          "BA",
+          "BW",
+          "BV",
+          "BR",
+          "IO",
+          "BN",
+          "BG",
+          "BF",
+          "BI",
+          "KH",
+          "CM",
+          "CA",
+          "CV",
+          "KY",
+          "CF",
+          "TD",
+          "CL",
+          "CN",
+          "CX",
+          "CC",
+          "CO",
+          "KM",
+          "CG",
+          "CD",
+          "CK",
+          "CR",
+          "CI",
+          "HR",
+          "CU",
+          "CW",
+          "CY",
+          "CZ",
+          "DK",
+          "DJ",
+          "DM",
+          "DO",
+          "EC",
+          "EG",
+          "SV",
+          "GQ",
+          "ER",
+          "EE",
+          "ET",
+          "FK",
+          "FO",
+          "FJ",
+          "FI",
+          "FR",
+          "GF",
+          "PF",
+          "TF",
+          "GA",
+          "GM",
+          "GE",
+          "DE",
+          "GH",
+          "GI",
+          "GR",
+          "GL",
+          "GD",
+          "GP",
+          "GU",
+          "GT",
+          "GG",
+          "GN",
+          "GW",
+          "GY",
+          "HT",
+          "HM",
+          "VA",
+          "HN",
+          "HK",
+          "HU",
+          "IS",
+          "IN",
+          "ID",
+          "IR",
+          "IQ",
+          "IE",
+          "IM",
+          "IL",
+          "IT",
+          "JM",
+          "JP",
+          "JE",
+          "JO",
+          "KZ",
+          "KE",
+          "KI",
+          "KP",
+          "KR",
+          "KW",
+          "KG",
+          "LA",
+          "LV",
+          "LB",
+          "LS",
+          "LR",
+          "LY",
+          "LI",
+          "LT",
+          "LU",
+          "MO",
+          "MK",
+          "MG",
+          "MW",
+          "MY",
+          "MV",
+          "ML",
+          "MT",
+          "MH",
+          "MQ",
+          "MR",
+          "MU",
+          "YT",
+          "MX",
+          "FM",
+          "MD",
+          "MC",
+          "MN",
+          "ME",
+          "MS",
+          "MA",
+          "MZ",
+          "MM",
+          "NA",
+          "NR",
+          "NP",
+          "NL",
+          "NC",
+          "NZ",
+          "NI",
+          "NE",
+          "NG",
+          "NU",
+          "NF",
+          "MP",
+          "NO",
+          "OM",
+          "PK",
+          "PW",
+          "PS",
+          "PA",
+          "PG",
+          "PY",
+          "PE",
+          "PH",
+          "PN",
+          "PL",
+          "PT",
+          "PR",
+          "QA",
+          "RE",
+          "RO",
+          "RU",
+          "RW",
+          "BL",
+          "SH",
+          "KN",
+          "LC",
+          "MF",
+          "PM",
+          "VC",
+          "WS",
+          "SM",
+          "ST",
+          "SA",
+          "SN",
+          "RS",
+          "SC",
+          "SL",
+          "SG",
+          "SX",
+          "SK",
+          "SI",
+          "SB",
+          "SO",
+          "ZA",
+          "GS",
+          "SS",
+          "ES",
+          "LK",
+          "SD",
+          "SR",
+          "SJ",
+          "SZ",
+          "SE",
+          "CH",
+          "SY",
+          "TW",
+          "TJ",
+          "TZ",
+          "TH",
+          "TL",
+          "TG",
+          "TK",
+          "TO",
+          "TT",
+          "TN",
+          "TR",
+          "TM",
+          "TC",
+          "TV",
+          "UG",
+          "UA",
+          "AE",
+          "GB",
+          "UM",
+          "UY",
+          "UZ",
+          "VU",
+          "VE",
+          "VN",
+          "VG",
+          "VI",
+          "WF",
+          "EH",
+          "YE",
+          "ZM",
+          "ZW",
+          "US"
+        ]
+      },
+      "CreateApiKeyRequest": {
+        "type": "object",
+        "description": "The request body for creating an API Key.",
+        "required": ["name", "expiration"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "A unique name for the API Key to help you identify it.",
+            "example": "Sandbox integration key",
+            "maxLength": 64
+          },
+          "description": {
+            "type": "string",
+            "description": "A description to provide more context about the API Key.",
+            "example": "Key used by our developers to integrate with the sandbox environment",
+            "nullable": true,
+            "maxLength": 256
+          },
+          "expiration": {
+            "$ref": "#/components/schemas/ApiKeyExpiration"
+          }
+        }
+      },
+      "CreateApiKeyResponse": {
+        "type": "object",
+        "description": "The response body for creating an API Key.",
+        "required": [
+          "key_id",
+          "merchant_id",
+          "name",
+          "api_key",
+          "created",
+          "expiration"
+        ],
+        "properties": {
+          "key_id": {
+            "type": "string",
+            "description": "The identifier for the API Key.",
+            "example": "5hEEqkgJUyuxgSKGArHA4mWSnX",
+            "maxLength": 64
+          },
+          "merchant_id": {
+            "type": "string",
+            "description": "The identifier for the Merchant Account.",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 64
+          },
+          "name": {
+            "type": "string",
+            "description": "The unique name for the API Key to help you identify it.",
+            "example": "Sandbox integration key",
+            "maxLength": 64
+          },
+          "description": {
+            "type": "string",
+            "description": "The description to provide more context about the API Key.",
+            "example": "Key used by our developers to integrate with the sandbox environment",
+            "nullable": true,
+            "maxLength": 256
+          },
+          "api_key": {
+            "type": "string",
+            "description": "The plaintext API Key used for server-side API access. Ensure you store the API Key\nsecurely as you will not be able to see it again.",
+            "maxLength": 128
+          },
+          "created": {
+            "type": "string",
+            "format": "date-time",
+            "description": "The time at which the API Key was created.",
+            "example": "2022-09-10T10:11:12Z"
+          },
+          "expiration": {
+            "$ref": "#/components/schemas/ApiKeyExpiration"
+          }
+        }
+      },
+      "CryptoData": {
+        "type": "object"
+      },
+      "Currency": {
+        "type": "string",
+        "enum": [
+          "AED",
+          "ALL",
+          "AMD",
+          "ANG",
+          "ARS",
+          "AUD",
+          "AWG",
+          "AZN",
+          "BBD",
+          "BDT",
+          "BHD",
+          "BMD",
+          "BND",
+          "BOB",
+          "BRL",
+          "BSD",
+          "BWP",
+          "BZD",
+          "CAD",
+          "CHF",
+          "CNY",
+          "COP",
+          "CRC",
+          "CUP",
+          "CZK",
+          "DKK",
+          "DOP",
+          "DZD",
+          "EGP",
+          "ETB",
+          "EUR",
+          "FJD",
+          "GBP",
+          "GHS",
+          "GIP",
+          "GMD",
+          "GTQ",
+          "GYD",
+          "HKD",
+          "HNL",
+          "HRK",
+          "HTG",
+          "HUF",
+          "IDR",
+          "ILS",
+          "INR",
+          "JMD",
+          "JOD",
+          "JPY",
+          "KES",
+          "KGS",
+          "KHR",
+          "KRW",
+          "KWD",
+          "KYD",
+          "KZT",
+          "LAK",
+          "LBP",
+          "LKR",
+          "LRD",
+          "LSL",
+          "MAD",
+          "MDL",
+          "MKD",
+          "MMK",
+          "MNT",
+          "MOP",
+          "MUR",
+          "MVR",
+          "MWK",
+          "MXN",
+          "MYR",
+          "NAD",
+          "NGN",
+          "NIO",
+          "NOK",
+          "NPR",
+          "NZD",
+          "OMR",
+          "PEN",
+          "PGK",
+          "PHP",
+          "PKR",
+          "PLN",
+          "QAR",
+          "RUB",
+          "SAR",
+          "SCR",
+          "SEK",
+          "SGD",
+          "SLL",
+          "SOS",
+          "SSP",
+          "SVC",
+          "SZL",
+          "THB",
+          "TTD",
+          "TWD",
+          "TZS",
+          "USD",
+          "UYU",
+          "UZS",
+          "YER",
+          "ZAR"
+        ]
+      },
+      "CustomerAcceptance": {
+        "type": "object",
+        "required": ["acceptance_type"],
+        "properties": {
+          "acceptance_type": {
+            "$ref": "#/components/schemas/AcceptanceType"
+          },
+          "accepted_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Specifying when the customer acceptance was provided",
+            "example": "2022-09-10T10:11:12Z",
+            "nullable": true
+          },
+          "online": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/OnlineMandate"
+              }
+            ],
+            "nullable": true
           }
+        }
+      },
+      "CustomerDeleteResponse": {
+        "type": "object",
+        "required": [
+          "customer_id",
+          "customer_deleted",
+          "address_deleted",
+          "payment_methods_deleted"
         ],
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/RefundUpdateRequest"
-              }
-            }
+        "properties": {
+          "customer_id": {
+            "type": "string",
+            "description": "The identifier for the customer object",
+            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
           },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Refund updated",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/RefundResponse"
-                }
-              }
-            }
+          "customer_deleted": {
+            "type": "boolean",
+            "description": "Whether customer was deleted or not",
+            "example": false
           },
-          "400": {
-            "description": "Missing Mandatory fields"
-          }
-        },
-        "deprecated": false,
-        "security": [
-          {
-            "api_key": []
+          "address_deleted": {
+            "type": "boolean",
+            "description": "Whether address was deleted or not",
+            "example": false
+          },
+          "payment_methods_deleted": {
+            "type": "boolean",
+            "description": "Whether payment methods deleted or not",
+            "example": false
           }
-        ]
-      }
-    }
-  },
-  "components": {
-    "schemas": {
-      "AcceptanceType": {
-        "type": "string",
-        "enum": ["online", "offline"]
+        }
       },
-      "AcceptedCountries": {
+      "CustomerPaymentMethod": {
         "type": "object",
-        "description": "List of enabled and disabled countries, empty in case all countries are enabled",
-        "required": ["type", "list"],
+        "required": [
+          "payment_token",
+          "customer_id",
+          "payment_method",
+          "recurring_enabled",
+          "installment_payment_enabled"
+        ],
         "properties": {
-          "type": {
+          "payment_token": {
             "type": "string",
-            "description": "Type of accepted countries (disable_only, enable_only)"
+            "description": "Token for payment method in temporary card locker which gets refreshed often",
+            "example": "7ebf443f-a050-4067-84e5-e6f6d4800aef"
+          },
+          "customer_id": {
+            "type": "string",
+            "description": "The unique identifier of the customer.",
+            "example": "cus_meowerunwiuwiwqw"
+          },
+          "payment_method": {
+            "$ref": "#/components/schemas/PaymentMethodType"
+          },
+          "payment_method_type": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PaymentMethodType"
+              }
+            ],
+            "nullable": true
+          },
+          "payment_method_issuer": {
+            "type": "string",
+            "description": "The name of the bank/ provider issuing the payment method to the end user",
+            "example": "Citibank",
+            "nullable": true
+          },
+          "payment_method_issuer_code": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PaymentMethodIssuerCode"
+              }
+            ],
+            "nullable": true
           },
-          "list": {
+          "recurring_enabled": {
+            "type": "boolean",
+            "description": "Indicates whether the payment method is eligible for recurring payments",
+            "example": true
+          },
+          "installment_payment_enabled": {
+            "type": "boolean",
+            "description": "Indicates whether the payment method is eligible for installment payments",
+            "example": true
+          },
+          "payment_experience": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/Country"
+              "$ref": "#/components/schemas/PaymentExperience"
             },
-            "description": "List of countries of the provided type",
-            "example": ["FR", "DE", "IN"],
+            "description": "Type of payment experience enabled with the connector",
+            "example": ["redirect_to_url"],
             "nullable": true
           },
-        "discriminator": {
-          "propertyName": "type"
+          "card": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CardDetailFromLocker"
+              }
+            ],
+            "nullable": true
+          },
+          "metadata": {
+            "type": "object",
+            "description": "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.",
+            "nullable": true
+          },
+          "created": {
+            "type": "string",
+            "format": "date-time",
+            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
+            "example": "2023-01-18T11:04:09.922Z",
+            "nullable": true
+          }
         }
       },
-      "AcceptedCurrencies": {
+      "CustomerPaymentMethodsListResponse": {
         "type": "object",
-        "description": "List of enabled and disabled currencies, empty in case all currencies are enabled",
-        "required": ["type", "list"],
+        "required": ["customer_payment_methods"],
         "properties": {
-          "type": {
-            "type": "string",
-            "description": "type of accepted currencies (disable_only, enable_only)"
-          },
-          "list": {
+          "customer_payment_methods": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/Currency"
+              "$ref": "#/components/schemas/CustomerPaymentMethod"
             },
-            "description": "List of currencies of the provided type",
-            "example": ["USD", "EUR"],
-            "nullable": true
+            "description": "List of payment methods for customer"
           }
-        ],
-        "discriminator": {
-          "propertyName": "type"
         }
       },
-      "Address": {
+      "CustomerRequest": {
         "type": "object",
-        "required": ["address", "phone"],
+        "description": "The customer details",
         "properties": {
-          "address": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/AddressDetails"
-              }
-            ],
+          "customer_id": {
+            "type": "string",
+            "description": "The identifier for the customer object. If not provided the customer ID will be autogenerated.",
+            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
+          },
+          "name": {
+            "type": "string",
+            "description": "The customer's name",
+            "example": "Jon Test",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "email": {
+            "type": "string",
+            "description": "The customer's email address",
+            "example": "JonTest@test.com",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "phone": {
+            "type": "string",
+            "description": "The customer's phone number",
+            "example": "9999999999",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "description": {
+            "type": "string",
+            "description": "An arbitrary string that you can attach to a customer object.",
+            "example": "First Customer",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "phone_country_code": {
+            "type": "string",
+            "description": "The country code for the customer phone number",
+            "example": "+65",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "address": {
+            "type": "object",
+            "description": "The address for the customer",
             "nullable": true
           },
-          "phone": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/PhoneDetails"
-              }
-            ],
+          "metadata": {
+            "type": "object",
+            "description": "You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\ncharacters long. Metadata is useful for storing additional, structured information on an\nobject.",
             "nullable": true
           }
         }
       },
-      "AddressDetails": {
+      "CustomerResponse": {
         "type": "object",
-        "required": [
-          "city",
-          "country",
-          "line1",
-          "line2",
-          "line3",
-          "zip",
-          "state",
-          "first_name",
-          "last_name"
-        ],
+        "required": ["customer_id", "created_at"],
         "properties": {
-          "city": {
+          "customer_id": {
             "type": "string",
-            "description": "The address city",
-            "example": "New York",
-            "nullable": true,
-            "maxLength": 50
+            "description": "The identifier for the customer object. If not provided the customer ID will be autogenerated.",
+            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
           },
-          "country": {
+          "name": {
             "type": "string",
-            "description": "The two-letter ISO country code for the address",
-            "example": "US",
+            "description": "The customer's name",
+            "example": "Jon Test",
             "nullable": true,
-            "maxLength": 2,
-            "minLength": 2
+            "maxLength": 255
           },
-          "line1": {
+          "email": {
             "type": "string",
-            "description": "The first line of the address",
-            "example": "123, King Street",
+            "description": "The customer's email address",
+            "example": "JonTest@test.com",
             "nullable": true,
-            "maxLength": 200
+            "maxLength": 255
           },
-          "line2": {
+          "phone": {
             "type": "string",
-            "description": "The second line of the address",
-            "example": "Powelson Avenue",
+            "description": "The customer's phone number",
+            "example": "9999999999",
             "nullable": true,
-            "maxLength": 50
+            "maxLength": 255
           },
-          "line3": {
+          "phone_country_code": {
             "type": "string",
-            "description": "The third line of the address",
-            "example": "Bridgewater",
+            "description": "The country code for the customer phone number",
+            "example": "+65",
             "nullable": true,
-            "maxLength": 50
+            "maxLength": 255
           },
-          "zip": {
+          "description": {
             "type": "string",
-            "description": "The zip/postal code for the address",
-            "example": "08807",
+            "description": "An arbitrary string that you can attach to a customer object.",
+            "example": "First Customer",
             "nullable": true,
-            "maxLength": 50
+            "maxLength": 255
           },
-          "state": {
-            "type": "string",
-            "description": "The address state",
-            "example": "New York",
+          "address": {
+            "type": "object",
+            "description": "The address for the customer",
             "nullable": true
           },
-          "first_name": {
+          "created_at": {
             "type": "string",
-            "description": "The first name for the address",
-            "example": "John",
-            "nullable": true,
-            "maxLength": 255
+            "format": "date-time",
+            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
+            "example": "2023-01-18T11:04:09.922Z"
           },
-          "last_name": {
-            "type": "string",
-            "description": "The last name for the address",
-            "example": "Doe",
-            "nullable": true,
-            "maxLength": 255
+          "metadata": {
+            "type": "object",
+            "description": "You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\ncharacters long. Metadata is useful for storing additional, structured information on an\nobject.",
+            "nullable": true
           }
         }
       },
-      "AmountInfo": {
+      "DisputeResponse": {
         "type": "object",
-        "required": ["label", "type", "amount"],
+        "required": [
+          "dispute_id",
+          "payment_id",
+          "attempt_id",
+          "amount",
+          "currency",
+          "dispute_stage",
+          "dispute_status",
+          "connector",
+          "connector_status",
+          "connector_dispute_id",
+          "created_at"
+        ],
         "properties": {
-          "label": {
+          "dispute_id": {
             "type": "string",
-            "description": "The label must be the name of the merchant."
+            "description": "The identifier for dispute"
           },
-          "type": {
+          "payment_id": {
             "type": "string",
-            "description": "A value that indicates whether the line item(Ex: total, tax, discount, or grand total) is final or pending."
+            "description": "The identifier for payment_intent"
           },
-          "amount": {
-            "type": "string",
-            "description": "The total amount for the payment"
-          }
-        }
-      },
-      "ApiKeyExpiration": {
-        "oneOf": [
-          {
+          "attempt_id": {
             "type": "string",
-            "enum": ["never"]
+            "description": "The identifier for payment_attempt"
           },
-          {
+          "amount": {
             "type": "string",
-            "format": "date-time"
-          }
-        ]
-      },
-      "ApplePayPaymentRequest": {
-        "type": "object",
-        "required": [
-          "country_code",
-          "currency_code",
-          "total",
-          "merchant_capabilities",
-          "supported_networks"
-        ],
-        "properties": {
-          "country_code": {
-            "$ref": "#/components/schemas/Country"
+            "description": "The dispute amount"
           },
-          "currency_code": {
+          "currency": {
             "type": "string",
-            "description": "The code for currency"
-          },
-          "total": {
-            "$ref": "#/components/schemas/AmountInfo"
-          },
-          "merchant_capabilities": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "The list of merchant capabilities(ex: whether capable of 3ds or no-3ds)"
+            "description": "The three-letter ISO currency code"
           },
-          "supported_networks": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "The list of supported networks"
-          }
-        }
-      },
-      "ApplePaySessionResponse": {
-        "type": "object",
-        "required": [
-          "epoch_timestamp",
-          "expires_at",
-          "merchant_session_identifier",
-          "nonce",
-          "merchant_identifier",
-          "domain_name",
-          "display_name",
-          "signature",
-          "operational_analytics_identifier",
-          "retries",
-          "psp_id"
-        ],
-        "properties": {
-          "epoch_timestamp": {
-            "type": "integer",
-            "format": "int64",
-            "description": "Timestamp at which session is requested"
+          "dispute_stage": {
+            "$ref": "#/components/schemas/DisputeStage"
           },
-          "expires_at": {
-            "type": "integer",
-            "format": "int64",
-            "description": "Timestamp at which session expires"
+          "dispute_status": {
+            "$ref": "#/components/schemas/DisputeStatus"
           },
-          "merchant_session_identifier": {
+          "connector": {
             "type": "string",
-            "description": "The identifier for the merchant session"
+            "description": "connector to which dispute is associated with"
           },
-          "nonce": {
+          "connector_status": {
             "type": "string",
-            "description": "Apple pay generated unique ID (UUID) value"
+            "description": "Status of the dispute sent by connector"
           },
-          "merchant_identifier": {
+          "connector_dispute_id": {
             "type": "string",
-            "description": "The identifier for the merchant"
+            "description": "Dispute id sent by connector"
           },
-          "domain_name": {
+          "connector_reason": {
             "type": "string",
-            "description": "The domain name of the merchant which is registered in Apple Pay"
+            "description": "Reason of dispute sent by connector",
+            "nullable": true
           },
-          "display_name": {
+          "connector_reason_code": {
             "type": "string",
-            "description": "The name to be displayed on Apple Pay button"
+            "description": "Reason code of dispute sent by connector",
+            "nullable": true
           },
-          "signature": {
+          "challenge_required_by": {
             "type": "string",
-            "description": "A string which represents the properties of a payment"
+            "format": "date-time",
+            "description": "Evidence deadline of dispute sent by connector",
+            "nullable": true
           },
-          "operational_analytics_identifier": {
+          "connector_created_at": {
             "type": "string",
-            "description": "The identifier for the operational analytics"
+            "format": "date-time",
+            "description": "Dispute created time sent by connector",
+            "nullable": true
           },
-          "retries": {
-            "type": "integer",
-            "format": "int32",
-            "description": "The number of retries to get the session response"
+          "connector_updated_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Dispute updated time sent by connector",
+            "nullable": true
           },
-          "psp_id": {
+          "created_at": {
             "type": "string",
-            "description": "The identifier for the connector transaction"
+            "format": "date-time",
+            "description": "Time at which dispute is received"
           }
         }
       },
-      "ApplePayWalletData": {
+      "DisputeResponsePaymentsRetrieve": {
         "type": "object",
         "required": [
-          "payment_data",
-          "payment_method",
-          "transaction_identifier"
+          "dispute_id",
+          "dispute_stage",
+          "dispute_status",
+          "connector_status",
+          "connector_dispute_id",
+          "created_at"
         ],
         "properties": {
-          "payment_data": {
+          "dispute_id": {
             "type": "string",
-            "description": "The payment data of Apple pay"
+            "description": "The identifier for dispute"
           },
-          "payment_method": {
-            "$ref": "#/components/schemas/ApplepayPaymentMethod"
+          "dispute_stage": {
+            "$ref": "#/components/schemas/DisputeStage"
           },
-          "transaction_identifier": {
+          "dispute_status": {
+            "$ref": "#/components/schemas/DisputeStatus"
+          },
+          "connector_status": {
             "type": "string",
-            "description": "The unique identifier for the transaction"
-          }
-        }
-      },
-      "ApplepayPaymentMethod": {
-        "type": "object",
-        "required": ["display_name", "network", "type"],
-        "properties": {
-          "display_name": {
+            "description": "Status of the dispute sent by connector"
+          },
+          "connector_dispute_id": {
             "type": "string",
-            "description": "The name to be displayed on Apple Pay button"
+            "description": "Dispute id sent by connector"
           },
-          "network": {
+          "connector_reason": {
             "type": "string",
-            "description": "The network of the Apple pay payment method"
+            "description": "Reason of dispute sent by connector",
+            "nullable": true
           },
-          "type": {
+          "connector_reason_code": {
             "type": "string",
-            "description": "The type of the payment method"
-          }
-        }
-      },
-      "ApplepaySessionTokenResponse": {
-        "type": "object",
-        "required": ["session_token_data", "payment_request_data"],
-        "properties": {
-          "session_token_data": {
-            "$ref": "#/components/schemas/ApplePaySessionResponse"
+            "description": "Reason code of dispute sent by connector",
+            "nullable": true
           },
-          "payment_request_data": {
-            "$ref": "#/components/schemas/ApplePayPaymentRequest"
+          "challenge_required_by": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Evidence deadline of dispute sent by connector",
+            "nullable": true
+          },
+          "connector_created_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Dispute created time sent by connector",
+            "nullable": true
+          },
+          "connector_updated_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Dispute updated time sent by connector",
+            "nullable": true
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Time at which dispute is received"
           }
         }
       },
-      "AuthenticationType": {
+      "DisputeStage": {
         "type": "string",
-        "enum": ["three_ds", "no_three_ds"]
+        "enum": ["pre_dispute", "dispute", "pre_arbitration"]
       },
-      "BankNames": {
+      "DisputeStatus": {
         "type": "string",
-        "description": "Name of banks supported by Hyperswitch",
         "enum": [
-          "american_express",
-          "bank_of_america",
-          "barclays",
-          "capital_one",
-          "chase",
-          "citi",
-          "discover",
-          "navy_federal_credit_union",
-          "pentagon_federal_credit_union",
-          "synchrony_bank",
-          "wells_fargo",
-          "abn_amro",
-          "asn_bank",
-          "bunq",
-          "handelsbanken",
-          "ing",
-          "knab",
-          "moneyou",
-          "rabobank",
-          "regiobank",
-          "revolut",
-          "sns_bank",
-          "triodos_bank",
-          "van_lanschot",
-          "arzte_und_apotheker_bank",
-          "austrian_anadi_bank_ag",
-          "bank_austria",
-          "bank99_ag",
-          "bankhaus_carl_spangler",
-          "bankhaus_schelhammer_und_schattera_ag",
-          "bawag_psk_ag",
-          "bks_bank_ag",
-          "brull_kallmus_bank_ag",
-          "btv_vier_lander_bank",
-          "capital_bank_grawe_gruppe_ag",
-          "dolomitenbank",
-          "easybank_ag",
-          "erste_bank_und_sparkassen",
-          "hypo_alpeadriabank_international_ag",
-          "hypo_noe_lb_fur_niederosterreich_u_wien",
-          "hypo_oberosterreich_salzburg_steiermark",
-          "hypo_tirol_bank_ag",
-          "hypo_vorarlberg_bank_ag",
-          "hypo_bank_burgenland_aktiengesellschaft",
-          "marchfelder_bank",
-          "oberbank_ag",
-          "osterreichische_arzte_und_apothekerbank",
-          "posojilnica_bank_e_gen",
-          "raiffeisen_bankengruppe_osterreich",
-          "schelhammer_capital_bank_ag",
-          "schoellerbank_ag",
-          "sparda_bank_wien",
-          "volksbank_gruppe",
-          "volkskreditbank_ag",
-          "vr_bank_braunau"
+          "dispute_opened",
+          "dispute_expired",
+          "dispute_accepted",
+          "dispute_cancelled",
+          "dispute_challenged",
+          "dispute_won",
+          "dispute_lost"
         ]
       },
-      "BankRedirectBilling": {
+      "FrmAction": {
+        "type": "string",
+        "enum": ["cancel_txn", "auto_refund", "manual_review"]
+      },
+      "FrmConfigs": {
         "type": "object",
-        "required": ["billing_name"],
+        "description": "Details of FrmConfigs are mentioned here... it should be passed in payment connector create api call, and stored in merchant_connector_table",
+        "required": ["frm_action", "frm_preferred_flow_type"],
         "properties": {
-          "billing_name": {
-            "type": "string",
-            "description": "The name for which billing is issued",
-            "example": "John Doe"
-          }
-        }
-      },
-      "BankRedirectData": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["eps"],
-            "properties": {
-              "eps": {
-                "type": "object",
-                "required": ["billing_details", "bank_name"],
-                "properties": {
-                  "billing_details": {
-                    "$ref": "#/components/schemas/BankRedirectBilling"
-                  },
-                  "bank_name": {
-                    "$ref": "#/components/schemas/BankNames"
-                  }
-                }
-              }
-            }
+          "frm_enabled_pms": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
           },
-          {
-            "type": "object",
-            "required": ["giropay"],
-            "properties": {
-              "giropay": {
-                "type": "object",
-                "required": ["billing_details"],
-                "properties": {
-                  "billing_details": {
-                    "$ref": "#/components/schemas/BankRedirectBilling"
-                  }
-                }
-              }
-            }
+          "frm_enabled_pm_types": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
           },
-          {
-            "type": "object",
-            "required": ["ideal"],
-            "properties": {
-              "ideal": {
-                "type": "object",
-                "required": ["billing_details", "bank_name"],
-                "properties": {
-                  "billing_details": {
-                    "$ref": "#/components/schemas/BankRedirectBilling"
-                  },
-                  "bank_name": {
-                    "$ref": "#/components/schemas/BankNames"
-                  }
-                }
-              }
-            }
+          "frm_enabled_gateways": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
           },
-          {
-            "type": "object",
-            "required": ["sofort"],
-            "properties": {
-              "sofort": {
-                "type": "object",
-                "required": ["country", "preferred_language"],
-                "properties": {
-                  "country": {
-                    "$ref": "#/components/schemas/Country"
-                  },
-                  "preferred_language": {
-                    "type": "string",
-                    "description": "The preferred language",
-                    "example": "en"
-                  }
-                }
-              }
-            }
+          "frm_action": {
+            "$ref": "#/components/schemas/FrmAction"
+          },
+          "frm_preferred_flow_type": {
+            "$ref": "#/components/schemas/FrmPreferredFlowTypes"
           }
-        ]
+        }
       },
-      "CaptureMethod": {
+      "FrmPreferredFlowTypes": {
         "type": "string",
-        "enum": ["automatic", "manual", "manual_multiple", "scheduled"]
+        "enum": ["pre", "post"]
       },
-      "Card": {
+      "FutureUsage": {
+        "type": "string",
+        "enum": ["off_session", "on_session"]
+      },
+      "GooglePayPaymentMethodInfo": {
         "type": "object",
-        "required": [
-          "card_number",
-          "card_exp_month",
-          "card_exp_year",
-          "card_holder_name",
-          "card_cvc",
-          "card_issuer",
-          "card_network"
-        ],
+        "required": ["card_network", "card_details"],
         "properties": {
-          "card_number": {
+          "card_network": {
             "type": "string",
-            "description": "The card number",
-            "example": "4242424242424242"
+            "description": "The name of the card network"
           },
-          "card_exp_month": {
+          "card_details": {
             "type": "string",
-            "description": "The card's expiry month",
-            "example": "24"
-          },
-          "card_exp_year": {
+            "description": "The details of the card"
+          }
+        }
+      },
+      "GooglePayWalletData": {
+        "type": "object",
+        "required": ["type", "description", "info", "tokenization_data"],
+        "properties": {
+          "type": {
             "type": "string",
-            "description": "The card's expiry year",
-            "example": "24"
+            "description": "The type of payment method"
           },
-          "card_holder_name": {
+          "description": {
             "type": "string",
-            "description": "The card holder's name",
-            "example": "John Test"
+            "description": "User-facing message to describe the payment method that funds this transaction."
           },
-          "card_cvc": {
-            "type": "string",
-            "description": "The CVC number for the card",
-            "example": "242"
+          "info": {
+            "$ref": "#/components/schemas/GooglePayPaymentMethodInfo"
           },
-          "card_issuer": {
+          "tokenization_data": {
+            "$ref": "#/components/schemas/GpayTokenizationData"
+          }
+        }
+      },
+      "GpayAllowedMethodsParameters": {
+        "type": "object",
+        "required": ["allowed_auth_methods", "allowed_card_networks"],
+        "properties": {
+          "allowed_auth_methods": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "The list of allowed auth methods (ex: 3DS, No3DS, PAN_ONLY etc)"
+          },
+          "allowed_card_networks": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "The list of allowed card networks (ex: AMEX,JCB etc)"
+          }
+        }
+      },
+      "GpayAllowedPaymentMethods": {
+        "type": "object",
+        "required": ["type", "parameters", "tokenization_specification"],
+        "properties": {
+          "type": {
             "type": "string",
-            "description": "The name of the issuer of card",
-            "example": "chase",
-            "nullable": true
+            "description": "The type of payment method"
           },
-          "card_network": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/CardNetwork"
-              }
-            ],
-            "nullable": true
+          "parameters": {
+            "$ref": "#/components/schemas/GpayAllowedMethodsParameters"
+          },
+          "tokenization_specification": {
+            "$ref": "#/components/schemas/GpayTokenizationSpecification"
+          }
+        }
+      },
+      "GpayMerchantInfo": {
+        "type": "object",
+        "required": ["merchant_name"],
+        "properties": {
+          "merchant_name": {
+            "type": "string",
+            "description": "The name of the merchant"
           }
         }
       },
-      "CardDetail": {
+      "GpaySessionTokenResponse": {
         "type": "object",
         "required": [
-          "card_number",
-          "card_exp_month",
-          "card_exp_year",
-          "card_holder_name"
+          "merchant_info",
+          "allowed_payment_methods",
+          "transaction_info",
+          "connector"
         ],
         "properties": {
-          "card_number": {
-            "type": "string",
-            "description": "Card Number",
-            "example": "4111111145551142"
+          "merchant_info": {
+            "$ref": "#/components/schemas/GpayMerchantInfo"
           },
-          "card_exp_month": {
-            "type": "string",
-            "description": "Card Expiry Month",
-            "example": "10"
+          "allowed_payment_methods": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/GpayAllowedPaymentMethods"
+            },
+            "description": "List of the allowed payment meythods"
           },
-          "card_exp_year": {
-            "type": "string",
-            "description": "Card Expiry Year",
-            "example": "25"
+          "transaction_info": {
+            "$ref": "#/components/schemas/GpayTransactionInfo"
           },
-          "card_holder_name": {
-            "type": "string",
-            "description": "Card Holder Name",
-            "example": "John Doe"
+          "connector": {
+            "type": "string"
           }
         }
       },
-      "CardDetailFromLocker": {
+      "GpayTokenParameters": {
         "type": "object",
-        "required": [
-          "scheme",
-          "issuer_country",
-          "last4_digits",
-          "expiry_month",
-          "expiry_year",
-          "card_token",
-          "card_holder_name",
-          "card_fingerprint"
-        ],
+        "required": ["gateway"],
         "properties": {
-          "scheme": {
+          "gateway": {
             "type": "string",
-            "nullable": true
+            "description": "The name of the connector"
           },
-          "issuer_country": {
+          "gateway_merchant_id": {
             "type": "string",
+            "description": "The merchant ID registered in the connector associated",
             "nullable": true
           },
-          "last4_digits": {
+          "stripe:version": {
             "type": "string",
             "nullable": true
           },
-          "expiry_month": {
+          "stripe:publishableKey": {
             "type": "string",
             "nullable": true
-          },
-          "expiry_year": {
+          }
+        }
+      },
+      "GpayTokenizationData": {
+        "type": "object",
+        "required": ["type", "token"],
+        "properties": {
+          "type": {
             "type": "string",
-            "nullable": true
+            "description": "The type of the token"
           },
-          "card_token": {
+          "token": {
             "type": "string",
-            "nullable": true
-          },
-          "card_holder_name": {
+            "description": "Token generated for the wallet"
+          }
+        }
+      },
+      "GpayTokenizationSpecification": {
+        "type": "object",
+        "required": ["type", "parameters"],
+        "properties": {
+          "type": {
             "type": "string",
-            "nullable": true
+            "description": "The token specification type(ex: PAYMENT_GATEWAY)"
           },
-          "card_fingerprint": {
-            "type": "string",
-            "nullable": true
+          "parameters": {
+            "$ref": "#/components/schemas/GpayTokenParameters"
           }
         }
       },
-      "CardNetwork": {
-        "type": "string",
-        "enum": [
-          "Visa",
-          "Mastercard",
-          "AmericanExpress",
-          "JCB",
-          "DinersClub",
-          "Discover",
-          "CartesBancaires",
-          "UnionPay",
-          "Interac",
-          "RuPay",
-          "Maestro"
-        ]
-      },
-      "Connector": {
-        "type": "string",
-        "enum": [
-          "aci",
-          "adyen",
-          "airwallex",
-          "applepay",
-          "authorizedotnet",
-          "bluesnap",
-          "braintree",
-          "checkout",
-          "cybersource",
-          "dummy",
-          "bambora",
-          "dlocal",
-          "fiserv",
-          "globalpay",
-          "klarna",
-          "mollie",
-          "multisafepay",
-          "nuvei",
-          "payu",
-          "rapyd",
-          "shift4",
-          "stripe",
-          "worldline",
-          "worldpay",
-          "trustpay"
-        ]
-      },
-      "ConnectorType": {
-        "type": "string",
-        "enum": [
-          "payment_processor",
-          "payment_vas",
-          "fin_operations",
-          "fiz_operations",
-          "networks",
-          "banking_entities",
-          "non_banking_finance"
-        ]
-      },
-      "Country": {
-        "type": "string",
-        "enum": [
-          "AL",
-          "DZ",
-          "AS",
-          "AO",
-          "AG",
-          "AR",
-          "AU",
-          "AT",
-          "AZ",
-          "BH",
-          "BY",
-          "BE",
-          "BR",
-          "BG",
-          "CA",
-          "CL",
-          "CO",
-          "HR",
-          "CZ",
-          "DK",
-          "DO",
-          "EG",
-          "EE",
-          "FI",
-          "FR",
-          "DE",
-          "GR",
-          "HK",
-          "HU",
-          "IN",
-          "ID",
-          "IE",
-          "IL",
-          "IT",
-          "JP",
-          "JO",
-          "KZ",
-          "KE",
-          "KW",
-          "LV",
-          "LB",
-          "LT",
-          "LU",
-          "MY",
-          "MX",
-          "NL",
-          "NZ",
-          "NO",
-          "OM",
-          "PK",
-          "PA",
-          "PE",
-          "PH",
-          "PL",
-          "PT",
-          "QA",
-          "RO",
-          "RU",
-          "SA",
-          "SG",
-          "SK",
-          "ZA",
-          "ES",
-          "LK",
-          "SE",
-          "CH",
-          "TW",
-          "TH",
-          "TR",
-          "UA",
-          "AE",
-          "GB",
-          "UY",
-          "VN",
-          "CN",
-          "MO",
-          "AM",
-          "CY",
-          "FO",
-          "GE",
-          "GL",
-          "GG",
-          "IS",
-          "IM",
-          "JE",
-          "LI",
-          "MT",
-          "MD",
-          "MC",
-          "ME",
-          "SM",
-          "RS",
-          "SI",
-          "CR",
-          "PS",
-          "UM",
-          "US"
+      "GpayTransactionInfo": {
+        "type": "object",
+        "required": [
+          "country_code",
+          "currency_code",
+          "total_price_status",
+          "total_price"
+        ],
+        "properties": {
+          "country_code": {
+            "$ref": "#/components/schemas/CountryAlpha2"
+          },
+          "currency_code": {
+            "type": "string",
+            "description": "The currency code"
+          },
+          "total_price_status": {
+            "type": "string",
+            "description": "The total price status (ex: 'FINAL')"
+          },
+          "total_price": {
+            "type": "integer",
+            "format": "int64",
+            "description": "The total price"
+          }
+        }
+      },
+      "IntentStatus": {
+        "type": "string",
+        "enum": [
+          "succeeded",
+          "failed",
+          "cancelled",
+          "processing",
+          "requires_customer_action",
+          "requires_merchant_action",
+          "requires_payment_method",
+          "requires_confirmation",
+          "requires_capture"
         ]
       },
-      "CreateApiKeyRequest": {
+      "KlarnaSessionTokenResponse": {
         "type": "object",
-        "description": "The request body for creating an API Key.",
-        "required": ["name", "description", "expiration"],
+        "required": ["session_token", "session_id"],
         "properties": {
-          "name": {
+          "session_token": {
             "type": "string",
-            "description": "A unique name for the API Key to help you identify it.",
-            "example": "Sandbox integration key",
-            "maxLength": 64
+            "description": "The session token for Klarna"
           },
-          "description": {
+          "session_id": {
             "type": "string",
-            "description": "A description to provide more context about the API Key.",
-            "example": "Key used by our developers to integrate with the sandbox environment",
-            "nullable": true,
-            "maxLength": 256
+            "description": "The identifier for the session"
+          }
+        }
+      },
+      "MandateAmountData": {
+        "type": "object",
+        "required": ["amount", "currency"],
+        "properties": {
+          "amount": {
+            "type": "integer",
+            "format": "int64",
+            "description": "The maximum amount to be debited for the mandate transaction",
+            "example": 6540
           },
-          "expiration": {
-            "$ref": "#/components/schemas/ApiKeyExpiration"
+          "currency": {
+            "$ref": "#/components/schemas/Currency"
+          },
+          "start_date": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Specifying start date of the mandate",
+            "example": "2022-09-10T00:00:00Z",
+            "nullable": true
+          },
+          "end_date": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Specifying end date of the mandate",
+            "example": "2023-09-10T23:59:59Z",
+            "nullable": true
+          },
+          "metadata": {
+            "type": "object",
+            "description": "Additional details required by mandate",
+            "nullable": true
           }
         }
       },
-      "CreateApiKeyResponse": {
+      "MandateCardDetails": {
         "type": "object",
-        "description": "The response body for creating an API Key.",
-        "required": [
-          "key_id",
-          "merchant_id",
-          "name",
-          "description",
-          "api_key",
-          "created",
-          "expiration"
-        ],
         "properties": {
-          "key_id": {
+          "last4_digits": {
             "type": "string",
-            "description": "The identifier for the API Key.",
-            "example": "5hEEqkgJUyuxgSKGArHA4mWSnX",
-            "maxLength": 64
+            "description": "The last 4 digits of card",
+            "nullable": true
           },
-          "merchant_id": {
+          "card_exp_month": {
             "type": "string",
-            "description": "The identifier for the Merchant Account.",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 64
+            "description": "The expiry month of card",
+            "nullable": true
           },
-          "name": {
+          "card_exp_year": {
             "type": "string",
-            "description": "The unique name for the API Key to help you identify it.",
-            "example": "Sandbox integration key",
-            "maxLength": 64
+            "description": "The expiry year of card",
+            "nullable": true
           },
-          "description": {
+          "card_holder_name": {
             "type": "string",
-            "description": "The description to provide more context about the API Key.",
-            "example": "Key used by our developers to integrate with the sandbox environment",
-            "nullable": true,
-            "maxLength": 256
+            "description": "The card holder name",
+            "nullable": true
           },
-          "api_key": {
+          "card_token": {
             "type": "string",
-            "description": "The plaintext API Key used for server-side API access. Ensure you store the API Key\nsecurely as you will not be able to see it again.",
-            "maxLength": 128
+            "description": "The token from card locker",
+            "nullable": true
           },
-          "created": {
+          "scheme": {
             "type": "string",
-            "format": "date-time",
-            "description": "The time at which the API Key was created.",
-            "example": "2022-09-10T10:11:12Z"
+            "description": "The card scheme network for the particular card",
+            "nullable": true
           },
-          "expiration": {
-            "$ref": "#/components/schemas/ApiKeyExpiration"
+          "issuer_country": {
+            "type": "string",
+            "description": "The country code in in which the card was issued",
+            "nullable": true
+          },
+          "card_fingerprint": {
+            "type": "string",
+            "description": "A unique identifier alias to identify a particular card",
+            "nullable": true
           }
         }
       },
-      "Currency": {
-        "type": "string",
-        "enum": [
-          "AED",
-          "ALL",
-          "AMD",
-          "ANG",
-          "ARS",
-          "AUD",
-          "AWG",
-          "AZN",
-          "BBD",
-          "BDT",
-          "BHD",
-          "BMD",
-          "BND",
-          "BOB",
-          "BRL",
-          "BSD",
-          "BWP",
-          "BZD",
-          "CAD",
-          "CHF",
-          "CNY",
-          "COP",
-          "CRC",
-          "CUP",
-          "CZK",
-          "DKK",
-          "DOP",
-          "DZD",
-          "EGP",
-          "ETB",
-          "EUR",
-          "FJD",
-          "GBP",
-          "GHS",
-          "GIP",
-          "GMD",
-          "GTQ",
-          "GYD",
-          "HKD",
-          "HNL",
-          "HRK",
-          "HTG",
-          "HUF",
-          "IDR",
-          "ILS",
-          "INR",
-          "JMD",
-          "JOD",
-          "JPY",
-          "KES",
-          "KGS",
-          "KHR",
-          "KRW",
-          "KWD",
-          "KYD",
-          "KZT",
-          "LAK",
-          "LBP",
-          "LKR",
-          "LRD",
-          "LSL",
-          "MAD",
-          "MDL",
-          "MKD",
-          "MMK",
-          "MNT",
-          "MOP",
-          "MUR",
-          "MVR",
-          "MWK",
-          "MXN",
-          "MYR",
-          "NAD",
-          "NGN",
-          "NIO",
-          "NOK",
-          "NPR",
-          "NZD",
-          "OMR",
-          "PEN",
-          "PGK",
-          "PHP",
-          "PKR",
-          "PLN",
-          "QAR",
-          "RUB",
-          "SAR",
-          "SCR",
-          "SEK",
-          "SGD",
-          "SLL",
-          "SOS",
-          "SSP",
-          "SVC",
-          "SZL",
-          "THB",
-          "TTD",
-          "TWD",
-          "TZS",
-          "USD",
-          "UYU",
-          "UZS",
-          "YER",
-          "ZAR"
-        ]
+      "MandateData": {
+        "type": "object",
+        "required": ["customer_acceptance", "mandate_type"],
+        "properties": {
+          "customer_acceptance": {
+            "$ref": "#/components/schemas/CustomerAcceptance"
+          },
+          "mandate_type": {
+            "$ref": "#/components/schemas/MandateType"
+          }
+        }
       },
-      "CustomerAcceptance": {
+      "MandateResponse": {
         "type": "object",
-        "required": ["acceptance_type", "online"],
+        "required": [
+          "mandate_id",
+          "status",
+          "payment_method_id",
+          "payment_method"
+        ],
         "properties": {
-          "acceptance_type": {
-            "$ref": "#/components/schemas/AcceptanceType"
+          "mandate_id": {
+            "type": "string",
+            "description": "The identifier for mandate"
           },
-          "accepted_at": {
+          "status": {
+            "$ref": "#/components/schemas/MandateStatus"
+          },
+          "payment_method_id": {
             "type": "string",
-            "format": "date-time",
-            "description": "Specifying when the customer acceptance was provided",
-            "example": "2022-09-10T10:11:12Z",
+            "description": "The identifier for payment method"
+          },
+          "payment_method": {
+            "type": "string",
+            "description": "The payment method"
+          },
+          "card": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/MandateCardDetails"
+              }
+            ],
             "nullable": true
           },
-          "online": {
+          "customer_acceptance": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/OnlineMandate"
+                "$ref": "#/components/schemas/CustomerAcceptance"
               }
             ],
             "nullable": true
           }
         }
       },
-      "CustomerDeleteResponse": {
+      "MandateRevokedResponse": {
         "type": "object",
-        "required": [
-          "customer_id",
-          "customer_deleted",
-          "address_deleted",
-          "payment_methods_deleted"
-        ],
+        "required": ["mandate_id", "status"],
         "properties": {
-          "customer_id": {
+          "mandate_id": {
             "type": "string",
-            "description": "The identifier for the customer object",
-            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 255
-          },
-          "customer_deleted": {
-            "type": "boolean",
-            "description": "Whether customer was deleted or not",
-            "example": false
+            "description": "The identifier for mandate"
           },
-          "address_deleted": {
-            "type": "boolean",
-            "description": "Whether address was deleted or not",
-            "example": false
+          "status": {
+            "$ref": "#/components/schemas/MandateStatus"
+          }
+        }
+      },
+      "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"]
+      },
+      "MandateType": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["single_use"],
+            "properties": {
+              "single_use": {
+                "$ref": "#/components/schemas/MandateAmountData"
+              }
+            }
           },
-          "payment_methods_deleted": {
-            "type": "boolean",
-            "description": "Whether payment methods deleted or not",
-            "example": false
+          {
+            "type": "object",
+            "required": ["multi_use"],
+            "properties": {
+              "multi_use": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/MandateAmountData"
+                  }
+                ],
+                "nullable": true
+              }
+            }
+          }
+        ]
+      },
+      "MbWayRedirection": {
+        "type": "object",
+        "required": ["telephone_number"],
+        "properties": {
+          "telephone_number": {
+            "type": "string",
+            "description": "Telephone number of the shopper. Should be Portuguese phone number."
           }
         }
       },
-      "CustomerPaymentMethod": {
+      "MerchantAccountCreate": {
         "type": "object",
-        "required": [
-          "payment_token",
-          "customer_id",
-          "payment_method",
-          "payment_method_type",
-          "payment_method_issuer",
-          "payment_method_issuer_code",
-          "recurring_enabled",
-          "installment_payment_enabled",
-          "payment_experience",
-          "card",
-          "metadata"
-        ],
+        "required": ["merchant_id"],
         "properties": {
-          "payment_token": {
+          "merchant_id": {
             "type": "string",
-            "description": "Token for payment method in temporary card locker which gets refreshed often",
-            "example": "7ebf443f-a050-4067-84e5-e6f6d4800aef"
+            "description": "The identifier for the Merchant Account",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
           },
-          "customer_id": {
+          "merchant_name": {
             "type": "string",
-            "description": "The unique identifier of the customer.",
-            "example": "cus_meowerunwiuwiwqw"
-          },
-          "payment_method": {
-            "$ref": "#/components/schemas/PaymentMethodType"
+            "description": "Name of the Merchant Account",
+            "example": "NewAge Retailer",
+            "nullable": true
           },
-          "payment_method_type": {
+          "merchant_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PaymentMethodType"
+                "$ref": "#/components/schemas/MerchantDetails"
               }
             ],
             "nullable": true
           },
-          "payment_method_issuer": {
+          "return_url": {
             "type": "string",
-            "description": "The name of the bank/ provider issuing the payment method to the end user",
-            "example": "Citibank",
-            "nullable": true
+            "description": "The URL to redirect after the completion of the operation",
+            "example": "https://www.example.com/success",
+            "nullable": true,
+            "maxLength": 255
           },
-          "payment_method_issuer_code": {
+          "webhook_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PaymentMethodIssuerCode"
+                "$ref": "#/components/schemas/WebhookDetails"
               }
             ],
             "nullable": true
           },
-          "recurring_enabled": {
+          "routing_algorithm": {
+            "type": "object",
+            "description": "The routing algorithm to be used for routing payments to desired connectors",
+            "nullable": true
+          },
+          "sub_merchants_enabled": {
             "type": "boolean",
-            "description": "Indicates whether the payment method is eligible for recurring payments",
-            "example": true
+            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
           },
-          "installment_payment_enabled": {
+          "parent_merchant_id": {
+            "type": "string",
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": "xkkdf909012sdjki2dkh5sdf",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "enable_payment_response_hash": {
             "type": "boolean",
-            "description": "Indicates whether the payment method is eligible for installment payments",
-            "example": true
+            "description": "A boolean value to indicate if payment response hash needs to be enabled",
+            "default": false,
+            "example": true,
+            "nullable": true
           },
-          "payment_experience": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentExperience"
-            },
-            "description": "Type of payment experience enabled with the connector",
-            "example": ["redirect_to_url"],
+          "payment_response_hash_key": {
+            "type": "string",
+            "description": "Refers to the hash key used for payment response",
             "nullable": true
           },
-          "card": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/CardDetailFromLocker"
-              }
-            ],
+          "redirect_to_merchant_with_http_post": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
+            "default": false,
+            "example": true,
             "nullable": true
           },
           "metadata": {
@@ -2834,638 +4032,609 @@
             "description": "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.",
             "nullable": true
           },
-          "created": {
+          "publishable_key": {
             "type": "string",
-            "format": "date-time",
-            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
-            "example": "2023-01-18T11:04:09.922Z",
+            "description": "API key that will be used for server side API access",
+            "example": "AH3423bkjbkjdsfbkj",
             "nullable": true
-          }
-        }
-      },
-      "CustomerPaymentMethodsListResponse": {
-        "type": "object",
-        "required": ["customer_payment_methods"],
-        "properties": {
-          "customer_payment_methods": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/CustomerPaymentMethod"
-            },
-            "description": "List of payment methods for customer"
-          }
-        }
-      },
-      "CustomerRequest": {
-        "type": "object",
-        "description": "The customer details",
-        "required": [
-          "name",
-          "email",
-          "phone",
-          "description",
-          "phone_country_code",
-          "address",
-          "metadata"
-        ],
-        "properties": {
-          "customer_id": {
-            "type": "string",
-            "description": "The identifier for the customer object. If not provided the customer ID will be autogenerated.",
-            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 255
-          },
-          "name": {
-            "type": "string",
-            "description": "The customer's name",
-            "example": "Jon Test",
-            "nullable": true,
-            "maxLength": 255
           },
-          "email": {
+          "locker_id": {
             "type": "string",
-            "description": "The customer's email address",
-            "example": "JonTest@test.com",
-            "nullable": true,
-            "maxLength": 255
+            "description": "An identifier for the vault used to store payment method information.",
+            "example": "locker_abc123",
+            "nullable": true
           },
-          "phone": {
-            "type": "string",
-            "description": "The customer's phone number",
-            "example": "9999999999",
-            "nullable": true,
-            "maxLength": 255
+          "primary_business_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PrimaryBusinessDetails"
+              }
+            ],
+            "nullable": true
           },
-          "description": {
-            "type": "string",
-            "description": "An arbitrary string that you can attach to a customer object.",
-            "example": "First Customer",
+          "intent_fulfillment_time": {
+            "type": "integer",
+            "format": "int32",
+            "description": "Will be used to expire client secret after certain amount of time to be supplied in seconds\n(900) for 15 mins",
+            "example": 900,
             "nullable": true,
-            "maxLength": 255
-          },
-          "phone_country_code": {
+            "minimum": 0.0
+          }
+        }
+      },
+      "MerchantAccountDeleteResponse": {
+        "type": "object",
+        "required": ["merchant_id", "deleted"],
+        "properties": {
+          "merchant_id": {
             "type": "string",
-            "description": "The country code for the customer phone number",
-            "example": "+65",
-            "nullable": true,
+            "description": "The identifier for the Merchant Account",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
             "maxLength": 255
           },
-          "address": {
-            "type": "object",
-            "description": "The address for the customer",
-            "nullable": true
-          },
-          "metadata": {
-            "type": "object",
-            "description": "You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\ncharacters long. Metadata is useful for storing additional, structured information on an\nobject.",
-            "nullable": true
+          "deleted": {
+            "type": "boolean",
+            "description": "If the connector is deleted or not",
+            "example": false
           }
         }
       },
-      "CustomerResponse": {
+      "MerchantAccountResponse": {
         "type": "object",
         "required": [
-          "customer_id",
-          "name",
-          "email",
-          "phone",
-          "phone_country_code",
-          "description",
-          "address",
-          "created_at",
-          "metadata"
+          "merchant_id",
+          "enable_payment_response_hash",
+          "redirect_to_merchant_with_http_post",
+          "primary_business_details"
         ],
         "properties": {
-          "customer_id": {
+          "merchant_id": {
             "type": "string",
-            "description": "The identifier for the customer object. If not provided the customer ID will be autogenerated.",
-            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
+            "description": "The identifier for the Merchant Account",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
             "maxLength": 255
           },
-          "name": {
+          "merchant_name": {
             "type": "string",
-            "description": "The customer's name",
-            "example": "Jon Test",
-            "nullable": true,
-            "maxLength": 255
+            "description": "Name of the Merchant Account",
+            "example": "NewAge Retailer",
+            "nullable": true
           },
-          "email": {
+          "return_url": {
             "type": "string",
-            "description": "The customer's email address",
-            "example": "JonTest@test.com",
+            "description": "The URL to redirect after the completion of the operation",
+            "example": "https://www.example.com/success",
             "nullable": true,
             "maxLength": 255
           },
-          "phone": {
+          "enable_payment_response_hash": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if payment response hash needs to be enabled",
+            "default": false,
+            "example": true
+          },
+          "payment_response_hash_key": {
             "type": "string",
-            "description": "The customer's phone number",
-            "example": "9999999999",
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": "xkkdf909012sdjki2dkh5sdf",
             "nullable": true,
             "maxLength": 255
           },
-          "phone_country_code": {
+          "redirect_to_merchant_with_http_post": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
+            "default": false,
+            "example": true
+          },
+          "merchant_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/MerchantDetails"
+              }
+            ],
+            "nullable": true
+          },
+          "webhook_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/WebhookDetails"
+              }
+            ],
+            "nullable": true
+          },
+          "routing_algorithm": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/RoutingAlgorithm"
+              }
+            ],
+            "nullable": true
+          },
+          "sub_merchants_enabled": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
+          },
+          "parent_merchant_id": {
             "type": "string",
-            "description": "The country code for the customer phone number",
-            "example": "+65",
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": "xkkdf909012sdjki2dkh5sdf",
             "nullable": true,
             "maxLength": 255
           },
-          "description": {
+          "publishable_key": {
             "type": "string",
-            "description": "An arbitrary string that you can attach to a customer object.",
-            "example": "First Customer",
-            "nullable": true,
-            "maxLength": 255
+            "description": "API key that will be used for server side API access",
+            "example": "AH3423bkjbkjdsfbkj",
+            "nullable": true
           },
-          "address": {
+          "metadata": {
             "type": "object",
-            "description": "The address for the customer",
+            "description": "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.",
             "nullable": true
           },
-          "created_at": {
+          "locker_id": {
             "type": "string",
-            "format": "date-time",
-            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
-            "example": "2023-01-18T11:04:09.922Z"
+            "description": "An identifier for the vault used to store payment method information.",
+            "example": "locker_abc123",
+            "nullable": true
           },
-          "metadata": {
-            "type": "object",
-            "description": "You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\ncharacters long. Metadata is useful for storing additional, structured information on an\nobject.",
+          "primary_business_details": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PrimaryBusinessDetails"
+            },
+            "description": "Default business details for connector routing"
+          },
+          "intent_fulfillment_time": {
+            "type": "integer",
+            "format": "int64",
+            "description": "Will be used to expire client secret after certain amount of time to be supplied in seconds\n(900) for 15 mins",
             "nullable": true
           }
         }
       },
-      "FutureUsage": {
-        "type": "string",
-        "enum": ["off_session", "on_session"]
-      },
-      "GooglePayPaymentMethodInfo": {
+      "MerchantAccountUpdate": {
         "type": "object",
-        "required": ["card_network", "card_details"],
+        "required": ["merchant_id"],
         "properties": {
-          "card_network": {
+          "merchant_id": {
             "type": "string",
-            "description": "The name of the card network"
+            "description": "The identifier for the Merchant Account",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
           },
-          "card_details": {
-            "type": "string",
-            "description": "The details of the card"
-          }
-        }
-      },
-      "GooglePayWalletData": {
-        "type": "object",
-        "required": ["type", "description", "info", "tokenization_data"],
-        "properties": {
-          "type": {
+          "merchant_name": {
             "type": "string",
-            "description": "The type of payment method"
+            "description": "Name of the Merchant Account",
+            "example": "NewAge Retailer",
+            "nullable": true
           },
-          "description": {
+          "merchant_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/MerchantDetails"
+              }
+            ],
+            "nullable": true
+          },
+          "return_url": {
             "type": "string",
-            "description": "User-facing message to describe the payment method that funds this transaction."
+            "description": "The URL to redirect after the completion of the operation",
+            "example": "https://www.example.com/success",
+            "nullable": true,
+            "maxLength": 255
           },
-          "info": {
-            "$ref": "#/components/schemas/GooglePayPaymentMethodInfo"
+          "webhook_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/WebhookDetails"
+              }
+            ],
+            "nullable": true
           },
-          "tokenization_data": {
-            "$ref": "#/components/schemas/GpayTokenizationData"
-          }
-        }
-      },
-      "GpayAllowedMethodsParameters": {
-        "type": "object",
-        "required": ["allowed_auth_methods", "allowed_card_networks"],
-        "properties": {
-          "allowed_auth_methods": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "The list of allowed auth methods (ex: 3DS, No3DS, PAN_ONLY etc)"
+          "routing_algorithm": {
+            "type": "object",
+            "description": "The routing algorithm to be used for routing payments to desired connectors",
+            "nullable": true
           },
-          "allowed_card_networks": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            },
-            "description": "The list of allowed card networks (ex: AMEX,JCB etc)"
-          }
-        }
-      },
-      "GpayAllowedPaymentMethods": {
-        "type": "object",
-        "required": ["type", "parameters", "tokenization_specification"],
-        "properties": {
-          "type": {
+          "sub_merchants_enabled": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
+          },
+          "parent_merchant_id": {
+            "type": "string",
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": "xkkdf909012sdjki2dkh5sdf",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "enable_payment_response_hash": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if payment response hash needs to be enabled",
+            "default": false,
+            "example": true,
+            "nullable": true
+          },
+          "payment_response_hash_key": {
             "type": "string",
-            "description": "The type of payment method"
+            "description": "Refers to the hash key used for payment response",
+            "nullable": true
           },
-          "parameters": {
-            "$ref": "#/components/schemas/GpayAllowedMethodsParameters"
+          "redirect_to_merchant_with_http_post": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
+            "default": false,
+            "example": true,
+            "nullable": true
           },
-          "tokenization_specification": {
-            "$ref": "#/components/schemas/GpayTokenizationSpecification"
-          }
-        }
-      },
-      "GpayMerchantInfo": {
-        "type": "object",
-        "required": ["merchant_name"],
-        "properties": {
-          "merchant_name": {
+          "metadata": {
+            "type": "object",
+            "description": "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.",
+            "nullable": true
+          },
+          "publishable_key": {
             "type": "string",
-            "description": "The name of the merchant"
-          }
-        }
-      },
-      "GpaySessionTokenResponse": {
-        "type": "object",
-        "required": [
-          "merchant_info",
-          "allowed_payment_methods",
-          "transaction_info"
-        ],
-        "properties": {
-          "merchant_info": {
-            "$ref": "#/components/schemas/GpayMerchantInfo"
+            "description": "API key that will be used for server side API access",
+            "example": "AH3423bkjbkjdsfbkj",
+            "nullable": true
           },
-          "allowed_payment_methods": {
+          "locker_id": {
+            "type": "string",
+            "description": "An identifier for the vault used to store payment method information.",
+            "example": "locker_abc123",
+            "nullable": true
+          },
+          "primary_business_details": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/GpayAllowedPaymentMethods"
+              "$ref": "#/components/schemas/PrimaryBusinessDetails"
             },
-            "description": "List of the allowed payment meythods"
+            "description": "Default business details for connector routing",
+            "nullable": true
           },
-          "transaction_info": {
-            "$ref": "#/components/schemas/GpayTransactionInfo"
+          "intent_fulfillment_time": {
+            "type": "integer",
+            "format": "int32",
+            "description": "Will be used to expire client secret after certain amount of time to be supplied in seconds\n(900) for 15 mins",
+            "nullable": true,
+            "minimum": 0.0
           }
         }
       },
-      "GpayTokenParameters": {
+      "MerchantConnectorCreate": {
         "type": "object",
-        "required": ["gateway", "gateway_merchant_id"],
+        "description": "Create a new Merchant 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", "connector_label"],
         "properties": {
-          "gateway": {
-            "type": "string",
-            "description": "The name of the connector"
+          "connector_type": {
+            "$ref": "#/components/schemas/ConnectorType"
           },
-          "gateway_merchant_id": {
-            "type": "string",
-            "description": "The merchant ID registered in the connector associated"
-          }
-        }
-      },
-      "GpayTokenizationData": {
-        "type": "object",
-        "required": ["type", "token"],
-        "properties": {
-          "type": {
+          "connector_name": {
             "type": "string",
-            "description": "The type of the token"
+            "description": "Name of the Connector",
+            "example": "stripe"
           },
-          "token": {
-            "type": "string",
-            "description": "Token generated for the wallet"
-          }
-        }
-      },
-      "GpayTokenizationSpecification": {
-        "type": "object",
-        "required": ["type", "parameters"],
-        "properties": {
-          "type": {
+          "connector_label": {
             "type": "string",
-            "description": "The token specification type(ex: PAYMENT_GATEWAY)"
-          },
-          "parameters": {
-            "$ref": "#/components/schemas/GpayTokenParameters"
-          }
-        }
-      },
-      "GpayTransactionInfo": {
-        "type": "object",
-        "required": [
-          "country_code",
-          "currency_code",
-          "total_price_status",
-          "total_price"
-        ],
-        "properties": {
-          "country_code": {
-            "$ref": "#/components/schemas/Country"
+            "example": "stripe_US_travel"
           },
-          "currency_code": {
+          "merchant_connector_id": {
             "type": "string",
-            "description": "The currency code"
+            "description": "Unique ID of the connector",
+            "example": "mca_5apGeP94tMts6rg3U3kR",
+            "nullable": true
           },
-          "total_price_status": {
-            "type": "string",
-            "description": "The total price status (ex: 'FINAL')"
+          "connector_account_details": {
+            "type": "object",
+            "description": "Account details of the Connector. You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Useful for storing additional, structured information on an object.",
+            "nullable": true
           },
-          "total_price": {
-            "type": "integer",
-            "format": "int64",
-            "description": "The total price"
-          }
-        }
-      },
-      "IntentStatus": {
-        "type": "string",
-        "enum": [
-          "succeeded",
-          "failed",
-          "cancelled",
-          "processing",
-          "requires_customer_action",
-          "requires_payment_method",
-          "requires_confirmation",
-          "requires_capture"
-        ]
-      },
-      "KlarnaSessionTokenResponse": {
-        "type": "object",
-        "required": ["session_token", "session_id"],
-        "properties": {
-          "session_token": {
-            "type": "string",
-            "description": "The session token for Klarna"
+          "test_mode": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the connector is in Test mode. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
           },
-          "session_id": {
-            "type": "string",
-            "description": "The identifier for the session"
-          }
-        }
-      },
-      "MandateAmountData": {
-        "type": "object",
-        "required": ["amount", "currency"],
-        "properties": {
-          "amount": {
-            "type": "integer",
-            "format": "int64",
-            "description": "The maximum amount to be debited for the mandate transaction",
-            "example": 6540
+          "disabled": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the connector is disabled. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
           },
-          "currency": {
-            "$ref": "#/components/schemas/Currency"
-          }
-        }
-      },
-      "MandateCardDetails": {
-        "type": "object",
-        "required": [
-          "last4_digits",
-          "card_exp_month",
-          "card_exp_year",
-          "card_holder_name",
-          "card_token",
-          "scheme",
-          "issuer_country",
-          "card_fingerprint"
-        ],
-        "properties": {
-          "last4_digits": {
-            "type": "string",
-            "description": "The last 4 digits of card",
+          "payment_methods_enabled": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodsEnabled"
+            },
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": [
+              {
+                "payment_method": "wallet",
+                "payment_method_types": ["upi_collect", "upi_intent"],
+                "payment_method_issuers": ["labore magna ipsum", "aute"],
+                "payment_schemes": ["Discover", "Discover"],
+                "accepted_currencies": {
+                  "type": "enable_only",
+                  "list": ["USD", "EUR"]
+                },
+                "accepted_countries": {
+                  "type": "disable_only",
+                  "list": ["FR", "DE", "IN"]
+                },
+                "minimum_amount": 1,
+                "maximum_amount": 68607706,
+                "recurring_enabled": true,
+                "installment_payment_enabled": true
+              }
+            ],
             "nullable": true
           },
-          "card_exp_month": {
-            "type": "string",
-            "description": "The expiry month of card",
+          "metadata": {
+            "type": "object",
+            "description": "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.",
             "nullable": true
           },
-          "card_exp_year": {
-            "type": "string",
-            "description": "The expiry year of card",
+          "frm_configs": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/FrmConfigs"
+              }
+            ],
             "nullable": true
           },
-          "card_holder_name": {
-            "type": "string",
-            "description": "The card holder name",
+          "business_country": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CountryAlpha2"
+              }
+            ],
             "nullable": true
           },
-          "card_token": {
+          "business_label": {
             "type": "string",
-            "description": "The token from card locker",
             "nullable": true
           },
-          "scheme": {
+          "business_sub_label": {
+            "type": "string",
+            "description": "Business Sub label of the merchant",
+            "example": "chase",
+            "nullable": true
+          }
+        }
+      },
+      "MerchantConnectorDeleteResponse": {
+        "type": "object",
+        "required": ["merchant_id", "merchant_connector_id", "deleted"],
+        "properties": {
+          "merchant_id": {
             "type": "string",
-            "description": "The card scheme network for the particular card",
-            "nullable": true
+            "description": "The identifier for the Merchant Account",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 255
           },
-          "issuer_country": {
+          "merchant_connector_id": {
             "type": "string",
-            "description": "The country code in in which the card was issued",
-            "nullable": true
+            "description": "Unique ID of the connector",
+            "example": "mca_5apGeP94tMts6rg3U3kR"
           },
-          "card_fingerprint": {
-            "type": "string",
-            "description": "A unique identifier alias to identify a particular card",
-            "nullable": true
+          "deleted": {
+            "type": "boolean",
+            "description": "If the connector is deleted or not",
+            "example": false
           }
         }
       },
-      "MandateData": {
+      "MerchantConnectorDetails": {
         "type": "object",
-        "required": ["customer_acceptance", "mandate_type"],
         "properties": {
-          "customer_acceptance": {
-            "$ref": "#/components/schemas/CustomerAcceptance"
+          "connector_account_details": {
+            "type": "object",
+            "description": "Account details of the Connector. You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Useful for storing additional, structured information on an object.",
+            "nullable": true
           },
-          "mandate_type": {
-            "$ref": "#/components/schemas/MandateType"
+          "metadata": {
+            "type": "object",
+            "description": "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.",
+            "nullable": true
           }
         }
       },
-      "MandateResponse": {
+      "MerchantConnectorDetailsWrap": {
         "type": "object",
-        "required": [
-          "mandate_id",
-          "status",
-          "payment_method_id",
-          "payment_method",
-          "card",
-          "customer_acceptance"
-        ],
+        "required": ["creds_identifier"],
         "properties": {
-          "mandate_id": {
-            "type": "string",
-            "description": "The identifier for mandate"
-          },
-          "status": {
-            "$ref": "#/components/schemas/MandateStatus"
-          },
-          "payment_method_id": {
-            "type": "string",
-            "description": "The identifier for payment method"
-          },
-          "payment_method": {
+          "creds_identifier": {
             "type": "string",
-            "description": "The payment method"
-          },
-          "card": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/MandateCardDetails"
-              }
-            ],
-            "nullable": true
+            "description": "Creds Identifier is to uniquely identify the credentials. Do not send any sensitive info in this field. And do not send the string \"null\"."
           },
-          "customer_acceptance": {
+          "encoded_data": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/CustomerAcceptance"
+                "$ref": "#/components/schemas/MerchantConnectorDetails"
               }
             ],
             "nullable": true
           }
         }
       },
-      "MandateRevokedResponse": {
+      "MerchantConnectorId": {
         "type": "object",
-        "required": ["mandate_id", "status"],
+        "required": ["merchant_id", "merchant_connector_id"],
         "properties": {
-          "mandate_id": {
-            "type": "string",
-            "description": "The identifier for mandate"
+          "merchant_id": {
+            "type": "string"
           },
-          "status": {
-            "$ref": "#/components/schemas/MandateStatus"
+          "merchant_connector_id": {
+            "type": "string"
           }
         }
       },
-      "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"]
-      },
-      "MandateType": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["single_use"],
-            "properties": {
-              "single_use": {
-                "$ref": "#/components/schemas/MandateAmountData"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["multi_use"],
-            "properties": {
-              "multi_use": {
-                "allOf": [
-                  {
-                    "$ref": "#/components/schemas/MandateAmountData"
-                  }
-                ],
-                "nullable": true
-              }
-            }
-          }
-        ]
-      },
-      "MerchantAccountCreate": {
+      "MerchantConnectorResponse": {
         "type": "object",
+        "description": "Response of creating a new Merchant Connector for the merchant account.\"",
         "required": [
-          "merchant_id",
-          "merchant_name",
-          "api_key",
-          "merchant_details",
-          "return_url",
-          "webhook_details",
-          "routing_algorithm",
-          "sub_merchants_enabled",
-          "parent_merchant_id",
-          "enable_payment_response_hash",
-          "payment_response_hash_key",
-          "redirect_to_merchant_with_http_post",
-          "metadata",
-          "publishable_key",
-          "locker_id",
-          "primary_business_details"
+          "connector_type",
+          "connector_name",
+          "connector_label",
+          "merchant_connector_id",
+          "business_country",
+          "business_label"
         ],
         "properties": {
-          "merchant_id": {
+          "connector_type": {
+            "$ref": "#/components/schemas/ConnectorType"
+          },
+          "connector_name": {
             "type": "string",
-            "description": "The identifier for the Merchant Account",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 255
+            "description": "Name of the Connector",
+            "example": "stripe"
           },
-          "merchant_name": {
+          "connector_label": {
             "type": "string",
-            "description": "Name of the Merchant Account",
-            "example": "NewAge Retailer",
-            "nullable": true
+            "example": "stripe_US_travel"
           },
-          "api_key": {
+          "merchant_connector_id": {
             "type": "string",
-            "description": "API key that will be used for server side API access",
-            "example": "Ah2354543543523",
+            "description": "Unique ID of the connector",
+            "example": "mca_5apGeP94tMts6rg3U3kR"
+          },
+          "connector_account_details": {
+            "type": "object",
+            "description": "Account details of the Connector. You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Useful for storing additional, structured information on an object.",
             "nullable": true
           },
-          "merchant_details": {
-            "allOf": [
+          "test_mode": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the connector is in Test mode. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
+          },
+          "disabled": {
+            "type": "boolean",
+            "description": "A boolean value to indicate if the connector is disabled. By default, its value is false.",
+            "default": false,
+            "example": false,
+            "nullable": true
+          },
+          "payment_methods_enabled": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodsEnabled"
+            },
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": [
               {
-                "$ref": "#/components/schemas/MerchantDetails"
+                "payment_method": "wallet",
+                "payment_method_types": ["upi_collect", "upi_intent"],
+                "payment_method_issuers": ["labore magna ipsum", "aute"],
+                "payment_schemes": ["Discover", "Discover"],
+                "accepted_currencies": {
+                  "type": "enable_only",
+                  "list": ["USD", "EUR"]
+                },
+                "accepted_countries": {
+                  "type": "disable_only",
+                  "list": ["FR", "DE", "IN"]
+                },
+                "minimum_amount": 1,
+                "maximum_amount": 68607706,
+                "recurring_enabled": true,
+                "installment_payment_enabled": true
               }
             ],
             "nullable": true
           },
-          "return_url": {
+          "metadata": {
+            "type": "object",
+            "description": "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.",
+            "nullable": true
+          },
+          "business_country": {
+            "$ref": "#/components/schemas/CountryAlpha2"
+          },
+          "business_label": {
             "type": "string",
-            "description": "The URL to redirect after the completion of the operation",
-            "example": "https://www.example.com/success",
-            "nullable": true,
-            "maxLength": 255
+            "description": "Business Type of the merchant",
+            "example": "travel"
           },
-          "webhook_details": {
+          "business_sub_label": {
+            "type": "string",
+            "description": "Business Sub label of the merchant",
+            "example": "chase",
+            "nullable": true
+          },
+          "frm_configs": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/WebhookDetails"
+                "$ref": "#/components/schemas/FrmConfigs"
               }
             ],
             "nullable": true
+          }
+        }
+      },
+      "MerchantConnectorUpdate": {
+        "type": "object",
+        "description": "Create a new Merchant Connector for the merchant account. The connector could be a payment processor / facilitator / acquirer or specialized services like Fraud / Accounting etc.\"",
+        "required": ["connector_type"],
+        "properties": {
+          "connector_type": {
+            "$ref": "#/components/schemas/ConnectorType"
           },
-          "routing_algorithm": {
+          "connector_account_details": {
             "type": "object",
-            "description": "The routing algorithm to be used for routing payments to desired connectors",
+            "description": "Account details of the Connector. You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Useful for storing additional, structured information on an object.",
             "nullable": true
           },
-          "sub_merchants_enabled": {
+          "test_mode": {
             "type": "boolean",
-            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
+            "description": "A boolean value to indicate if the connector is in Test mode. By default, its value is false.",
             "default": false,
             "example": false,
             "nullable": true
           },
-          "parent_merchant_id": {
-            "type": "string",
-            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
-            "example": "xkkdf909012sdjki2dkh5sdf",
-            "nullable": true,
-            "maxLength": 255
-          },
-          "enable_payment_response_hash": {
+          "disabled": {
             "type": "boolean",
-            "description": "A boolean value to indicate if payment response hash needs to be enabled",
+            "description": "A boolean value to indicate if the connector is disabled. By default, its value is false.",
             "default": false,
-            "example": true,
-            "nullable": true
-          },
-          "payment_response_hash_key": {
-            "type": "string",
-            "description": "Refers to the hash key used for payment response",
+            "example": false,
             "nullable": true
           },
-          "redirect_to_merchant_with_http_post": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
-            "default": false,
-            "example": true,
+          "payment_methods_enabled": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodsEnabled"
+            },
+            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
+            "example": [
+              {
+                "payment_method": "wallet",
+                "payment_method_types": ["upi_collect", "upi_intent"],
+                "payment_method_issuers": ["labore magna ipsum", "aute"],
+                "payment_schemes": ["Discover", "Discover"],
+                "accepted_currencies": {
+                  "type": "enable_only",
+                  "list": ["USD", "EUR"]
+                },
+                "accepted_countries": {
+                  "type": "disable_only",
+                  "list": ["FR", "DE", "IN"]
+                },
+                "minimum_amount": 1,
+                "maximum_amount": 68607706,
+                "recurring_enabled": true,
+                "installment_payment_enabled": true
+              }
+            ],
             "nullable": true
           },
           "metadata": {
@@ -3473,1025 +4642,1040 @@
             "description": "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.",
             "nullable": true
           },
-          "publishable_key": {
-            "type": "string",
-            "description": "API key that will be used for server side API access",
-            "example": "AH3423bkjbkjdsfbkj",
-            "nullable": true
-          },
-          "locker_id": {
-            "type": "string",
-            "description": "An identifier for the vault used to store payment method information.",
-            "example": "locker_abc123",
-            "nullable": true
-          },
-          "primary_business_details": {
+          "frm_configs": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PrimaryBusinessDetails"
+                "$ref": "#/components/schemas/FrmConfigs"
               }
             ],
             "nullable": true
           }
         }
       },
-      "MerchantAccountDeleteResponse": {
+      "MerchantDetails": {
         "type": "object",
-        "required": ["merchant_id", "deleted"],
         "properties": {
-          "merchant_id": {
+          "primary_contact_person": {
             "type": "string",
-            "description": "The identifier for the Merchant Account",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "description": "The merchant's primary contact name",
+            "example": "John Doe",
+            "nullable": true,
             "maxLength": 255
           },
-          "deleted": {
-            "type": "boolean",
-            "description": "If the connector is deleted or not",
-            "example": false
-          }
-        }
-      },
-      "MerchantAccountResponse": {
-        "type": "object",
-        "required": [
-          "merchant_id",
-          "merchant_name",
-          "api_key",
-          "return_url",
-          "enable_payment_response_hash",
-          "payment_response_hash_key",
-          "redirect_to_merchant_with_http_post",
-          "merchant_details",
-          "webhook_details",
-          "routing_algorithm",
-          "sub_merchants_enabled",
-          "parent_merchant_id",
-          "publishable_key",
-          "metadata",
-          "locker_id",
-          "primary_business_details"
-        ],
-        "properties": {
-          "merchant_id": {
+          "primary_phone": {
             "type": "string",
-            "description": "The identifier for the Merchant Account",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "description": "The merchant's primary phone number",
+            "example": "999999999",
+            "nullable": true,
             "maxLength": 255
           },
-          "merchant_name": {
+          "primary_email": {
             "type": "string",
-            "description": "Name of the Merchant Account",
-            "example": "NewAge Retailer",
-            "nullable": true
+            "description": "The merchant's primary email address",
+            "example": "johndoe@test.com",
+            "nullable": true,
+            "maxLength": 255
           },
-          "api_key": {
+          "secondary_contact_person": {
             "type": "string",
-            "description": "API key that will be used for server side API access",
-            "example": "Ah2354543543523",
-            "nullable": true
+            "description": "The merchant's secondary contact name",
+            "example": "John Doe2",
+            "nullable": true,
+            "maxLength": 255
           },
-          "return_url": {
+          "secondary_phone": {
             "type": "string",
-            "description": "The URL to redirect after the completion of the operation",
-            "example": "https://www.example.com/success",
+            "description": "The merchant's secondary phone number",
+            "example": "999999988",
             "nullable": true,
             "maxLength": 255
           },
-          "enable_payment_response_hash": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if payment response hash needs to be enabled",
-            "default": false,
-            "example": true
+          "secondary_email": {
+            "type": "string",
+            "description": "The merchant's secondary email address",
+            "example": "johndoe2@test.com",
+            "nullable": true,
+            "maxLength": 255
           },
-          "payment_response_hash_key": {
+          "website": {
             "type": "string",
-            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
-            "example": "xkkdf909012sdjki2dkh5sdf",
+            "description": "The business website of the merchant",
+            "example": "www.example.com",
             "nullable": true,
             "maxLength": 255
           },
-          "redirect_to_merchant_with_http_post": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
-            "default": false,
-            "example": true
+          "about_business": {
+            "type": "string",
+            "description": "A brief description about merchant's business",
+            "example": "Online Retail with a wide selection of organic products for North America",
+            "nullable": true,
+            "maxLength": 255
           },
-          "merchant_details": {
+          "address": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/MerchantDetails"
+                "$ref": "#/components/schemas/AddressDetails"
               }
             ],
             "nullable": true
+          }
+        }
+      },
+      "Metadata": {
+        "allOf": [
+          {
+            "type": "object",
+            "description": "Any other metadata that is to be provided"
+          },
+          {
+            "type": "object",
+            "properties": {
+              "order_details": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/OrderDetails"
+                },
+                "description": "Information about the product and quantity for specific connectors. (e.g. Klarna)",
+                "nullable": true
+              },
+              "payload": {
+                "type": "object",
+                "description": "Payload coming in request as a metadata field",
+                "nullable": true
+              },
+              "allowed_payment_method_types": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/PaymentMethodType"
+                },
+                "description": "Allowed payment method types for a payment intent",
+                "nullable": true
+              }
+            }
+          }
+        ]
+      },
+      "MobilePayRedirection": {
+        "type": "object"
+      },
+      "NextAction": {
+        "type": "object",
+        "required": ["type"],
+        "properties": {
+          "type": {
+            "$ref": "#/components/schemas/NextActionType"
+          },
+          "redirect_to_url": {
+            "type": "string",
+            "description": "Contains the url for redirection flow",
+            "example": "https://router.juspay.io/redirect/fakushdfjlksdfasklhdfj",
+            "nullable": true
+          }
+        }
+      },
+      "NextActionType": {
+        "type": "string",
+        "enum": [
+          "redirect_to_url",
+          "display_qr_code",
+          "invoke_sdk_client",
+          "trigger_api"
+        ]
+      },
+      "OnlineMandate": {
+        "type": "object",
+        "required": ["ip_address", "user_agent"],
+        "properties": {
+          "ip_address": {
+            "type": "string",
+            "description": "Ip address of the customer machine from which the mandate was created",
+            "example": "123.32.25.123"
           },
-          "webhook_details": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/WebhookDetails"
+          "user_agent": {
+            "type": "string",
+            "description": "The user-agent of the customer's browser"
+          }
+        }
+      },
+      "OrderDetails": {
+        "type": "object",
+        "required": ["product_name", "quantity", "amount"],
+        "properties": {
+          "product_name": {
+            "type": "string",
+            "description": "Name of the product that is being purchased",
+            "example": "shirt",
+            "maxLength": 255
+          },
+          "quantity": {
+            "type": "integer",
+            "format": "int32",
+            "description": "The quantity of the product to be purchased",
+            "example": 1,
+            "minimum": 0.0
+          },
+          "amount": {
+            "type": "integer",
+            "format": "int64",
+            "description": "the amount per quantity of product"
+          }
+        }
+      },
+      "PayLaterData": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["klarna_redirect"],
+            "properties": {
+              "klarna_redirect": {
+                "type": "object",
+                "description": "For KlarnaRedirect as PayLater Option",
+                "required": ["billing_email", "billing_country"],
+                "properties": {
+                  "billing_email": {
+                    "type": "string",
+                    "description": "The billing email"
+                  },
+                  "billing_country": {
+                    "$ref": "#/components/schemas/CountryAlpha2"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["klarna_sdk"],
+            "properties": {
+              "klarna_sdk": {
+                "type": "object",
+                "description": "For Klarna Sdk as PayLater Option",
+                "required": ["token"],
+                "properties": {
+                  "token": {
+                    "type": "string",
+                    "description": "The token for the sdk workflow"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["affirm_redirect"],
+            "properties": {
+              "affirm_redirect": {
+                "type": "object",
+                "description": "For Affirm redirect as PayLater Option"
               }
-            ],
-            "nullable": true
+            }
           },
-          "routing_algorithm": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/RoutingAlgorithm"
+          {
+            "type": "object",
+            "required": ["afterpay_clearpay_redirect"],
+            "properties": {
+              "afterpay_clearpay_redirect": {
+                "type": "object",
+                "description": "For AfterpayClearpay redirect as PayLater Option",
+                "required": ["billing_email", "billing_name"],
+                "properties": {
+                  "billing_email": {
+                    "type": "string",
+                    "description": "The billing email"
+                  },
+                  "billing_name": {
+                    "type": "string",
+                    "description": "The billing name"
+                  }
+                }
               }
-            ],
-            "nullable": true
-          },
-          "sub_merchants_enabled": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
-            "default": false,
-            "example": false,
-            "nullable": true
+            }
           },
-          "parent_merchant_id": {
-            "type": "string",
-            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
-            "example": "xkkdf909012sdjki2dkh5sdf",
-            "nullable": true,
-            "maxLength": 255
+          {
+            "type": "object",
+            "required": ["pay_bright"],
+            "properties": {
+              "pay_bright": {
+                "type": "object"
+              }
+            }
           },
-          "publishable_key": {
+          {
+            "type": "object",
+            "required": ["walley"],
+            "properties": {
+              "walley": {
+                "type": "object"
+              }
+            }
+          }
+        ]
+      },
+      "PayPalWalletData": {
+        "type": "object",
+        "required": ["token"],
+        "properties": {
+          "token": {
             "type": "string",
-            "description": "API key that will be used for server side API access",
-            "example": "AH3423bkjbkjdsfbkj",
-            "nullable": true
-          },
-          "metadata": {
+            "description": "Token generated for the Apple pay"
+          }
+        }
+      },
+      "PaymentExperience": {
+        "type": "string",
+        "enum": [
+          "redirect_to_url",
+          "invoke_sdk_client",
+          "display_qr_code",
+          "one_click",
+          "link_wallet",
+          "invoke_payment_app"
+        ]
+      },
+      "PaymentIdType": {
+        "oneOf": [
+          {
             "type": "object",
-            "description": "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.",
-            "nullable": true
+            "required": ["PaymentIntentId"],
+            "properties": {
+              "PaymentIntentId": {
+                "type": "string",
+                "description": "The identifier for payment intent"
+              }
+            }
           },
-          "locker_id": {
-            "type": "string",
-            "description": "An identifier for the vault used to store payment method information.",
-            "example": "locker_abc123",
-            "nullable": true
+          {
+            "type": "object",
+            "required": ["ConnectorTransactionId"],
+            "properties": {
+              "ConnectorTransactionId": {
+                "type": "string",
+                "description": "The identifier for connector transaction"
+              }
+            }
           },
-          "primary_business_details": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/PrimaryBusinessDetails"
+          {
+            "type": "object",
+            "required": ["PaymentAttemptId"],
+            "properties": {
+              "PaymentAttemptId": {
+                "type": "string",
+                "description": "The identifier for payment attempt"
               }
-            ],
-            "nullable": true
+            }
           }
-        }
+        ]
       },
-      "MerchantAccountUpdate": {
+      "PaymentListConstraints": {
         "type": "object",
-        "required": [
-          "merchant_id",
-          "merchant_name",
-          "merchant_details",
-          "return_url",
-          "webhook_details",
-          "routing_algorithm",
-          "sub_merchants_enabled",
-          "parent_merchant_id",
-          "enable_payment_response_hash",
-          "payment_response_hash_key",
-          "redirect_to_merchant_with_http_post",
-          "metadata",
-          "publishable_key",
-          "locker_id",
-          "primary_business_details"
-        ],
         "properties": {
-          "merchant_id": {
-            "type": "string",
-            "description": "The identifier for the Merchant Account",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 255
-          },
-          "merchant_name": {
+          "customer_id": {
             "type": "string",
-            "description": "Name of the Merchant Account",
-            "example": "NewAge Retailer",
+            "description": "The identifier for customer",
+            "example": "cus_meowuwunwiuwiwqw",
             "nullable": true
           },
-          "merchant_details": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/MerchantDetails"
-              }
-            ],
+          "starting_after": {
+            "type": "string",
+            "description": "A cursor for use in pagination, fetch the next list after some object",
+            "example": "pay_fafa124123",
             "nullable": true
           },
-          "return_url": {
+          "ending_before": {
             "type": "string",
-            "description": "The URL to redirect after the completion of the operation",
-            "example": "https://www.example.com/success",
-            "nullable": true,
-            "maxLength": 255
-          },
-          "webhook_details": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/WebhookDetails"
-              }
-            ],
+            "description": "A cursor for use in pagination, fetch the previous list before some object",
+            "example": "pay_fafa124123",
             "nullable": true
           },
-          "routing_algorithm": {
-            "type": "object",
-            "description": "The routing algorithm to be used for routing payments to desired connectors",
-            "nullable": true
+          "limit": {
+            "type": "integer",
+            "format": "int64",
+            "description": "limit on the number of objects to return",
+            "default": 10
           },
-          "sub_merchants_enabled": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if the merchant is a sub-merchant under a master or a parent merchant. By default, its value is false.",
-            "default": false,
-            "example": false,
+          "created": {
+            "type": "string",
+            "format": "date-time",
+            "description": "The time at which payment is created",
+            "example": "2022-09-10T10:11:12Z",
             "nullable": true
           },
-          "parent_merchant_id": {
+          "created.lt": {
             "type": "string",
-            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
-            "example": "xkkdf909012sdjki2dkh5sdf",
-            "nullable": true,
-            "maxLength": 255
-          },
-          "enable_payment_response_hash": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if payment response hash needs to be enabled",
-            "default": false,
-            "example": true,
+            "format": "date-time",
+            "description": "Time less than the payment created time",
+            "example": "2022-09-10T10:11:12Z",
             "nullable": true
           },
-          "payment_response_hash_key": {
+          "created.gt": {
             "type": "string",
-            "description": "Refers to the hash key used for payment response",
+            "format": "date-time",
+            "description": "Time greater than the payment created time",
+            "example": "2022-09-10T10:11:12Z",
             "nullable": true
           },
-          "redirect_to_merchant_with_http_post": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if redirect to merchant with http post needs to be enabled",
-            "default": false,
-            "example": true,
+          "created.lte": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Time less than or equals to the payment created time",
+            "example": "2022-09-10T10:11:12Z",
             "nullable": true
           },
-          "metadata": {
-            "type": "object",
-            "description": "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.",
+          "created.gte": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Time greater than or equals to the payment created time",
+            "example": "2022-09-10T10:11:12Z",
             "nullable": true
+          }
+        }
+      },
+      "PaymentListResponse": {
+        "type": "object",
+        "required": ["size", "data"],
+        "properties": {
+          "size": {
+            "type": "integer",
+            "description": "The number of payments included in the list",
+            "minimum": 0.0
           },
-          "publishable_key": {
-            "type": "string",
-            "description": "API key that will be used for server side API access",
-            "example": "AH3423bkjbkjdsfbkj",
+          "data": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentsResponse"
+            }
+          }
+        }
+      },
+      "PaymentMethod": {
+        "type": "string",
+        "enum": [
+          "card",
+          "pay_later",
+          "wallet",
+          "bank_redirect",
+          "crypto",
+          "bank_debit"
+        ]
+      },
+      "PaymentMethodCreate": {
+        "type": "object",
+        "required": ["payment_method"],
+        "properties": {
+          "payment_method": {
+            "$ref": "#/components/schemas/PaymentMethodType"
+          },
+          "payment_method_type": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PaymentMethodType"
+              }
+            ],
             "nullable": true
           },
-          "locker_id": {
+          "payment_method_issuer": {
             "type": "string",
-            "description": "An identifier for the vault used to store payment method information.",
-            "example": "locker_abc123",
+            "description": "The name of the bank/ provider issuing the payment method to the end user",
+            "example": "Citibank",
             "nullable": true
           },
-          "primary_business_details": {
+          "payment_method_issuer_code": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PrimaryBusinessDetails"
+                "$ref": "#/components/schemas/PaymentMethodIssuerCode"
               }
             ],
             "nullable": true
-          }
-        }
-      },
-      "MerchantConnector": {
-        "type": "object",
-        "description": "Create a new Merchant 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",
-          "connector_label",
-          "business_country",
-          "business_label",
-          "business_sub_label",
-          "merchant_connector_id",
-          "connector_account_details",
-          "test_mode",
-          "disabled",
-          "payment_methods_enabled",
-          "metadata"
-        ],
-        "properties": {
-          "connector_type": {
-            "$ref": "#/components/schemas/ConnectorType"
-          },
-          "connector_name": {
-            "type": "string",
-            "description": "Name of the Connector",
-            "example": "stripe"
-          },
-          "connector_label": {
-            "type": "string",
-            "example": "stripe_US_travel"
           },
-          "business_country": {
-            "type": "string",
-            "description": "Country through which payment should be processed",
-            "example": "US",
+          "card": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CardDetail"
+              }
+            ],
             "nullable": true
           },
-          "business_label": {
-            "type": "string",
-            "description": "Business Type of the merchant",
-            "example": "travel",
+          "metadata": {
+            "type": "object",
+            "description": "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.",
             "nullable": true
           },
-          "business_sub_label": {
+          "customer_id": {
             "type": "string",
-            "description": "Business Sub label of the merchant",
-            "example": "chase",
+            "description": "The unique identifier of the customer.",
+            "example": "cus_meowerunwiuwiwqw",
             "nullable": true
           },
-          "merchant_connector_id": {
+          "card_network": {
             "type": "string",
-            "description": "Unique ID of the connector",
-            "example": "mca_5apGeP94tMts6rg3U3kR",
+            "description": "The card network",
+            "example": "Visa",
             "nullable": true
+          }
+        }
+      },
+      "PaymentMethodData": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["card"],
+            "properties": {
+              "card": {
+                "$ref": "#/components/schemas/Card"
+              }
+            }
           },
-          "connector_account_details": {
-            "type": "string",
-            "description": "Account details of the Connector. You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Useful for storing additional, structured information on an object.",
-            "example": {
-              "auth_type": "HeaderKey",
-              "api_key": "Basic MyVerySecretApiKey"
-            },
-            "nullable": true
+          {
+            "type": "object",
+            "required": ["wallet"],
+            "properties": {
+              "wallet": {
+                "$ref": "#/components/schemas/WalletData"
+              }
+            }
           },
-          "test_mode": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if the connector is in Test mode. By default, its value is false.",
-            "default": false,
-            "example": false,
-            "nullable": true
+          {
+            "type": "object",
+            "required": ["pay_later"],
+            "properties": {
+              "pay_later": {
+                "$ref": "#/components/schemas/PayLaterData"
+              }
+            }
           },
-          "disabled": {
-            "type": "boolean",
-            "description": "A boolean value to indicate if the connector is disabled. By default, its value is false.",
-            "default": false,
-            "example": false,
-            "nullable": true
+          {
+            "type": "object",
+            "required": ["bank_redirect"],
+            "properties": {
+              "bank_redirect": {
+                "$ref": "#/components/schemas/BankRedirectData"
+              }
+            }
           },
-          "payment_methods_enabled": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentMethodsEnabled"
-            },
-            "description": "Refers to the Parent Merchant ID if the merchant being created is a sub-merchant",
-            "example": [
-              {
-                "payment_method": "wallet",
-                "payment_method_types": ["upi_collect", "upi_intent"],
-                "payment_method_issuers": ["labore magna ipsum", "aute"],
-                "payment_schemes": ["Discover", "Discover"],
-                "accepted_currencies": {
-                  "type": "enable_only",
-                  "list": ["USD", "EUR"]
-                },
-                "accepted_countries": {
-                  "type": "disable_only",
-                  "list": ["FR", "DE", "IN"]
-                },
-                "minimum_amount": 1,
-                "maximum_amount": 68607706,
-                "recurring_enabled": true,
-                "installment_payment_enabled": true
+          {
+            "type": "object",
+            "required": ["bank_debit"],
+            "properties": {
+              "bank_debit": {
+                "$ref": "#/components/schemas/BankDebitData"
               }
-            ],
-            "nullable": true
+            }
           },
-          "metadata": {
+          {
             "type": "object",
-            "description": "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.",
-            "nullable": true
+            "required": ["crypto"],
+            "properties": {
+              "crypto": {
+                "$ref": "#/components/schemas/CryptoData"
+              }
+            }
+          },
+          {
+            "type": "string",
+            "enum": ["mandate_payment"]
           }
-        }
+        ]
       },
-      "MerchantConnectorDeleteResponse": {
+      "PaymentMethodDeleteResponse": {
         "type": "object",
-        "required": ["merchant_id", "merchant_connector_id", "deleted"],
+        "required": ["payment_method_id", "deleted"],
         "properties": {
-          "merchant_id": {
-            "type": "string",
-            "description": "The identifier for the Merchant Account",
-            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
-            "maxLength": 255
-          },
-          "merchant_connector_id": {
+          "payment_method_id": {
             "type": "string",
-            "description": "Unique ID of the connector",
-            "example": "mca_5apGeP94tMts6rg3U3kR"
+            "description": "The unique identifier of the Payment method",
+            "example": "card_rGK4Vi5iSW70MY7J2mIy"
           },
           "deleted": {
             "type": "boolean",
-            "description": "If the connector is deleted or not",
-            "example": false
+            "description": "Whether payment method was deleted or not",
+            "example": true
           }
         }
       },
-      "MerchantConnectorId": {
+      "PaymentMethodIssuerCode": {
+        "type": "string",
+        "enum": [
+          "jp_hdfc",
+          "jp_icici",
+          "jp_googlepay",
+          "jp_applepay",
+          "jp_phonepay",
+          "jp_wechat",
+          "jp_sofort",
+          "jp_giropay",
+          "jp_sepa",
+          "jp_bacs"
+        ]
+      },
+      "PaymentMethodList": {
         "type": "object",
-        "required": ["merchant_id", "merchant_connector_id"],
+        "required": ["payment_method"],
         "properties": {
-          "merchant_id": {
-            "type": "string"
+          "payment_method": {
+            "$ref": "#/components/schemas/PaymentMethod"
           },
-          "merchant_connector_id": {
-            "type": "string"
+          "payment_method_types": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodType"
+            },
+            "description": "This is a sub-category of payment method.",
+            "example": ["credit"],
+            "nullable": true
           }
         }
       },
-      "MerchantDetails": {
+      "PaymentMethodListResponse": {
         "type": "object",
-        "required": [
-          "primary_contact_person",
-          "primary_phone",
-          "primary_email",
-          "secondary_contact_person",
-          "secondary_phone",
-          "secondary_email",
-          "website",
-          "about_business",
-          "address"
-        ],
+        "required": ["payment_methods"],
         "properties": {
-          "primary_contact_person": {
-            "type": "string",
-            "description": "The merchant's primary contact name",
-            "example": "John Doe",
-            "nullable": true,
-            "maxLength": 255
-          },
-          "primary_phone": {
-            "type": "string",
-            "description": "The merchant's primary phone number",
-            "example": "999999999",
-            "nullable": true,
-            "maxLength": 255
-          },
-          "primary_email": {
+          "redirect_url": {
             "type": "string",
-            "description": "The merchant's primary email address",
-            "example": "johndoe@test.com",
-            "nullable": true,
-            "maxLength": 255
+            "description": "Redirect URL of the merchant",
+            "example": "https://www.google.com",
+            "nullable": true
           },
-          "secondary_contact_person": {
+          "payment_methods": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodList"
+            },
+            "description": "Information about the payment method",
+            "example": [
+              {
+                "payment_method": "wallet",
+                "payment_experience": null,
+                "payment_method_issuers": ["labore magna ipsum", "aute"]
+              }
+            ]
+          }
+        }
+      },
+      "PaymentMethodResponse": {
+        "type": "object",
+        "required": [
+          "merchant_id",
+          "payment_method_id",
+          "payment_method",
+          "recurring_enabled",
+          "installment_payment_enabled"
+        ],
+        "properties": {
+          "merchant_id": {
             "type": "string",
-            "description": "The merchant's secondary contact name",
-            "example": "John Doe2",
-            "nullable": true,
-            "maxLength": 255
+            "description": "Unique identifier for a merchant",
+            "example": "merchant_1671528864"
           },
-          "secondary_phone": {
+          "customer_id": {
             "type": "string",
-            "description": "The merchant's secondary phone number",
-            "example": "999999988",
-            "nullable": true,
-            "maxLength": 255
+            "description": "The unique identifier of the customer.",
+            "example": "cus_meowerunwiuwiwqw",
+            "nullable": true
           },
-          "secondary_email": {
+          "payment_method_id": {
             "type": "string",
-            "description": "The merchant's secondary email address",
-            "example": "johndoe2@test.com",
-            "nullable": true,
-            "maxLength": 255
+            "description": "The unique identifier of the Payment method",
+            "example": "card_rGK4Vi5iSW70MY7J2mIy"
           },
-          "website": {
-            "type": "string",
-            "description": "The business website of the merchant",
-            "example": "www.example.com",
-            "nullable": true,
-            "maxLength": 255
+          "payment_method": {
+            "$ref": "#/components/schemas/PaymentMethodType"
           },
-          "about_business": {
-            "type": "string",
-            "description": "A brief description about merchant's business",
-            "example": "Online Retail with a wide selection of organic products for North America",
-            "nullable": true,
-            "maxLength": 255
+          "payment_method_type": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PaymentMethodType"
+              }
+            ],
+            "nullable": true
           },
-          "address": {
+          "card": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/AddressDetails"
+                "$ref": "#/components/schemas/CardDetailFromLocker"
               }
             ],
             "nullable": true
-          }
-        }
-      },
-      "Metadata": {
-        "allOf": [
-          {
-            "type": "object",
-            "description": "Any other metadata that is to be provided"
           },
-          {
+          "recurring_enabled": {
+            "type": "boolean",
+            "description": "Indicates whether the payment method is eligible for recurring payments",
+            "example": true
+          },
+          "installment_payment_enabled": {
+            "type": "boolean",
+            "description": "Indicates whether the payment method is eligible for installment payments",
+            "example": true
+          },
+          "payment_experience": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentExperience"
+            },
+            "description": "Type of payment experience enabled with the connector",
+            "example": ["redirect_to_url"],
+            "nullable": true
+          },
+          "metadata": {
             "type": "object",
-            "required": ["order_details"],
-            "properties": {
-              "order_details": {
-                "allOf": [
-                  {
-                    "$ref": "#/components/schemas/OrderDetails"
-                  }
-                ],
-                "nullable": true
-              }
-            }
-          }
-        ]
-      },
-      "NextAction": {
-        "type": "object",
-        "required": ["type", "redirect_to_url"],
-        "properties": {
-          "type": {
-            "$ref": "#/components/schemas/NextActionType"
+            "description": "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.",
+            "nullable": true
           },
-          "redirect_to_url": {
+          "created": {
             "type": "string",
-            "description": "Contains the url for redirection flow",
-            "example": "https://router.juspay.io/redirect/fakushdfjlksdfasklhdfj",
+            "format": "date-time",
+            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
+            "example": "2023-01-18T11:04:09.922Z",
             "nullable": true
           }
         }
       },
-      "NextActionType": {
+      "PaymentMethodType": {
         "type": "string",
         "enum": [
-          "redirect_to_url",
-          "display_qr_code",
-          "invoke_sdk_client",
-          "trigger_api"
+          "ach",
+          "affirm",
+          "afterpay_clearpay",
+          "ali_pay",
+          "apple_pay",
+          "bacs",
+          "bancontact_card",
+          "becs",
+          "blik",
+          "credit",
+          "crypto_currency",
+          "debit",
+          "eps",
+          "giropay",
+          "google_pay",
+          "ideal",
+          "klarna",
+          "mb_way",
+          "mobile_pay",
+          "online_banking_czech_republic",
+          "online_banking_finland",
+          "online_banking_poland",
+          "online_banking_slovakia",
+          "pay_bright",
+          "paypal",
+          "przelewy24",
+          "sepa",
+          "sofort",
+          "swish",
+          "trustly",
+          "walley",
+          "we_chat_pay"
         ]
       },
-      "OnlineMandate": {
+      "PaymentMethodUpdate": {
         "type": "object",
-        "required": ["ip_address", "user_agent"],
         "properties": {
-          "ip_address": {
-            "type": "string",
-            "description": "Ip address of the customer machine from which the mandate was created",
-            "example": "123.32.25.123"
+          "card": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CardDetail"
+              }
+            ],
+            "nullable": true
           },
-          "user_agent": {
-            "type": "string",
-            "description": "The user-agent of the customer's browser"
+          "card_network": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CardNetwork"
+              }
+            ],
+            "nullable": true
+          },
+          "metadata": {
+            "type": "object",
+            "description": "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.",
+            "nullable": true
           }
         }
       },
-      "OrderDetails": {
+      "PaymentMethodsEnabled": {
         "type": "object",
-        "required": ["product_name", "quantity"],
+        "description": "Details of all the payment methods enabled for the connector for the given merchant account",
+        "required": ["payment_method"],
         "properties": {
-          "product_name": {
-            "type": "string",
-            "description": "Name of the product that is being purchased",
-            "example": "shirt",
-            "maxLength": 255
-          },
-          "quantity": {
-            "type": "integer",
-            "format": "int32",
-            "description": "The quantity of the product to be purchased",
-            "example": 1
-          }
-        }
-      },
-      "PayLaterData": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["klarna_redirect"],
-            "properties": {
-              "klarna_redirect": {
-                "type": "object",
-                "description": "For KlarnaRedirect as PayLater Option",
-                "required": ["billing_email", "billing_country"],
-                "properties": {
-                  "billing_email": {
-                    "type": "string",
-                    "description": "The billing email"
-                  },
-                  "billing_country": {
-                    "$ref": "#/components/schemas/Country"
-                  }
-                }
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["klarna_sdk"],
-            "properties": {
-              "klarna_sdk": {
-                "type": "object",
-                "description": "For Klarna Sdk as PayLater Option",
-                "required": ["token"],
-                "properties": {
-                  "token": {
-                    "type": "string",
-                    "description": "The token for the sdk workflow"
-                  }
-                }
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["affirm_redirect"],
-            "properties": {
-              "affirm_redirect": {
-                "type": "object",
-                "description": "For Affirm redirect as PayLater Option"
-              }
-            }
+          "payment_method": {
+            "$ref": "#/components/schemas/PaymentMethod"
           },
-          {
-            "type": "object",
-            "required": ["afterpay_clearpay_redirect"],
-            "properties": {
-              "afterpay_clearpay_redirect": {
-                "type": "object",
-                "description": "For AfterpayClearpay redirect as PayLater Option",
-                "required": ["billing_email", "billing_name"],
-                "properties": {
-                  "billing_email": {
-                    "type": "string",
-                    "description": "The billing email"
-                  },
-                  "billing_name": {
-                    "type": "string",
-                    "description": "The billing name"
-                  }
-                }
-              }
-            }
+          "payment_method_types": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodType"
+            },
+            "description": "Subtype of payment method",
+            "example": ["credit"],
+            "nullable": true
           }
-        ]
+        }
       },
-      "PayPalWalletData": {
+      "PaymentRetrieveBody": {
         "type": "object",
-        "required": ["token"],
         "properties": {
-          "token": {
+          "merchant_id": {
             "type": "string",
-            "description": "Token generated for the Apple pay"
-          }
-        }
-      },
-      "PaymentExperience": {
-        "type": "string",
-        "enum": [
-          "redirect_to_url",
-          "invoke_sdk_client",
-          "display_qr_code",
-          "one_click",
-          "link_wallet",
-          "invoke_payment_app"
-        ]
-      },
-      "PaymentIdType": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["PaymentIntentId"],
-            "properties": {
-              "PaymentIntentId": {
-                "type": "string",
-                "description": "The identifier for payment intent"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["ConnectorTransactionId"],
-            "properties": {
-              "ConnectorTransactionId": {
-                "type": "string",
-                "description": "The identifier for connector transaction"
-              }
-            }
+            "description": "The identifier for the Merchant Account.",
+            "nullable": true
           },
-          {
-            "type": "object",
-            "required": ["PaymentAttemptId"],
-            "properties": {
-              "PaymentAttemptId": {
-                "type": "string",
-                "description": "The identifier for payment attempt"
-              }
-            }
+          "force_sync": {
+            "type": "boolean",
+            "description": "Decider to enable or disable the connector call for retrieve request",
+            "nullable": true
           }
-        ]
+        }
       },
-      "PaymentListConstraints": {
+      "PaymentsCancelRequest": {
         "type": "object",
-        "required": ["customer_id", "starting_after", "ending_before"],
+        "required": ["merchant_connector_details"],
         "properties": {
-          "customer_id": {
+          "cancellation_reason": {
             "type": "string",
-            "description": "The identifier for customer",
-            "example": "cus_meowuwunwiuwiwqw",
+            "description": "The reason for the payment cancel",
             "nullable": true
           },
-          "starting_after": {
+          "merchant_connector_details": {
+            "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
+          }
+        }
+      },
+      "PaymentsCaptureRequest": {
+        "type": "object",
+        "properties": {
+          "payment_id": {
             "type": "string",
-            "description": "A cursor for use in pagination, fetch the next list after some object",
-            "example": "pay_fafa124123",
+            "description": "The unique identifier for the payment",
             "nullable": true
           },
-          "ending_before": {
+          "merchant_id": {
             "type": "string",
-            "description": "A cursor for use in pagination, fetch the previous list before some object",
-            "example": "pay_fafa124123",
+            "description": "The unique identifier for the merchant",
             "nullable": true
           },
-          "limit": {
+          "amount_to_capture": {
             "type": "integer",
             "format": "int64",
-            "description": "limit on the number of objects to return",
-            "default": 10
-          },
-          "created": {
-            "type": "string",
-            "format": "date-time",
-            "description": "The time at which payment is created",
-            "example": "2022-09-10T10:11:12Z",
+            "description": "The Amount to be captured/ debited from the user's payment method.",
             "nullable": true
           },
-          "created.lt": {
-            "type": "string",
-            "format": "date-time",
-            "description": "Time less than the payment created time",
-            "example": "2022-09-10T10:11:12Z",
+          "refund_uncaptured_amount": {
+            "type": "boolean",
+            "description": "Decider to refund the uncaptured amount",
             "nullable": true
           },
-          "created.gt": {
+          "statement_descriptor_suffix": {
             "type": "string",
-            "format": "date-time",
-            "description": "Time greater than the payment created time",
-            "example": "2022-09-10T10:11:12Z",
+            "description": "Provides information about a card payment that customers see on their statements.",
             "nullable": true
           },
-          "created.lte": {
+          "statement_descriptor_prefix": {
             "type": "string",
-            "format": "date-time",
-            "description": "Time less than or equals to the payment created time",
-            "example": "2022-09-10T10:11:12Z",
+            "description": "Concatenated with the statement descriptor suffix that’s set on the account to form the complete statement descriptor.",
             "nullable": true
           },
-          "created.gte": {
-            "type": "string",
-            "format": "date-time",
-            "description": "Time greater than or equals to the payment created time",
-            "example": "2022-09-10T10:11:12Z",
+          "merchant_connector_details": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
+              }
+            ],
             "nullable": true
           }
         }
       },
-      "PaymentListResponse": {
+      "PaymentsCreateRequest": {
         "type": "object",
-        "required": ["size", "data"],
+        "required": ["amount", "currency"],
         "properties": {
-          "size": {
-            "type": "integer",
-            "description": "The number of payments included in the list"
+          "confirm": {
+            "type": "boolean",
+            "description": "Whether to confirm the payment (if applicable)",
+            "default": false,
+            "example": true,
+            "nullable": true
           },
-          "data": {
+          "merchant_id": {
+            "type": "string",
+            "description": "This is an identifier for the merchant account. This is inferred from the API key\nprovided during the request",
+            "example": "merchant_1668273825",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "customer_id": {
+            "type": "string",
+            "description": "The identifier for the customer object. If not provided the customer ID will be autogenerated.",
+            "example": "cus_y3oqhf46pyzuxjbcn2giaqnb44",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "name": {
+            "type": "string",
+            "description": "description: The customer's name",
+            "example": "John Test",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "connector": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/PaymentsResponse"
-            }
-          }
-        }
-      },
-      "PaymentMethod": {
-        "type": "string",
-        "enum": ["card", "pay_later", "wallet", "bank_redirect"]
-      },
-      "PaymentMethodCreate": {
-        "type": "object",
-        "required": [
-          "payment_method",
-          "payment_method_type",
-          "payment_method_issuer",
-          "payment_method_issuer_code",
-          "card",
-          "metadata",
-          "customer_id",
-          "card_network"
-        ],
-        "properties": {
-          "payment_method": {
-            "$ref": "#/components/schemas/PaymentMethodType"
+              "$ref": "#/components/schemas/Connector"
+            },
+            "description": "This allows the merchant to manually select a connector with which the payment can go through",
+            "example": ["stripe", "adyen"],
+            "nullable": true
           },
-          "payment_method_type": {
+          "phone_country_code": {
+            "type": "string",
+            "description": "The country code for the customer phone number",
+            "example": "+1",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "business_label": {
+            "type": "string",
+            "description": "Business label of the merchant for this payment",
+            "example": "food",
+            "nullable": true
+          },
+          "statement_descriptor_name": {
+            "type": "string",
+            "description": "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.",
+            "example": "Hyperswitch Router",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "payment_experience": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PaymentMethodType"
+                "$ref": "#/components/schemas/PaymentExperience"
               }
             ],
             "nullable": true
           },
-          "payment_method_issuer": {
+          "payment_method_data": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/PaymentMethodData"
+              }
+            ],
+            "nullable": true
+          },
+          "authentication_type": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/AuthenticationType"
+              }
+            ],
+            "nullable": true
+          },
+          "allowed_payment_method_types": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodType"
+            },
+            "description": "Allowed Payment Method Types for a given PaymentIntent",
+            "nullable": true
+          },
+          "capture_method": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CaptureMethod"
+              }
+            ],
+            "nullable": true
+          },
+          "card_cvc": {
             "type": "string",
-            "description": "The name of the bank/ provider issuing the payment method to the end user",
-            "example": "Citibank",
+            "description": "This is used when payment is to be confirmed and the card is not saved",
             "nullable": true
           },
-          "payment_method_issuer_code": {
+          "capture_on": {
+            "type": "string",
+            "format": "date-time",
+            "description": "A timestamp (ISO 8601 code) that determines when the payment should be captured.\nProviding this field will automatically set `capture` to true",
+            "example": "2022-09-10T10:11:12Z",
+            "nullable": true
+          },
+          "mandate_id": {
+            "type": "string",
+            "description": "A unique identifier to link the payment to a mandate, can be use instead of payment_method_data",
+            "example": "mandate_iwer89rnjef349dni3",
+            "nullable": true,
+            "maxLength": 255
+          },
+          "merchant_connector_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/PaymentMethodIssuerCode"
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
               }
             ],
             "nullable": true
           },
-          "card": {
+          "payment_id": {
+            "type": "string",
+            "description": "Unique identifier for the payment. This ensures idempotency for multiple payments\nthat have been done by a single merchant. This field is auto generated and is returned in the API response.",
+            "example": "pay_mbabizu24mvu3mela5njyhpit4",
+            "nullable": true,
+            "maxLength": 30,
+            "minLength": 30
+          },
+          "routing": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/CardDetail"
+                "$ref": "#/components/schemas/RoutingAlgorithm"
               }
             ],
             "nullable": true
           },
-          "metadata": {
-            "type": "object",
-            "description": "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.",
-            "nullable": true
-          },
-          "customer_id": {
-            "type": "string",
-            "description": "The unique identifier of the customer.",
-            "example": "cus_meowerunwiuwiwqw",
+          "off_session": {
+            "type": "boolean",
+            "description": "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`.",
+            "example": true,
             "nullable": true
           },
-          "card_network": {
+          "return_url": {
             "type": "string",
-            "description": "The card network",
-            "example": "Visa",
+            "description": "The URL to redirect after the completion of the operation",
+            "example": "https://hyperswitch.io",
             "nullable": true
-          }
-        }
-      },
-      "PaymentMethodData": {
-        "oneOf": [
-          {
-            "type": "object",
-            "required": ["card"],
-            "properties": {
-              "card": {
-                "$ref": "#/components/schemas/Card"
-              }
-            }
-          },
-          {
-            "type": "object",
-            "required": ["wallet"],
-            "properties": {
-              "wallet": {
-                "$ref": "#/components/schemas/WalletData"
-              }
-            }
           },
-          {
-            "type": "object",
-            "required": ["pay_later"],
-            "properties": {
-              "pay_later": {
-                "$ref": "#/components/schemas/PayLaterData"
-              }
-            }
+          "amount": {
+            "type": "integer",
+            "format": "int64",
+            "description": "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.,",
+            "example": 6540,
+            "nullable": true,
+            "minimum": 0.0
           },
-          {
-            "type": "object",
-            "required": ["bank_redirect"],
-            "properties": {
-              "bank_redirect": {
-                "$ref": "#/components/schemas/BankRedirectData"
+          "setup_future_usage": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/FutureUsage"
               }
-            }
-          }
-        ]
-      },
-      "PaymentMethodDeleteResponse": {
-        "type": "object",
-        "required": ["payment_method_id", "deleted"],
-        "properties": {
-          "payment_method_id": {
-            "type": "string",
-            "description": "The unique identifier of the Payment method",
-            "example": "card_rGK4Vi5iSW70MY7J2mIy"
-          },
-          "deleted": {
-            "type": "boolean",
-            "description": "Whether payment method was deleted or not",
-            "example": true
-          }
-        }
-      },
-      "PaymentMethodIssuerCode": {
-        "type": "string",
-        "enum": [
-          "jp_hdfc",
-          "jp_icici",
-          "jp_googlepay",
-          "jp_applepay",
-          "jp_phonepay",
-          "jp_wechat",
-          "jp_sofort",
-          "jp_giropay",
-          "jp_sepa",
-          "jp_bacs"
-        ]
-      },
-      "PaymentMethodList": {
-        "type": "object",
-        "required": ["payment_method", "payment_method_types"],
-        "properties": {
-          "payment_method": {
-            "$ref": "#/components/schemas/PaymentMethod"
-          },
-          "payment_method_types": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentMethodType"
-            },
-            "description": "This is a sub-category of payment method.",
-            "example": ["credit"],
+            ],
             "nullable": true
-          }
-        }
-      },
-      "PaymentMethodListResponse": {
-        "type": "object",
-        "required": ["redirect_url", "payment_methods"],
-        "properties": {
-          "redirect_url": {
+          },
+          "statement_descriptor_suffix": {
             "type": "string",
-            "description": "Redirect URL of the merchant",
-            "example": "https://www.google.com",
-            "nullable": true
+            "description": "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.",
+            "example": "Payment for shoes purchase",
+            "nullable": true,
+            "maxLength": 255
           },
-          "payment_methods": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentMethodList"
-            },
-            "description": "Information about the payment method",
-            "example": [
+          "shipping": {
+            "allOf": [
               {
-                "payment_method": "wallet",
-                "payment_experience": null,
-                "payment_method_issuers": ["labore magna ipsum", "aute"]
+                "$ref": "#/components/schemas/Address"
               }
-            ]
-          }
-        }
-      },
-      "PaymentMethodResponse": {
-        "type": "object",
-        "required": [
-          "merchant_id",
-          "customer_id",
-          "payment_method_id",
-          "payment_method",
-          "payment_method_type",
-          "card",
-          "recurring_enabled",
-          "installment_payment_enabled",
-          "payment_experience",
-          "metadata"
-        ],
-        "properties": {
-          "merchant_id": {
-            "type": "string",
-            "description": "Unique identifier for a merchant",
-            "example": "merchant_1671528864"
-          },
-          "customer_id": {
-            "type": "string",
-            "description": "The unique identifier of the customer.",
-            "example": "cus_meowerunwiuwiwqw",
+            ],
             "nullable": true
           },
-          "payment_method_id": {
+          "client_secret": {
             "type": "string",
-            "description": "The unique identifier of the Payment method",
-            "example": "card_rGK4Vi5iSW70MY7J2mIy"
-          },
-          "payment_method": {
-            "$ref": "#/components/schemas/PaymentMethodType"
+            "description": "It's a token used for client side verification.",
+            "example": "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo",
+            "nullable": true
           },
           "payment_method_type": {
             "allOf": [
@@ -4501,237 +5685,101 @@
             ],
             "nullable": true
           },
-          "card": {
+          "business_country": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/CardDetailFromLocker"
+                "$ref": "#/components/schemas/CountryAlpha2"
               }
             ],
             "nullable": true
           },
-          "recurring_enabled": {
-            "type": "boolean",
-            "description": "Indicates whether the payment method is eligible for recurring payments",
-            "example": true
-          },
-          "installment_payment_enabled": {
-            "type": "boolean",
-            "description": "Indicates whether the payment method is eligible for installment payments",
-            "example": true
-          },
-          "payment_experience": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentExperience"
-            },
-            "description": "Type of payment experience enabled with the connector",
-            "example": ["redirect_to_url"],
+          "metadata": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/Metadata"
+              }
+            ],
             "nullable": true
           },
-          "metadata": {
-            "type": "object",
-            "description": "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.",
+          "billing": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/Address"
+              }
+            ],
             "nullable": true
           },
-          "created": {
+          "description": {
             "type": "string",
-            "format": "date-time",
-            "description": "A timestamp (ISO 8601 code) that determines when the customer was created",
-            "example": "2023-01-18T11:04:09.922Z",
-            "nullable": true
-          }
-        }
-      },
-      "PaymentMethodType": {
-        "type": "string",
-        "enum": [
-          "credit",
-          "debit",
-          "giropay",
-          "ideal",
-          "sofort",
-          "eps",
-          "klarna",
-          "affirm",
-          "afterpay_clearpay",
-          "google_pay",
-          "apple_pay",
-          "paypal"
-        ]
-      },
-      "PaymentMethodUpdate": {
-        "type": "object",
-        "required": ["card", "card_network", "metadata"],
-        "properties": {
-          "card": {
+            "description": "A description of the payment",
+            "example": "It's my first payment request",
+            "nullable": true
+          },
+          "currency": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/CardDetail"
+                "$ref": "#/components/schemas/Currency"
               }
             ],
             "nullable": true
           },
-          "card_network": {
+          "business_sub_label": {
+            "type": "string",
+            "description": "Business sub label for the payment",
+            "nullable": true
+          },
+          "payment_method": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/CardNetwork"
+                "$ref": "#/components/schemas/PaymentMethod"
               }
             ],
             "nullable": true
           },
-          "metadata": {
-            "type": "object",
-            "description": "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.",
-            "nullable": true
-          }
-        }
-      },
-      "PaymentMethodsEnabled": {
-        "type": "object",
-        "description": "Details of all the payment methods enabled for the connector for the given merchant account",
-        "required": ["payment_method", "payment_method_types"],
-        "properties": {
-          "payment_method": {
-            "$ref": "#/components/schemas/PaymentMethod"
-          },
-          "payment_method_types": {
-            "type": "array",
-            "items": {
-              "$ref": "#/components/schemas/PaymentMethodType"
-            },
-            "description": "Subtype of payment method",
-            "example": ["credit"],
-            "nullable": true
-          }
-        }
-      },
-      "PaymentRetrieveBody": {
-        "type": "object",
-        "required": ["merchant_id", "force_sync"],
-        "properties": {
-          "merchant_id": {
+          "phone": {
             "type": "string",
-            "description": "The identifier for the Merchant Account.",
-            "nullable": true
+            "description": "The customer's phone number",
+            "example": "3141592653",
+            "nullable": true,
+            "maxLength": 255
           },
-          "force_sync": {
-            "type": "boolean",
-            "description": "Decider to enable or disable the connector call for retrieve request",
-            "nullable": true
-          }
-        }
-      },
-      "PaymentsCancelRequest": {
-        "type": "object",
-        "required": ["cancellation_reason"],
-        "properties": {
-          "cancellation_reason": {
+          "payment_token": {
             "type": "string",
-            "description": "The reason for the payment cancel",
+            "description": "Provide a reference to a stored payment method",
+            "example": "187282ab-40ef-47a9-9206-5099ba31e432",
             "nullable": true
           },
-          "merchant_connector_details": {
+          "mandate_data": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
+                "$ref": "#/components/schemas/MandateData"
               }
             ],
             "nullable": true
-          }
-        }
-      },
-      "PaymentsCaptureRequest": {
-        "type": "object",
-        "required": [
-          "payment_id",
-          "merchant_id",
-          "amount_to_capture",
-          "refund_uncaptured_amount",
-          "statement_descriptor_suffix",
-          "statement_descriptor_prefix",
-          "merchant_connector_details"
-        ],
-        "properties": {
-          "payment_id": {
-            "type": "string",
-            "description": "The unique identifier for the payment",
-            "nullable": true
           },
-          "merchant_id": {
-            "type": "string",
-            "description": "The unique identifier for the merchant",
+          "browser_info": {
+            "type": "object",
+            "description": "Additional details required by 3DS 2.0",
             "nullable": true
           },
           "amount_to_capture": {
             "type": "integer",
             "format": "int64",
-            "description": "The Amount to be captured/ debited from the user's payment method.",
-            "nullable": true
-          },
-          "refund_uncaptured_amount": {
-            "type": "boolean",
-            "description": "Decider to refund the uncaptured amount",
-            "nullable": true
-          },
-          "statement_descriptor_suffix": {
-            "type": "string",
-            "description": "Provides information about a card payment that customers see on their statements.",
+            "description": "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.,\nIf not provided, the default amount_to_capture will be the payment amount.",
+            "example": 6540,
             "nullable": true
           },
-          "statement_descriptor_prefix": {
+          "email": {
             "type": "string",
-            "description": "Concatenated with the statement descriptor suffix that’s set on the account to form the complete statement descriptor.",
-            "nullable": true
-          },
-          "merchant_connector_details": {
-            "allOf": [
-              {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
-              }
-            ],
-            "nullable": true
+            "description": "description: The customer's email address",
+            "example": "johntest@test.com",
+            "nullable": true,
+            "maxLength": 255
           }
         }
       },
       "PaymentsRequest": {
         "type": "object",
-        "required": [
-          "merchant_id",
-          "routing",
-          "connector",
-          "currency",
-          "capture_method",
-          "amount_to_capture",
-          "confirm",
-          "customer_id",
-          "email",
-          "name",
-          "phone",
-          "phone_country_code",
-          "off_session",
-          "description",
-          "return_url",
-          "setup_future_usage",
-          "authentication_type",
-          "payment_method_data",
-          "payment_method",
-          "payment_token",
-          "card_cvc",
-          "shipping",
-          "billing",
-          "statement_descriptor_name",
-          "statement_descriptor_suffix",
-          "metadata",
-          "client_secret",
-          "mandate_data",
-          "mandate_id",
-          "browser_info",
-          "payment_experience",
-          "payment_method_type",
-          "business_country",
-          "business_label",
-          "merchant_connector_details"
-        ],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -4753,7 +5801,8 @@
             "format": "int64",
             "description": "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.,",
             "example": 6540,
-            "nullable": true
+            "nullable": true,
+            "minimum": 0.0
           },
           "routing": {
             "allOf": [
@@ -4769,10 +5818,7 @@
               "$ref": "#/components/schemas/Connector"
             },
             "description": "This allows the merchant to manually select a connector with which the payment can go through",
-            "example": [
-              "stripe",
-              "adyen"
-            ],
+            "example": ["stripe", "adyen"],
             "nullable": true
           },
           "currency": {
@@ -4989,9 +6035,11 @@
             "nullable": true
           },
           "business_country": {
-            "type": "string",
-            "description": "Business country of the merchant for this payment",
-            "example": "US",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CountryAlpha2"
+              }
+            ],
             "nullable": true
           },
           "business_label": {
@@ -5003,54 +6051,35 @@
           "merchant_connector_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
               }
             ],
             "nullable": true
+          },
+          "allowed_payment_method_types": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodType"
+            },
+            "description": "Allowed Payment Method Types for a given PaymentIntent",
+            "nullable": true
+          },
+          "business_sub_label": {
+            "type": "string",
+            "description": "Business sub label for the payment",
+            "nullable": true
           }
         }
       },
       "PaymentsResponse": {
         "type": "object",
         "required": [
-          "payment_id",
-          "merchant_id",
           "status",
           "amount",
-          "amount_capturable",
-          "amount_received",
-          "connector",
-          "client_secret",
-          "created",
           "currency",
-          "customer_id",
-          "description",
-          "refunds",
-          "mandate_id",
-          "mandate_data",
-          "setup_future_usage",
-          "off_session",
-          "capture_on",
-          "capture_method",
           "payment_method",
-          "payment_method_data",
-          "payment_token",
-          "shipping",
-          "billing",
-          "metadata",
-          "email",
-          "name",
-          "phone",
-          "return_url",
-          "authentication_type",
-          "statement_descriptor_name",
-          "statement_descriptor_suffix",
-          "next_action",
-          "cancellation_reason",
-          "error_code",
-          "error_message",
-          "payment_experience",
-          "payment_method_type"
+          "business_country",
+          "business_label"
         ],
         "properties": {
           "payment_id": {
@@ -5136,6 +6165,14 @@
             "description": "List of refund that happened on this intent",
             "nullable": true
           },
+          "disputes": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/DisputeResponsePaymentsRetrieve"
+            },
+            "description": "List of dispute that happened on this intent",
+            "nullable": true
+          },
           "mandate_id": {
             "type": "string",
             "description": "A unique identifier to link the payment to a mandate, can be use instead of payment_method_data",
@@ -5307,19 +6344,38 @@
               }
             ],
             "nullable": true
+          },
+          "connector_label": {
+            "type": "string",
+            "description": "The connector used for this payment along with the country and business details",
+            "example": "stripe_US_food",
+            "nullable": true
+          },
+          "business_country": {
+            "$ref": "#/components/schemas/CountryAlpha2"
+          },
+          "business_label": {
+            "type": "string",
+            "description": "The business label of merchant for this payment"
+          },
+          "business_sub_label": {
+            "type": "string",
+            "description": "The business_sub_label for this payment",
+            "nullable": true
+          },
+          "allowed_payment_method_types": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PaymentMethodType"
+            },
+            "description": "Allowed Payment Method Types for a given PaymentIntent",
+            "nullable": true
           }
         }
       },
       "PaymentsRetrieveRequest": {
         "type": "object",
-        "required": [
-          "resource_id",
-          "merchant_id",
-          "force_sync",
-          "param",
-          "connector",
-          "merchant_connector_details"
-        ],
+        "required": ["resource_id", "force_sync"],
         "properties": {
           "resource_id": {
             "$ref": "#/components/schemas/PaymentIdType"
@@ -5346,7 +6402,7 @@
           "merchant_connector_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
               }
             ],
             "nullable": true
@@ -5368,14 +6424,14 @@
           "wallets": {
             "type": "array",
             "items": {
-              "$ref": "#/components/schemas/SupportedWallets"
+              "$ref": "#/components/schemas/PaymentMethodType"
             },
             "description": "The list of the supported wallets"
           },
           "merchant_connector_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
               }
             ],
             "nullable": true
@@ -5436,7 +6492,6 @@
       },
       "PhoneDetails": {
         "type": "object",
-        "required": ["number", "country_code"],
         "properties": {
           "number": {
             "type": "string",
@@ -5452,9 +6507,21 @@
           }
         }
       },
+      "PrimaryBusinessDetails": {
+        "type": "object",
+        "required": ["country", "business"],
+        "properties": {
+          "country": {
+            "$ref": "#/components/schemas/CountryAlpha2"
+          },
+          "business": {
+            "type": "string",
+            "example": "food"
+          }
+        }
+      },
       "RefundListRequest": {
         "type": "object",
-        "required": ["payment_id", "limit"],
         "properties": {
           "payment_id": {
             "type": "string",
@@ -5501,29 +6568,25 @@
       },
       "RefundListResponse": {
         "type": "object",
-        "required": ["data"],
+        "required": ["size", "data"],
         "properties": {
+          "size": {
+            "type": "integer",
+            "description": "The number of refunds included in the list",
+            "minimum": 0.0
+          },
           "data": {
             "type": "array",
             "items": {
               "$ref": "#/components/schemas/RefundResponse"
             },
-            "description": "The list of refund response"
+            "description": "The List of refund response object"
           }
         }
       },
       "RefundRequest": {
         "type": "object",
-        "required": [
-          "refund_id",
-          "payment_id",
-          "merchant_id",
-          "amount",
-          "reason",
-          "refund_type",
-          "metadata",
-          "merchant_connector_details"
-        ],
+        "required": ["payment_id"],
         "properties": {
           "refund_id": {
             "type": "string",
@@ -5578,7 +6641,7 @@
           "merchant_connector_details": {
             "allOf": [
               {
-                "$ref": "#/components/schemas/admin.MerchantConnectorDetailsWrap"
+                "$ref": "#/components/schemas/MerchantConnectorDetailsWrap"
               }
             ],
             "nullable": true
@@ -5592,13 +6655,8 @@
           "payment_id",
           "amount",
           "currency",
-          "reason",
           "status",
-          "metadata",
-          "error_message",
-          "error_code",
-          "created_at",
-          "updated_at"
+          "connector"
         ],
         "properties": {
           "refund_id": {
@@ -5652,6 +6710,11 @@
             "format": "date-time",
             "description": "The timestamp at which refund is updated",
             "nullable": true
+          },
+          "connector": {
+            "type": "string",
+            "description": "The connector used for the refund and the corresponding payment",
+            "example": "stripe"
           }
         }
       },
@@ -5666,7 +6729,6 @@
       },
       "RefundUpdateRequest": {
         "type": "object",
-        "required": ["reason", "metadata"],
         "properties": {
           "reason": {
             "type": "string",
@@ -5689,7 +6751,6 @@
           "key_id",
           "merchant_id",
           "name",
-          "description",
           "prefix",
           "created",
           "expiration"
@@ -5739,8 +6800,14 @@
       "RevokeApiKeyResponse": {
         "type": "object",
         "description": "The response body for revoking an API Key.",
-        "required": ["key_id", "revoked"],
+        "required": ["merchant_id", "key_id", "revoked"],
         "properties": {
+          "merchant_id": {
+            "type": "string",
+            "description": "The identifier for the Merchant Account.",
+            "example": "y3oqhf46pyzuxjbcn2giaqnb44",
+            "maxLength": 64
+          },
           "key_id": {
             "type": "string",
             "description": "The identifier for the API Key.",
@@ -5835,15 +6902,9 @@
           "propertyName": "wallet_name"
         }
       },
-      "SupportedWallets": {
-        "type": "string",
-        "description": "Wallets which support obtaining session object",
-        "enum": ["paypal", "apple_pay", "klarna", "gpay"]
-      },
       "UpdateApiKeyRequest": {
         "type": "object",
         "description": "The request body for updating an API Key.",
-        "required": ["name", "description", "expiration"],
         "properties": {
           "name": {
             "type": "string",
@@ -5873,10 +6934,10 @@
         "oneOf": [
           {
             "type": "object",
-            "required": ["google_pay"],
+            "required": ["ali_pay"],
             "properties": {
-              "google_pay": {
-                "$ref": "#/components/schemas/GooglePayWalletData"
+              "ali_pay": {
+                "$ref": "#/components/schemas/AliPayRedirection"
               }
             }
           },
@@ -5891,10 +6952,28 @@
           },
           {
             "type": "object",
-            "required": ["paypal_sdk"],
+            "required": ["google_pay"],
             "properties": {
-              "paypal_sdk": {
-                "$ref": "#/components/schemas/PayPalWalletData"
+              "google_pay": {
+                "$ref": "#/components/schemas/GooglePayWalletData"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["mb_way"],
+            "properties": {
+              "mb_way": {
+                "$ref": "#/components/schemas/MbWayRedirection"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["mobile_pay"],
+            "properties": {
+              "mobile_pay": {
+                "$ref": "#/components/schemas/MobilePayRedirection"
               }
             }
           },
@@ -5906,20 +6985,32 @@
                 "$ref": "#/components/schemas/PaypalRedirection"
               }
             }
+          },
+          {
+            "type": "object",
+            "required": ["paypal_sdk"],
+            "properties": {
+              "paypal_sdk": {
+                "$ref": "#/components/schemas/PayPalWalletData"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["we_chat_pay_redirect"],
+            "properties": {
+              "we_chat_pay_redirect": {
+                "$ref": "#/components/schemas/WeChatPayRedirection"
+              }
+            }
           }
         ]
       },
+      "WeChatPayRedirection": {
+        "type": "object"
+      },
       "WebhookDetails": {
         "type": "object",
-        "required": [
-          "webhook_version",
-          "webhook_username",
-          "webhook_password",
-          "webhook_url",
-          "payment_created_enabled",
-          "payment_succeeded_enabled",
-          "payment_failed_enabled"
-        ],
         "properties": {
           "webhook_version": {
             "type": "string",
@@ -6024,6 +7115,10 @@
     {
       "name": "Payment Methods",
       "description": "Create and manage payment methods of customers"
+    },
+    {
+      "name": "Disputes",
+      "description": "Manage disputes"
     }
   ]
 }