@gofynd/fdk-client-javascript 1.0.1 → 1.0.3

package/sdk/application/Payment/PaymentApplicationClient.js

@@ -3,76 +3,78 @@ const constructUrl = require("../constructUrl");
 const Paginator = require("../../common/Paginator");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const PaymentValidator = require("./PaymentApplicationValidator");
+const PaymentModel = require("./PaymentApplicationModel");
+const { Logger } = require("./../../common/Logger");
 
 class Payment {
   constructor(_conf) {
     this._conf = _conf;
     this._relativeUrls = {
-      getAggregatorsConfig:
-        "/service/application/payment/v1.0/config/aggregators/key",
+      addBeneficiaryDetails: "/service/application/payment/v1.0/refund/account",
+      addRefundBankAccountUsingOTP:
+        "/service/application/payment/v1.0/refund/account/otp",
       attachCardToCustomer: "/service/application/payment/v1.0/card/attach",
+      cancelPaymentLink:
+        "/service/application/payment/v1.0/cancel-payment-link/",
+      checkAndUpdatePaymentStatus:
+        "/service/application/payment/v1.0/payment/confirm/polling",
+      checkAndUpdatePaymentStatusPaymentLink:
+        "/service/application/payment/v1.0/payment/confirm/polling/link/",
+      checkCredit: "/service/application/payment/v1.0/check-credits/",
+      createOrderHandlerPaymentLink:
+        "/service/application/payment/v1.0/create-order/link/",
+      createPaymentLink:
+        "/service/application/payment/v1.0/create-payment-link/",
+      customerCreditSummary:
+        "/service/application/payment/v1.0/payment/credit-summary/",
+      customerOnboard: "/service/application/payment/v1.0/credit-onboard/",
+      deleteUserCard: "/service/application/payment/v1.0/card/remove",
+      enableOrDisableRefundTransferMode:
+        "/service/application/payment/v1.0/refund/transfer-mode",
       getActiveCardAggregator:
         "/service/application/payment/v1.0/card/aggregator",
+      getActiveRefundTransferModes:
+        "/service/application/payment/v1.0/refund/transfer-mode",
       getActiveUserCards: "/service/application/payment/v1.0/cards",
-      deleteUserCard: "/service/application/payment/v1.0/card/remove",
-      verifyCustomerForPayment:
-        "/service/application/payment/v1.0/payment/customer/validation",
-      verifyAndChargePayment:
-        "/service/application/payment/v1.0/payment/confirm/charge",
-      initialisePayment: "/service/application/payment/v1.0/payment/request",
-      checkAndUpdatePaymentStatus:
-        "/service/application/payment/v1.0/payment/confirm/polling",
+      getAggregatorsConfig:
+        "/service/application/payment/v1.0/config/aggregators/key",
+      getEpaylaterBannerDetails:
+        "/service/application/payment/v1.0/epaylater/banner",
+      getOrderBeneficiariesDetail:
+        "/service/application/payment/v1.0/refund/order/beneficiaries",
+      getPaymentLink: "/service/application/payment/v1.0/create-payment-link/",
       getPaymentModeRoutes: "/service/application/payment/v1.0/payment/options",
+      getPaymentModeRoutesPaymentLink:
+        "/service/application/payment/v1.0/payment/options/link/",
       getPosPaymentModeRoutes:
         "/service/application/payment/v1.0/payment/options/pos",
       getRupifiBannerDetails: "/service/application/payment/v1.0/rupifi/banner",
-      getEpaylaterBannerDetails:
-        "/service/application/payment/v1.0/epaylater/banner",
+      getUserBeneficiariesDetail:
+        "/service/application/payment/v1.0/refund/user/beneficiary",
+      initialisePayment: "/service/application/payment/v1.0/payment/request",
+      initialisePaymentPaymentLink:
+        "/service/application/payment/v1.0/payment/request/link/",
+      pollingPaymentLink:
+        "/service/application/payment/v1.0/polling-payment-link/",
+      redirectToAggregator:
+        "/service/application/payment/v1.0/payment/redirect-to-aggregator/",
+      renderHTML: "/service/application/payment/v1.0/payment/html/render/",
       resendOrCancelPayment:
         "/service/application/payment/v1.0/payment/resend_or_cancel",
-      renderHTML: "/service/application/payment/v1.0/payment/html/render/",
+      resendPaymentLink:
+        "/service/application/payment/v1.0/resend-payment-link/",
+      updateDefaultBeneficiary:
+        "/service/application/payment/v1.0/refund/beneficiary/default",
       validateVPA: "/service/application/payment/v1.0/validate-vpa",
-      getActiveRefundTransferModes:
-        "/service/application/payment/v1.0/refund/transfer-mode",
-      enableOrDisableRefundTransferMode:
-        "/service/application/payment/v1.0/refund/transfer-mode",
-      getUserBeneficiariesDetail:
-        "/service/application/payment/v1.0/refund/user/beneficiary",
+      verifyAndChargePayment:
+        "/service/application/payment/v1.0/payment/confirm/charge",
+      verifyCustomerForPayment:
+        "/service/application/payment/v1.0/payment/customer/validation",
       verifyIfscCode: "/service/application/payment/v1.0/ifsc-code/verify",
-      getOrderBeneficiariesDetail:
-        "/service/application/payment/v1.0/refund/order/beneficiaries",
       verifyOtpAndAddBeneficiaryForBank:
         "/service/application/payment/v1.0/refund/verification/bank",
-      addBeneficiaryDetails: "/service/application/payment/v1.0/refund/account",
-      addRefundBankAccountUsingOTP:
-        "/service/application/payment/v1.0/refund/account/otp",
       verifyOtpAndAddBeneficiaryForWallet:
         "/service/application/payment/v1.0/refund/verification/wallet",
-      updateDefaultBeneficiary:
-        "/service/application/payment/v1.0/refund/beneficiary/default",
-      getPaymentLink: "/service/application/payment/v1.0/create-payment-link/",
-      createPaymentLink:
-        "/service/application/payment/v1.0/create-payment-link/",
-      resendPaymentLink:
-        "/service/application/payment/v1.0/resend-payment-link/",
-      cancelPaymentLink:
-        "/service/application/payment/v1.0/cancel-payment-link/",
-      getPaymentModeRoutesPaymentLink:
-        "/service/application/payment/v1.0/payment/options/link/",
-      pollingPaymentLink:
-        "/service/application/payment/v1.0/polling-payment-link/",
-      createOrderHandlerPaymentLink:
-        "/service/application/payment/v1.0/create-order/link/",
-      initialisePaymentPaymentLink:
-        "/service/application/payment/v1.0/payment/request/link/",
-      checkAndUpdatePaymentStatusPaymentLink:
-        "/service/application/payment/v1.0/payment/confirm/polling/link/",
-      customerCreditSummary:
-        "/service/application/payment/v1.0/payment/credit-summary/",
-      redirectToAggregator:
-        "/service/application/payment/v1.0/payment/redirect-to-aggregator/",
-      checkCredit: "/service/application/payment/v1.0/check-credits/",
-      customerOnboard: "/service/application/payment/v1.0/credit-onboard/",
     };
     this._urls = Object.entries(this._relativeUrls).reduce(
       (urls, [method, relativeUrl]) => {
@@ -92,17 +94,14 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.xApiToken] - Used for basic authentication.
-   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
-   *   to remove temporary cache files on payment gateway and replace with the
-   *   latest one.
-   * @returns {Promise<AggregatorsConfigDetailResponse>} - Success response
-   * @summary: Get payment gateway keys
-   * @description: Use this API to retrieve the payment gateway key, secrets, merchant, SDK/API details to complete a payment at front-end.
+   * @param {AddBeneficiaryDetailsRequest} arg.body
+   * @returns {Promise<RefundAccountResponse>} - Success response
+   * @summary: Save bank details for cancelled/returned order
+   * @description: Use this API to save the bank details for a returned or cancelled order to refund the amount.
    */
-  getAggregatorsConfig({ xApiToken, refresh } = {}) {
-    const { error } = PaymentValidator.getAggregatorsConfig().validate(
-      { xApiToken, refresh },
+  async addBeneficiaryDetails({ body } = {}) {
+    const { error } = PaymentValidator.addBeneficiaryDetails().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -112,43 +111,61 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getAggregatorsConfig().validate(
-      { xApiToken, refresh },
+    } = PaymentValidator.addBeneficiaryDetails().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getAggregatorsConfig");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addBeneficiaryDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["refresh"] = refresh;
 
     const xHeaders = {};
-    xHeaders["x-api-token"] = xApiToken;
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["getAggregatorsConfig"],
+        url: this._urls["addBeneficiaryDetails"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RefundAccountResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addBeneficiaryDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {AttachCardRequest} arg.body
-   * @returns {Promise<AttachCardsResponse>} - Success response
-   * @summary: Attach a saved card to customer.
-   * @description: Use this API to attach a customer's saved card at the payment gateway, such as Stripe, Juspay.
+   * @param {AddBeneficiaryDetailsOTPRequest} arg.body
+   * @returns {Promise<RefundAccountResponse>} - Success response
+   * @summary: Save bank details for cancelled/returned order
+   * @description: Use this API to save bank details for returned/cancelled order to refund amount in his account.
    */
-  attachCardToCustomer({ body } = {}) {
-    const { error } = PaymentValidator.attachCardToCustomer().validate(
+  async addRefundBankAccountUsingOTP({ body } = {}) {
+    const { error } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -159,42 +176,64 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.attachCardToCustomer().validate(
+    } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for attachCardToCustomer");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for addRefundBankAccountUsingOTP",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["attachCardToCustomer"],
+        url: this._urls["addRefundBankAccountUsingOTP"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RefundAccountResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for addRefundBankAccountUsingOTP",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {boolean} [arg.refresh] -
-   * @returns {Promise<ActiveCardPaymentGatewayResponse>} - Success response
-   * @summary: Fetch active payment gateway for card payments
-   * @description: Use this API to retrieve an active payment aggregator along with the Customer ID. This is applicable for cards payments only.
+   * @param {AttachCardRequest} arg.body
+   * @returns {Promise<AttachCardsResponse>} - Success response
+   * @summary: Attach a saved card to customer.
+   * @description: Use this API to attach a customer's saved card at the payment gateway, such as Stripe, Juspay.
    */
-  getActiveCardAggregator({ refresh } = {}) {
-    const { error } = PaymentValidator.getActiveCardAggregator().validate(
-      { refresh },
+  async attachCardToCustomer({ body } = {}) {
+    const { error } = PaymentValidator.attachCardToCustomer().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -204,43 +243,62 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getActiveCardAggregator().validate(
-      { refresh },
+    } = PaymentValidator.attachCardToCustomer().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getActiveCardAggregator");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for attachCardToCustomer",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["refresh"] = refresh;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["getActiveCardAggregator"],
+        url: this._urls["attachCardToCustomer"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.AttachCardsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for attachCardToCustomer",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {boolean} [arg.forceRefresh] -
-   * @returns {Promise<ListCardsResponse>} - Success response
-   * @summary: Fetch the list of cards saved by the user
-   * @description: Use this API to retrieve a list of cards stored by user from an active payment gateway.
+   * @param {CancelOrResendPaymentLinkRequest} arg.body
+   * @returns {Promise<CancelPaymentLinkResponse>} - Success response
+   * @summary: Cancel payment link
+   * @description: Use this API to cancel a payment link for the customer
    */
-  getActiveUserCards({ forceRefresh } = {}) {
-    const { error } = PaymentValidator.getActiveUserCards().validate(
-      { forceRefresh },
+  async cancelPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.cancelPaymentLink().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -248,42 +306,61 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.getActiveUserCards().validate(
-      { forceRefresh },
+    const { error: warrning } = PaymentValidator.cancelPaymentLink().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getActiveUserCards");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for cancelPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["force_refresh"] = forceRefresh;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["getActiveUserCards"],
+        url: this._urls["cancelPaymentLink"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.CancelPaymentLinkResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for cancelPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {DeletehCardRequest} arg.body
-   * @returns {Promise<DeleteCardsResponse>} - Success response
-   * @summary: Delete a card
-   * @description: Use this API to delete a card added by a user on the payment gateway and clear the cache.
+   * @param {PaymentStatusUpdateRequest} arg.body
+   * @returns {Promise<PaymentStatusUpdateResponse>} - Success response
+   * @summary: Performs continuous polling to check status of payment on the server
+   * @description: Use this API to perform continuous polling at intervals to check the status of payment until timeout.
    */
-  deleteUserCard({ body } = {}) {
-    const { error } = PaymentValidator.deleteUserCard().validate(
+  async checkAndUpdatePaymentStatus({ body } = {}) {
+    const { error } = PaymentValidator.checkAndUpdatePaymentStatus().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -292,41 +369,67 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.deleteUserCard().validate(
+    const {
+      error: warrning,
+    } = PaymentValidator.checkAndUpdatePaymentStatus().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for deleteUserCard");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for checkAndUpdatePaymentStatus",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["deleteUserCard"],
+        url: this._urls["checkAndUpdatePaymentStatus"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentStatusUpdateResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for checkAndUpdatePaymentStatus",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {ValidateCustomerRequest} arg.body
-   * @returns {Promise<ValidateCustomerResponse>} - Success response
-   * @summary: Validate customer for payment
-   * @description: Use this API to check if the customer is eligible to use credit-line facilities such as Simpl Pay Later and Rupifi.
+   * @param {PaymentStatusUpdateRequest} arg.body
+   * @returns {Promise<PaymentStatusUpdateResponse>} - Success response
+   * @summary: Performs continuous polling to check status of payment on the server
+   * @description: Use this API to perform continuous polling at intervals to check the status of payment until timeout.
    */
-  verifyCustomerForPayment({ body } = {}) {
-    const { error } = PaymentValidator.verifyCustomerForPayment().validate(
+  async checkAndUpdatePaymentStatusPaymentLink({ body } = {}) {
+    const {
+      error,
+    } = PaymentValidator.checkAndUpdatePaymentStatusPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -337,44 +440,64 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.verifyCustomerForPayment().validate(
+    } = PaymentValidator.checkAndUpdatePaymentStatusPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for verifyCustomerForPayment"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for checkAndUpdatePaymentStatusPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["verifyCustomerForPayment"],
+        url: this._urls["checkAndUpdatePaymentStatusPaymentLink"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentStatusUpdateResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for checkAndUpdatePaymentStatusPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {ChargeCustomerRequest} arg.body
-   * @returns {Promise<ChargeCustomerResponse>} - Success response
-   * @summary: Verify and charge payment
-   * @description: Use this API to verify and check the status of a payment transaction (server-to-server) made through aggregators like Simpl and Mswipe.
+   * @param {string} [arg.aggregator] -
+   * @returns {Promise<CheckCreditResponse>} - Success response
+   * @summary: API to fetch the customer credit summary
+   * @description: Use this API to fetch the customer credit summary.
    */
-  verifyAndChargePayment({ body } = {}) {
-    const { error } = PaymentValidator.verifyAndChargePayment().validate(
-      { body },
+  async checkCredit({ aggregator } = {}) {
+    const { error } = PaymentValidator.checkCredit().validate(
+      { aggregator },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -382,43 +505,62 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.verifyAndChargePayment().validate(
-      { body },
+    const { error: warrning } = PaymentValidator.checkCredit().validate(
+      { aggregator },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for verifyAndChargePayment");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for checkCredit",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["aggregator"] = aggregator;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["verifyAndChargePayment"],
+        url: this._urls["checkCredit"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.CheckCreditResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for checkCredit",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {PaymentInitializationRequest} arg.body
-   * @returns {Promise<PaymentInitializationResponse>} - Success response
-   * @summary: Initialize a payment (server-to-server) for UPI and BharatQR
-   * @description: PUse this API to inititate payment using UPI, BharatQR, wherein the UPI requests are send to the app and QR code is displayed on the screen.
+   * @param {CreateOrderUserRequest} arg.body
+   * @returns {Promise<CreateOrderUserResponse>} - Success response
+   * @summary: Create Order user
+   * @description: Use this API to create a order and payment on aggregator side
    */
-  initialisePayment({ body } = {}) {
-    const { error } = PaymentValidator.initialisePayment().validate(
+  async createOrderHandlerPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.createOrderHandlerPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -427,41 +569,65 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.initialisePayment().validate(
+    const {
+      error: warrning,
+    } = PaymentValidator.createOrderHandlerPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for initialisePayment");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for createOrderHandlerPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["initialisePayment"],
+        url: this._urls["createOrderHandlerPaymentLink"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.CreateOrderUserResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for createOrderHandlerPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {PaymentStatusUpdateRequest} arg.body
-   * @returns {Promise<PaymentStatusUpdateResponse>} - Success response
-   * @summary: Performs continuous polling to check status of payment on the server
-   * @description: Use this API to perform continuous polling at intervals to check the status of payment until timeout.
+   * @param {CreatePaymentLinkRequest} arg.body
+   * @returns {Promise<CreatePaymentLinkResponse>} - Success response
+   * @summary: Create payment link
+   * @description: Use this API to create a payment link for the customer
    */
-  checkAndUpdatePaymentStatus({ body } = {}) {
-    const { error } = PaymentValidator.checkAndUpdatePaymentStatus().validate(
+  async createPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.createPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -470,72 +636,62 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.checkAndUpdatePaymentStatus().validate(
+    const { error: warrning } = PaymentValidator.createPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for checkAndUpdatePaymentStatus"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["checkAndUpdatePaymentStatus"],
+        url: this._urls["createPaymentLink"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.CreatePaymentLinkResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for createPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {number} arg.amount - Payable amount.
-   * @param {string} arg.cartId - Identifier of the cart.
-   * @param {string} arg.pincode - The PIN Code of the destination address, e.g. 400059
-   * @param {string} arg.checkoutMode - Option to checkout for self or for others.
-   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
-   *   to remove temporary cache files on payment gateway and replace with the
-   *   latest one.
-   * @param {string} [arg.cardReference] - Card reference id of user's debit
-   *   or credit card.
-   * @param {string} [arg.userDetails] - URIencoded JSON containing details of
-   *   an anonymous user.
-   * @returns {Promise<PaymentModeRouteResponse>} - Success response
-   * @summary: Get applicable payment options
-   * @description: Use this API to get all valid payment options for doing a payment.
+   * @param {string} [arg.aggregator] -
+   * @returns {Promise<CustomerCreditSummaryResponse>} - Success response
+   * @summary: API to fetch the customer credit summary
+   * @description: Use this API to fetch the customer credit summary.
    */
-  getPaymentModeRoutes({
-    amount,
-    cartId,
-    pincode,
-    checkoutMode,
-    refresh,
-    cardReference,
-    userDetails,
-  } = {}) {
-    const { error } = PaymentValidator.getPaymentModeRoutes().validate(
-      {
-        amount,
-        cartId,
-        pincode,
-        checkoutMode,
-        refresh,
-        cardReference,
-        userDetails,
-      },
+  async customerCreditSummary({ aggregator } = {}) {
+    const { error } = PaymentValidator.customerCreditSummary().validate(
+      { aggregator },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -545,88 +701,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getPaymentModeRoutes().validate(
-      {
-        amount,
-        cartId,
-        pincode,
-        checkoutMode,
-        refresh,
-        cardReference,
-        userDetails,
-      },
+    } = PaymentValidator.customerCreditSummary().validate(
+      { aggregator },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getPaymentModeRoutes");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for customerCreditSummary",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["amount"] = amount;
-    query_params["cart_id"] = cartId;
-    query_params["pincode"] = pincode;
-    query_params["checkout_mode"] = checkoutMode;
-    query_params["refresh"] = refresh;
-    query_params["card_reference"] = cardReference;
-    query_params["user_details"] = userDetails;
+    query_params["aggregator"] = aggregator;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getPaymentModeRoutes"],
+        url: this._urls["customerCreditSummary"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.CustomerCreditSummaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for customerCreditSummary",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {number} arg.amount - Payable amount.
-   * @param {string} arg.cartId - Identifier of the cart.
-   * @param {string} arg.pincode - The PIN Code of the destination address, e.g. 400059
-   * @param {string} arg.checkoutMode - Option to checkout for self or for others.
-   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
-   *   to remove temporary cache files on payment gateway and replace with the
-   *   latest one.
-   * @param {string} [arg.cardReference] - Card reference id of user's debit
-   *   or credit card.
-   * @param {string} arg.orderType - The order type of shipment * HomeDelivery
-   *   - If the customer wants the order home-delivered * PickAtStore - If the
-   *   customer wants the handover of an order at the store itself.
-   * @param {string} [arg.userDetails] - URIencoded JSON containing details of
-   *   an anonymous user.
-   * @returns {Promise<PaymentModeRouteResponse>} - Success response
-   * @summary: Get applicable payment options for Point-of-Sale (POS)
-   * @description: Use this API to get all valid payment options for doing a payment in POS.
+   * @param {CustomerOnboardingRequest} arg.body
+   * @returns {Promise<CustomerOnboardingResponse>} - Success response
+   * @summary: API to fetch the customer credit summary
+   * @description: Use this API to fetch the customer credit summary.
    */
-  getPosPaymentModeRoutes({
-    amount,
-    cartId,
-    pincode,
-    checkoutMode,
-    orderType,
-    refresh,
-    cardReference,
-    userDetails,
-  } = {}) {
-    const { error } = PaymentValidator.getPosPaymentModeRoutes().validate(
-      {
-        amount,
-        cartId,
-        pincode,
-        checkoutMode,
-        orderType,
-        refresh,
-        cardReference,
-        userDetails,
-      },
+  async customerOnboard({ body } = {}) {
+    const { error } = PaymentValidator.customerOnboard().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -634,60 +765,127 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.customerOnboard().validate(
+      { body },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for customerOnboard",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const xHeaders = {};
+
+    const response = await APIClient.execute(
+      this._conf,
+      "post",
+      constructUrl({
+        url: this._urls["customerOnboard"],
+        params: {},
+      }),
+      query_params,
+      body,
+      xHeaders
+    );
+
     const {
-      error: warrning,
-    } = PaymentValidator.getPosPaymentModeRoutes().validate(
-      {
-        amount,
-        cartId,
-        pincode,
-        checkoutMode,
-        orderType,
-        refresh,
-        cardReference,
-        userDetails,
-      },
+      error: res_error,
+    } = PaymentModel.CustomerOnboardingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for customerOnboard",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {DeletehCardRequest} arg.body
+   * @returns {Promise<DeleteCardsResponse>} - Success response
+   * @summary: Delete a card
+   * @description: Use this API to delete a card added by a user on the payment gateway and clear the cache.
+   */
+  async deleteUserCard({ body } = {}) {
+    const { error } = PaymentValidator.deleteUserCard().validate(
+      { body },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.deleteUserCard().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getPosPaymentModeRoutes");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for deleteUserCard",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["amount"] = amount;
-    query_params["cart_id"] = cartId;
-    query_params["pincode"] = pincode;
-    query_params["checkout_mode"] = checkoutMode;
-    query_params["refresh"] = refresh;
-    query_params["card_reference"] = cardReference;
-    query_params["order_type"] = orderType;
-    query_params["user_details"] = userDetails;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["getPosPaymentModeRoutes"],
+        url: this._urls["deleteUserCard"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.DeleteCardsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for deleteUserCard",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @returns {Promise<RupifiBannerResponse>} - Success response
-   * @summary: Get CreditLine Offer
-   * @description: Get CreditLine Offer if user is tentatively approved by rupifi
+   * @param {UpdateRefundTransferModeRequest} arg.body
+   * @returns {Promise<UpdateRefundTransferModeResponse>} - Success response
+   * @summary: Enable/Disable a mode for transferring a refund
+   * @description: Activate or Deactivate Transfer Mode to collect Beneficiary Details for Refund
    */
-  getRupifiBannerDetails({} = {}) {
-    const { error } = PaymentValidator.getRupifiBannerDetails().validate(
-      {},
+  async enableOrDisableRefundTransferMode({ body } = {}) {
+    const {
+      error,
+    } = PaymentValidator.enableOrDisableRefundTransferMode().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -697,41 +895,64 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getRupifiBannerDetails().validate(
-      {},
+    } = PaymentValidator.enableOrDisableRefundTransferMode().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getRupifiBannerDetails");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for enableOrDisableRefundTransferMode",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "put",
       constructUrl({
-        url: this._urls["getRupifiBannerDetails"],
+        url: this._urls["enableOrDisableRefundTransferMode"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.UpdateRefundTransferModeResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for enableOrDisableRefundTransferMode",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @returns {Promise<EpaylaterBannerResponse>} - Success response
-   * @summary: Get Epaylater Enabled
-   * @description: Get Epaylater Enabled if user is tentatively approved by epaylater
+   * @param {boolean} [arg.refresh] -
+   * @returns {Promise<ActiveCardPaymentGatewayResponse>} - Success response
+   * @summary: Fetch active payment gateway for card payments
+   * @description: Use this API to retrieve an active payment aggregator along with the Customer ID. This is applicable for cards payments only.
    */
-  getEpaylaterBannerDetails({} = {}) {
-    const { error } = PaymentValidator.getEpaylaterBannerDetails().validate(
-      {},
+  async getActiveCardAggregator({ refresh } = {}) {
+    const { error } = PaymentValidator.getActiveCardAggregator().validate(
+      { refresh },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -741,44 +962,62 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getEpaylaterBannerDetails().validate(
-      {},
+    } = PaymentValidator.getActiveCardAggregator().validate(
+      { refresh },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for getEpaylaterBannerDetails"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getActiveCardAggregator",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["refresh"] = refresh;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getEpaylaterBannerDetails"],
+        url: this._urls["getActiveCardAggregator"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ActiveCardPaymentGatewayResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getActiveCardAggregator",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {ResendOrCancelPaymentRequest} arg.body
-   * @returns {Promise<ResendOrCancelPaymentResponse>} - Success response
-   * @summary: API to resend and cancel a payment link which was already generated.
-   * @description: Use this API to perform resend or cancel a payment link based on request payload.
+   * @returns {Promise<TransferModeResponse>} - Success response
+   * @summary: Lists the mode of refund
+   * @description: Use this API to retrieve eligible refund modes (such as Netbanking) and add the beneficiary details.
    */
-  resendOrCancelPayment({ body } = {}) {
-    const { error } = PaymentValidator.resendOrCancelPayment().validate(
-      { body },
+  async getActiveRefundTransferModes({} = {}) {
+    const { error } = PaymentValidator.getActiveRefundTransferModes().validate(
+      {},
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -788,42 +1027,64 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.resendOrCancelPayment().validate(
-      { body },
+    } = PaymentValidator.getActiveRefundTransferModes().validate(
+      {},
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for resendOrCancelPayment");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getActiveRefundTransferModes",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["resendOrCancelPayment"],
+        url: this._urls["getActiveRefundTransferModes"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.TransferModeResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getActiveRefundTransferModes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {renderHTMLRequest} arg.body
-   * @returns {Promise<renderHTMLResponse>} - Success response
-   * @summary: Convert base64 string to HTML form
-   * @description: Use this API to decode base64 html form to plain HTML string.
+   * @param {boolean} [arg.forceRefresh] -
+   * @returns {Promise<ListCardsResponse>} - Success response
+   * @summary: Fetch the list of cards saved by the user
+   * @description: Use this API to retrieve a list of cards stored by user from an active payment gateway.
    */
-  renderHTML({ body } = {}) {
-    const { error } = PaymentValidator.renderHTML().validate(
-      { body },
+  async getActiveUserCards({ forceRefresh } = {}) {
+    const { error } = PaymentValidator.getActiveUserCards().validate(
+      { forceRefresh },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -831,42 +1092,66 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.renderHTML().validate(
-      { body },
+    const { error: warrning } = PaymentValidator.getActiveUserCards().validate(
+      { forceRefresh },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for renderHTML");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getActiveUserCards",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["force_refresh"] = forceRefresh;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["renderHTML"],
+        url: this._urls["getActiveUserCards"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ListCardsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getActiveUserCards",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {ValidateVPARequest} arg.body
-   * @returns {Promise<ValidateVPAResponse>} - Success response
-   * @summary: API to Validate UPI ID
-   * @description: API to Validate UPI ID
+   * @param {string} [arg.xApiToken] - Used for basic authentication.
+   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
+   *   to remove temporary cache files on payment gateway and replace with the
+   *   latest one.
+   * @returns {Promise<AggregatorsConfigDetailResponse>} - Success response
+   * @summary: Get payment gateway keys
+   * @description: Use this API to retrieve the payment gateway key, secrets, merchant, SDK/API details to complete a payment at front-end.
    */
-  validateVPA({ body } = {}) {
-    const { error } = PaymentValidator.validateVPA().validate(
-      { body },
+  async getAggregatorsConfig({ xApiToken, refresh } = {}) {
+    const { error } = PaymentValidator.getAggregatorsConfig().validate(
+      { xApiToken, refresh },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -874,40 +1159,64 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.validateVPA().validate(
-      { body },
+    const {
+      error: warrning,
+    } = PaymentValidator.getAggregatorsConfig().validate(
+      { xApiToken, refresh },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for validateVPA");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getAggregatorsConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["refresh"] = refresh;
 
     const xHeaders = {};
+    xHeaders["x-api-token"] = xApiToken;
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["validateVPA"],
+        url: this._urls["getAggregatorsConfig"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.AggregatorsConfigDetailResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getAggregatorsConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @returns {Promise<TransferModeResponse>} - Success response
-   * @summary: Lists the mode of refund
-   * @description: Use this API to retrieve eligible refund modes (such as Netbanking) and add the beneficiary details.
+   * @returns {Promise<EpaylaterBannerResponse>} - Success response
+   * @summary: Get Epaylater Enabled
+   * @description: Get Epaylater Enabled if user is tentatively approved by epaylater
    */
-  getActiveRefundTransferModes({} = {}) {
-    const { error } = PaymentValidator.getActiveRefundTransferModes().validate(
+  async getEpaylaterBannerDetails({} = {}) {
+    const { error } = PaymentValidator.getEpaylaterBannerDetails().validate(
       {},
       { abortEarly: false, allowUnknown: true }
     );
@@ -918,46 +1227,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getActiveRefundTransferModes().validate(
+    } = PaymentValidator.getEpaylaterBannerDetails().validate(
       {},
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for getActiveRefundTransferModes"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEpaylaterBannerDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getActiveRefundTransferModes"],
+        url: this._urls["getEpaylaterBannerDetails"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EpaylaterBannerResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEpaylaterBannerDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {UpdateRefundTransferModeRequest} arg.body
-   * @returns {Promise<UpdateRefundTransferModeResponse>} - Success response
-   * @summary: Enable/Disable a mode for transferring a refund
-   * @description: Activate or Deactivate Transfer Mode to collect Beneficiary Details for Refund
+   * @param {string} arg.orderId - A unique number used for identifying and
+   *   tracking your orders.
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
+   * @summary: Lists the beneficiary of a refund
+   * @description: Use this API to get the details of all active beneficiary added by a user for refund.
    */
-  enableOrDisableRefundTransferMode({ body } = {}) {
-    const {
-      error,
-    } = PaymentValidator.enableOrDisableRefundTransferMode().validate(
-      { body },
+  async getOrderBeneficiariesDetail({ orderId } = {}) {
+    const { error } = PaymentValidator.getOrderBeneficiariesDetail().validate(
+      { orderId },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -967,45 +1293,65 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.enableOrDisableRefundTransferMode().validate(
-      { body },
+    } = PaymentValidator.getOrderBeneficiariesDetail().validate(
+      { orderId },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for enableOrDisableRefundTransferMode"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getOrderBeneficiariesDetail",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["order_id"] = orderId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "put",
+      "get",
       constructUrl({
-        url: this._urls["enableOrDisableRefundTransferMode"],
+        url: this._urls["getOrderBeneficiariesDetail"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getOrderBeneficiariesDetail",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.orderId - A unique number used for identifying and
-   *   tracking your orders.
-   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
-   * @summary: Lists the beneficiary of a refund
-   * @description: Use this API to get the details of all active beneficiary added by a user for refund.
+   * @param {string} [arg.paymentLinkId] -
+   * @returns {Promise<GetPaymentLinkResponse>} - Success response
+   * @summary: Get payment link
+   * @description: Use this API to get a payment link
    */
-  getUserBeneficiariesDetail({ orderId } = {}) {
-    const { error } = PaymentValidator.getUserBeneficiariesDetail().validate(
-      { orderId },
+  async getPaymentLink({ paymentLinkId } = {}) {
+    const { error } = PaymentValidator.getPaymentLink().validate(
+      { paymentLinkId },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1013,48 +1359,89 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getUserBeneficiariesDetail().validate(
-      { orderId },
+    const { error: warrning } = PaymentValidator.getPaymentLink().validate(
+      { paymentLinkId },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for getUserBeneficiariesDetail"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["order_id"] = orderId;
+    query_params["payment_link_id"] = paymentLinkId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getUserBeneficiariesDetail"],
+        url: this._urls["getPaymentLink"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.GetPaymentLinkResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.ifscCode] - A 11-digit alphanumeric code that
-   *   uniquely identifies a bank branch.
-   * @returns {Promise<IfscCodeResponse>} - Success response
-   * @summary: Verify IFSC Code
-   * @description: Use this API to check whether the 11-digit IFSC code is valid and to fetch the bank details for refund.
+   * @param {number} arg.amount - Payable amount.
+   * @param {string} arg.cartId - Identifier of the cart.
+   * @param {string} arg.pincode - The PIN Code of the destination address, e.g. 400059
+   * @param {string} arg.checkoutMode - Option to checkout for self or for others.
+   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
+   *   to remove temporary cache files on payment gateway and replace with the
+   *   latest one.
+   * @param {string} [arg.cardReference] - Card reference id of user's debit
+   *   or credit card.
+   * @param {string} [arg.userDetails] - URIencoded JSON containing details of
+   *   an anonymous user.
+   * @returns {Promise<PaymentModeRouteResponse>} - Success response
+   * @summary: Get applicable payment options
+   * @description: Use this API to get all valid payment options for doing a payment.
    */
-  verifyIfscCode({ ifscCode } = {}) {
-    const { error } = PaymentValidator.verifyIfscCode().validate(
-      { ifscCode },
+  async getPaymentModeRoutes({
+    amount,
+    cartId,
+    pincode,
+    checkoutMode,
+    refresh,
+    cardReference,
+    userDetails,
+  } = {}) {
+    const { error } = PaymentValidator.getPaymentModeRoutes().validate(
+      {
+        amount,
+        cartId,
+        pincode,
+        checkoutMode,
+        refresh,
+        cardReference,
+        userDetails,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1062,44 +1449,81 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.verifyIfscCode().validate(
-      { ifscCode },
+    const {
+      error: warrning,
+    } = PaymentValidator.getPaymentModeRoutes().validate(
+      {
+        amount,
+        cartId,
+        pincode,
+        checkoutMode,
+        refresh,
+        cardReference,
+        userDetails,
+      },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for verifyIfscCode");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["ifsc_code"] = ifscCode;
+    query_params["amount"] = amount;
+    query_params["cart_id"] = cartId;
+    query_params["pincode"] = pincode;
+    query_params["checkout_mode"] = checkoutMode;
+    query_params["refresh"] = refresh;
+    query_params["card_reference"] = cardReference;
+    query_params["user_details"] = userDetails;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["verifyIfscCode"],
+        url: this._urls["getPaymentModeRoutes"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentModeRouteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.orderId - A unique number used for identifying and
-   *   tracking your orders.
-   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
-   * @summary: Lists the beneficiary of a refund
-   * @description: Use this API to get the details of all active beneficiary added by a user for refund.
+   * @param {string} arg.paymentLinkId - Payment link id
+   * @returns {Promise<PaymentModeRouteResponse>} - Success response
+   * @summary: Get applicable payment options for payment link
+   * @description: Use this API to get all valid payment options for doing a payment through payment link
    */
-  getOrderBeneficiariesDetail({ orderId } = {}) {
-    const { error } = PaymentValidator.getOrderBeneficiariesDetail().validate(
-      { orderId },
+  async getPaymentModeRoutesPaymentLink({ paymentLinkId } = {}) {
+    const {
+      error,
+    } = PaymentValidator.getPaymentModeRoutesPaymentLink().validate(
+      { paymentLinkId },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1109,47 +1533,96 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getOrderBeneficiariesDetail().validate(
-      { orderId },
+    } = PaymentValidator.getPaymentModeRoutesPaymentLink().validate(
+      { paymentLinkId },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for getOrderBeneficiariesDetail"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getPaymentModeRoutesPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["order_id"] = orderId;
+    query_params["payment_link_id"] = paymentLinkId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getOrderBeneficiariesDetail"],
+        url: this._urls["getPaymentModeRoutesPaymentLink"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentModeRouteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getPaymentModeRoutesPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {AddBeneficiaryViaOtpVerificationRequest} arg.body
-   * @returns {Promise<AddBeneficiaryViaOtpVerificationResponse>} - Success response
-   * @summary: Verify the beneficiary details using OTP
-   * @description: Use this API to perform an OTP validation before saving the beneficiary details added for a refund.
+   * @param {number} arg.amount - Payable amount.
+   * @param {string} arg.cartId - Identifier of the cart.
+   * @param {string} arg.pincode - The PIN Code of the destination address, e.g. 400059
+   * @param {string} arg.checkoutMode - Option to checkout for self or for others.
+   * @param {boolean} [arg.refresh] - This is a boolean value. Select `true`
+   *   to remove temporary cache files on payment gateway and replace with the
+   *   latest one.
+   * @param {string} [arg.cardReference] - Card reference id of user's debit
+   *   or credit card.
+   * @param {string} arg.orderType - The order type of shipment * HomeDelivery
+   *   - If the customer wants the order home-delivered * PickAtStore - If the
+   *   customer wants the handover of an order at the store itself.
+   * @param {string} [arg.userDetails] - URIencoded JSON containing details of
+   *   an anonymous user.
+   * @returns {Promise<PaymentModeRouteResponse>} - Success response
+   * @summary: Get applicable payment options for Point-of-Sale (POS)
+   * @description: Use this API to get all valid payment options for doing a payment in POS.
    */
-  verifyOtpAndAddBeneficiaryForBank({ body } = {}) {
-    const {
-      error,
-    } = PaymentValidator.verifyOtpAndAddBeneficiaryForBank().validate(
-      { body },
+  async getPosPaymentModeRoutes({
+    amount,
+    cartId,
+    pincode,
+    checkoutMode,
+    orderType,
+    refresh,
+    cardReference,
+    userDetails,
+  } = {}) {
+    const { error } = PaymentValidator.getPosPaymentModeRoutes().validate(
+      {
+        amount,
+        cartId,
+        pincode,
+        checkoutMode,
+        orderType,
+        refresh,
+        cardReference,
+        userDetails,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1159,44 +1632,78 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.verifyOtpAndAddBeneficiaryForBank().validate(
-      { body },
+    } = PaymentValidator.getPosPaymentModeRoutes().validate(
+      {
+        amount,
+        cartId,
+        pincode,
+        checkoutMode,
+        orderType,
+        refresh,
+        cardReference,
+        userDetails,
+      },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for verifyOtpAndAddBeneficiaryForBank"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPosPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["amount"] = amount;
+    query_params["cart_id"] = cartId;
+    query_params["pincode"] = pincode;
+    query_params["checkout_mode"] = checkoutMode;
+    query_params["refresh"] = refresh;
+    query_params["card_reference"] = cardReference;
+    query_params["order_type"] = orderType;
+    query_params["user_details"] = userDetails;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["verifyOtpAndAddBeneficiaryForBank"],
+        url: this._urls["getPosPaymentModeRoutes"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentModeRouteResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPosPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {AddBeneficiaryDetailsRequest} arg.body
-   * @returns {Promise<RefundAccountResponse>} - Success response
-   * @summary: Save bank details for cancelled/returned order
-   * @description: Use this API to save the bank details for a returned or cancelled order to refund the amount.
+   * @returns {Promise<RupifiBannerResponse>} - Success response
+   * @summary: Get CreditLine Offer
+   * @description: Get CreditLine Offer if user is tentatively approved by rupifi
    */
-  addBeneficiaryDetails({ body } = {}) {
-    const { error } = PaymentValidator.addBeneficiaryDetails().validate(
-      { body },
+  async getRupifiBannerDetails({} = {}) {
+    const { error } = PaymentValidator.getRupifiBannerDetails().validate(
+      {},
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1206,42 +1713,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.addBeneficiaryDetails().validate(
-      { body },
+    } = PaymentValidator.getRupifiBannerDetails().validate(
+      {},
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for addBeneficiaryDetails");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getRupifiBannerDetails",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["addBeneficiaryDetails"],
+        url: this._urls["getRupifiBannerDetails"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RupifiBannerResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getRupifiBannerDetails",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {AddBeneficiaryDetailsOTPRequest} arg.body
-   * @returns {Promise<RefundAccountResponse>} - Success response
-   * @summary: Save bank details for cancelled/returned order
-   * @description: Use this API to save bank details for returned/cancelled order to refund amount in his account.
+   * @param {string} arg.orderId - A unique number used for identifying and
+   *   tracking your orders.
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
+   * @summary: Lists the beneficiary of a refund
+   * @description: Use this API to get the details of all active beneficiary added by a user for refund.
    */
-  addRefundBankAccountUsingOTP({ body } = {}) {
-    const { error } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
-      { body },
+  async getUserBeneficiariesDetail({ orderId } = {}) {
+    const { error } = PaymentValidator.getUserBeneficiariesDetail().validate(
+      { orderId },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1251,45 +1779,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
-      { body },
+    } = PaymentValidator.getUserBeneficiariesDetail().validate(
+      { orderId },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for addRefundBankAccountUsingOTP"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getUserBeneficiariesDetail",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["order_id"] = orderId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["addRefundBankAccountUsingOTP"],
+        url: this._urls["getUserBeneficiariesDetail"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserBeneficiariesDetail",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {WalletOtpRequest} arg.body
-   * @returns {Promise<WalletOtpResponse>} - Success response
-   * @summary: Send OTP on adding a wallet beneficiary
-   * @description: Use this API to send an OTP while adding a wallet beneficiary by mobile no. verification.
+   * @param {PaymentInitializationRequest} arg.body
+   * @returns {Promise<PaymentInitializationResponse>} - Success response
+   * @summary: Initialize a payment (server-to-server) for UPI and BharatQR
+   * @description: PUse this API to inititate payment using UPI, BharatQR, wherein the UPI requests are send to the app and QR code is displayed on the screen.
    */
-  verifyOtpAndAddBeneficiaryForWallet({ body } = {}) {
-    const {
-      error,
-    } = PaymentValidator.verifyOtpAndAddBeneficiaryForWallet().validate(
+  async initialisePayment({ body } = {}) {
+    const { error } = PaymentValidator.initialisePayment().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1298,45 +1844,61 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.verifyOtpAndAddBeneficiaryForWallet().validate(
+    const { error: warrning } = PaymentValidator.initialisePayment().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for verifyOtpAndAddBeneficiaryForWallet"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for initialisePayment",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["verifyOtpAndAddBeneficiaryForWallet"],
+        url: this._urls["initialisePayment"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentInitializationResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for initialisePayment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {SetDefaultBeneficiaryRequest} arg.body
-   * @returns {Promise<SetDefaultBeneficiaryResponse>} - Success response
-   * @summary: Set a default beneficiary for a refund
-   * @description: Use this API to set a default beneficiary for getting a refund.
+   * @param {PaymentInitializationRequest} arg.body
+   * @returns {Promise<PaymentInitializationResponse>} - Success response
+   * @summary: Initialize a payment (server-to-server) for UPI and BharatQR
+   * @description: Use this API to inititate payment using UPI, BharatQR, wherein the UPI requests are send to the app and QR code is displayed on the screen.
    */
-  updateDefaultBeneficiary({ body } = {}) {
-    const { error } = PaymentValidator.updateDefaultBeneficiary().validate(
+  async initialisePaymentPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.initialisePaymentPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1347,43 +1909,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.updateDefaultBeneficiary().validate(
+    } = PaymentValidator.initialisePaymentPaymentLink().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for updateDefaultBeneficiary"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for initialisePaymentPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["updateDefaultBeneficiary"],
+        url: this._urls["initialisePaymentPaymentLink"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentInitializationResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for initialisePaymentPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} [arg.paymentLinkId] -
-   * @returns {Promise<GetPaymentLinkResponse>} - Success response
-   * @summary: Get payment link
-   * @description: Use this API to get a payment link
+   * @returns {Promise<PollingPaymentLinkResponse>} - Success response
+   * @summary: Used for polling if payment successful or not
+   * @description: Use this API to poll if payment through payment was successful or not
    */
-  getPaymentLink({ paymentLinkId } = {}) {
-    const { error } = PaymentValidator.getPaymentLink().validate(
+  async pollingPaymentLink({ paymentLinkId } = {}) {
+    const { error } = PaymentValidator.pollingPaymentLink().validate(
       { paymentLinkId },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1392,13 +1974,16 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.getPaymentLink().validate(
+    const { error: warrning } = PaymentValidator.pollingPaymentLink().validate(
       { paymentLinkId },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for getPaymentLink");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for pollingPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
@@ -1406,72 +1991,49 @@ class Payment {
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["getPaymentLink"],
+        url: this._urls["pollingPaymentLink"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
-  }
 
-  /**
-   * @param {Object} arg - Arg object.
-   * @param {CreatePaymentLinkRequest} arg.body
-   * @returns {Promise<CreatePaymentLinkResponse>} - Success response
-   * @summary: Create payment link
-   * @description: Use this API to create a payment link for the customer
-   */
-  createPaymentLink({ body } = {}) {
-    const { error } = PaymentValidator.createPaymentLink().validate(
-      { body },
-      { abortEarly: false, allowUnknown: true }
-    );
-    if (error) {
-      return Promise.reject(new FDKClientValidationError(error));
-    }
+    const {
+      error: res_error,
+    } = PaymentModel.PollingPaymentLinkResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
 
-    // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.createPaymentLink().validate(
-      { body },
-      { abortEarly: false, allowUnknown: false }
-    );
-    if (warrning) {
-      console.log("Parameter Validation warrnings for createPaymentLink");
-      console.log(warrning);
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for pollingPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
     }
 
-    const query_params = {};
-
-    const xHeaders = {};
-
-    return APIClient.execute(
-      this._conf,
-      "post",
-      constructUrl({
-        url: this._urls["createPaymentLink"],
-        params: {},
-      }),
-      query_params,
-      body,
-      xHeaders
-    );
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CancelOrResendPaymentLinkRequest} arg.body
-   * @returns {Promise<ResendPaymentLinkResponse>} - Success response
-   * @summary: Resend payment link
-   * @description: Use this API to resend a payment link for the customer
+   * @param {string} [arg.source] - This is a String value that contains
+   *   callback URL as value.
+   * @param {string} [arg.aggregator] - This is a String value that contains
+   *   aggregator name as value.
+   * @returns {Promise<RedirectToAggregatorResponse>} - Success response
+   * @summary: API to get the redirect url to redirect the user to aggregator's page
+   * @description: Use this API to get the redirect url to redirect the user to aggregator's page
    */
-  resendPaymentLink({ body } = {}) {
-    const { error } = PaymentValidator.resendPaymentLink().validate(
-      { body },
+  async redirectToAggregator({ source, aggregator } = {}) {
+    const { error } = PaymentValidator.redirectToAggregator().validate(
+      { source, aggregator },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1479,41 +2041,65 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.resendPaymentLink().validate(
-      { body },
+    const {
+      error: warrning,
+    } = PaymentValidator.redirectToAggregator().validate(
+      { source, aggregator },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for resendPaymentLink");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for redirectToAggregator",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["source"] = source;
+    query_params["aggregator"] = aggregator;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "post",
+      "get",
       constructUrl({
-        url: this._urls["resendPaymentLink"],
+        url: this._urls["redirectToAggregator"],
         params: {},
       }),
       query_params,
-      body,
+      undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RedirectToAggregatorResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for redirectToAggregator",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CancelOrResendPaymentLinkRequest} arg.body
-   * @returns {Promise<CancelPaymentLinkResponse>} - Success response
-   * @summary: Cancel payment link
-   * @description: Use this API to cancel a payment link for the customer
+   * @param {renderHTMLRequest} arg.body
+   * @returns {Promise<renderHTMLResponse>} - Success response
+   * @summary: Convert base64 string to HTML form
+   * @description: Use this API to decode base64 html form to plain HTML string.
    */
-  cancelPaymentLink({ body } = {}) {
-    const { error } = PaymentValidator.cancelPaymentLink().validate(
+  async renderHTML({ body } = {}) {
+    const { error } = PaymentValidator.renderHTML().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1522,44 +2108,62 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.cancelPaymentLink().validate(
+    const { error: warrning } = PaymentValidator.renderHTML().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for cancelPaymentLink");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for renderHTML",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["cancelPaymentLink"],
+        url: this._urls["renderHTML"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.renderHTMLResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for renderHTML",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.paymentLinkId - Payment link id
-   * @returns {Promise<PaymentModeRouteResponse>} - Success response
-   * @summary: Get applicable payment options for payment link
-   * @description: Use this API to get all valid payment options for doing a payment through payment link
+   * @param {ResendOrCancelPaymentRequest} arg.body
+   * @returns {Promise<ResendOrCancelPaymentResponse>} - Success response
+   * @summary: API to resend and cancel a payment link which was already generated.
+   * @description: Use this API to perform resend or cancel a payment link based on request payload.
    */
-  getPaymentModeRoutesPaymentLink({ paymentLinkId } = {}) {
-    const {
-      error,
-    } = PaymentValidator.getPaymentModeRoutesPaymentLink().validate(
-      { paymentLinkId },
+  async resendOrCancelPayment({ body } = {}) {
+    const { error } = PaymentValidator.resendOrCancelPayment().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1569,45 +2173,62 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getPaymentModeRoutesPaymentLink().validate(
-      { paymentLinkId },
+    } = PaymentValidator.resendOrCancelPayment().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for getPaymentModeRoutesPaymentLink"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for resendOrCancelPayment",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["payment_link_id"] = paymentLinkId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["getPaymentModeRoutesPaymentLink"],
+        url: this._urls["resendOrCancelPayment"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ResendOrCancelPaymentResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for resendOrCancelPayment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.paymentLinkId] -
-   * @returns {Promise<PollingPaymentLinkResponse>} - Success response
-   * @summary: Used for polling if payment successful or not
-   * @description: Use this API to poll if payment through payment was successful or not
+   * @param {CancelOrResendPaymentLinkRequest} arg.body
+   * @returns {Promise<ResendPaymentLinkResponse>} - Success response
+   * @summary: Resend payment link
+   * @description: Use this API to resend a payment link for the customer
    */
-  pollingPaymentLink({ paymentLinkId } = {}) {
-    const { error } = PaymentValidator.pollingPaymentLink().validate(
-      { paymentLinkId },
+  async resendPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.resendPaymentLink().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1615,42 +2236,61 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.pollingPaymentLink().validate(
-      { paymentLinkId },
+    const { error: warrning } = PaymentValidator.resendPaymentLink().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for pollingPaymentLink");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for resendPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["payment_link_id"] = paymentLinkId;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["pollingPaymentLink"],
+        url: this._urls["resendPaymentLink"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ResendPaymentLinkResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for resendPaymentLink",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CreateOrderUserRequest} arg.body
-   * @returns {Promise<CreateOrderUserResponse>} - Success response
-   * @summary: Create Order user
-   * @description: Use this API to create a order and payment on aggregator side
+   * @param {SetDefaultBeneficiaryRequest} arg.body
+   * @returns {Promise<SetDefaultBeneficiaryResponse>} - Success response
+   * @summary: Set a default beneficiary for a refund
+   * @description: Use this API to set a default beneficiary for getting a refund.
    */
-  createOrderHandlerPaymentLink({ body } = {}) {
-    const { error } = PaymentValidator.createOrderHandlerPaymentLink().validate(
+  async updateDefaultBeneficiary({ body } = {}) {
+    const { error } = PaymentValidator.updateDefaultBeneficiary().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1661,43 +2301,61 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.createOrderHandlerPaymentLink().validate(
+    } = PaymentValidator.updateDefaultBeneficiary().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for createOrderHandlerPaymentLink"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for updateDefaultBeneficiary",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["createOrderHandlerPaymentLink"],
+        url: this._urls["updateDefaultBeneficiary"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.SetDefaultBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for updateDefaultBeneficiary",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {PaymentInitializationRequest} arg.body
-   * @returns {Promise<PaymentInitializationResponse>} - Success response
-   * @summary: Initialize a payment (server-to-server) for UPI and BharatQR
-   * @description: Use this API to inititate payment using UPI, BharatQR, wherein the UPI requests are send to the app and QR code is displayed on the screen.
+   * @param {ValidateVPARequest} arg.body
+   * @returns {Promise<ValidateVPAResponse>} - Success response
+   * @summary: API to Validate UPI ID
+   * @description: API to Validate UPI ID
    */
-  initialisePaymentPaymentLink({ body } = {}) {
-    const { error } = PaymentValidator.initialisePaymentPaymentLink().validate(
+  async validateVPA({ body } = {}) {
+    const { error } = PaymentValidator.validateVPA().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1706,47 +2364,61 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.initialisePaymentPaymentLink().validate(
+    const { error: warrning } = PaymentValidator.validateVPA().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for initialisePaymentPaymentLink"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for validateVPA",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["initialisePaymentPaymentLink"],
+        url: this._urls["validateVPA"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ValidateVPAResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for validateVPA",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {PaymentStatusUpdateRequest} arg.body
-   * @returns {Promise<PaymentStatusUpdateResponse>} - Success response
-   * @summary: Performs continuous polling to check status of payment on the server
-   * @description: Use this API to perform continuous polling at intervals to check the status of payment until timeout.
+   * @param {ChargeCustomerRequest} arg.body
+   * @returns {Promise<ChargeCustomerResponse>} - Success response
+   * @summary: Verify and charge payment
+   * @description: Use this API to verify and check the status of a payment transaction (server-to-server) made through aggregators like Simpl and Mswipe.
    */
-  checkAndUpdatePaymentStatusPaymentLink({ body } = {}) {
-    const {
-      error,
-    } = PaymentValidator.checkAndUpdatePaymentStatusPaymentLink().validate(
+  async verifyAndChargePayment({ body } = {}) {
+    const { error } = PaymentValidator.verifyAndChargePayment().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1757,44 +2429,62 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.checkAndUpdatePaymentStatusPaymentLink().validate(
+    } = PaymentValidator.verifyAndChargePayment().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log(
-        "Parameter Validation warrnings for checkAndUpdatePaymentStatusPaymentLink"
-      );
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for verifyAndChargePayment",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["checkAndUpdatePaymentStatusPaymentLink"],
+        url: this._urls["verifyAndChargePayment"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ChargeCustomerResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for verifyAndChargePayment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.aggregator] -
-   * @returns {Promise<CustomerCreditSummaryResponse>} - Success response
-   * @summary: API to fetch the customer credit summary
-   * @description: Use this API to fetch the customer credit summary.
+   * @param {ValidateCustomerRequest} arg.body
+   * @returns {Promise<ValidateCustomerResponse>} - Success response
+   * @summary: Validate customer for payment
+   * @description: Use this API to check if the customer is eligible to use credit-line facilities such as Simpl Pay Later and Rupifi.
    */
-  customerCreditSummary({ aggregator } = {}) {
-    const { error } = PaymentValidator.customerCreditSummary().validate(
-      { aggregator },
+  async verifyCustomerForPayment({ body } = {}) {
+    const { error } = PaymentValidator.verifyCustomerForPayment().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1804,46 +2494,63 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.customerCreditSummary().validate(
-      { aggregator },
+    } = PaymentValidator.verifyCustomerForPayment().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for customerCreditSummary");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for verifyCustomerForPayment",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["aggregator"] = aggregator;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["customerCreditSummary"],
+        url: this._urls["verifyCustomerForPayment"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.ValidateCustomerResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for verifyCustomerForPayment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.source] - This is a String value that contains
-   *   callback URL as value.
-   * @param {string} [arg.aggregator] - This is a String value that contains
-   *   aggregator name as value.
-   * @returns {Promise<RedirectToAggregatorResponse>} - Success response
-   * @summary: API to get the redirect url to redirect the user to aggregator's page
-   * @description: Use this API to get the redirect url to redirect the user to aggregator's page
+   * @param {string} [arg.ifscCode] - A 11-digit alphanumeric code that
+   *   uniquely identifies a bank branch.
+   * @returns {Promise<IfscCodeResponse>} - Success response
+   * @summary: Verify IFSC Code
+   * @description: Use this API to check whether the 11-digit IFSC code is valid and to fetch the bank details for refund.
    */
-  redirectToAggregator({ source, aggregator } = {}) {
-    const { error } = PaymentValidator.redirectToAggregator().validate(
-      { source, aggregator },
+  async verifyIfscCode({ ifscCode } = {}) {
+    const { error } = PaymentValidator.verifyIfscCode().validate(
+      { ifscCode },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1851,46 +2558,65 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.redirectToAggregator().validate(
-      { source, aggregator },
+    const { error: warrning } = PaymentValidator.verifyIfscCode().validate(
+      { ifscCode },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for redirectToAggregator");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for verifyIfscCode",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["source"] = source;
-    query_params["aggregator"] = aggregator;
+    query_params["ifsc_code"] = ifscCode;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "get",
       constructUrl({
-        url: this._urls["redirectToAggregator"],
+        url: this._urls["verifyIfscCode"],
         params: {},
       }),
       query_params,
       undefined,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.IfscCodeResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for verifyIfscCode",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} [arg.aggregator] -
-   * @returns {Promise<CheckCreditResponse>} - Success response
-   * @summary: API to fetch the customer credit summary
-   * @description: Use this API to fetch the customer credit summary.
+   * @param {AddBeneficiaryViaOtpVerificationRequest} arg.body
+   * @returns {Promise<AddBeneficiaryViaOtpVerificationResponse>} - Success response
+   * @summary: Verify the beneficiary details using OTP
+   * @description: Use this API to perform an OTP validation before saving the beneficiary details added for a refund.
    */
-  checkCredit({ aggregator } = {}) {
-    const { error } = PaymentValidator.checkCredit().validate(
-      { aggregator },
+  async verifyOtpAndAddBeneficiaryForBank({ body } = {}) {
+    const {
+      error,
+    } = PaymentValidator.verifyOtpAndAddBeneficiaryForBank().validate(
+      { body },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -1898,42 +2624,67 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.checkCredit().validate(
-      { aggregator },
+    const {
+      error: warrning,
+    } = PaymentValidator.verifyOtpAndAddBeneficiaryForBank().validate(
+      { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for checkCredit");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for verifyOtpAndAddBeneficiaryForBank",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["aggregator"] = aggregator;
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
-      "get",
+      "post",
       constructUrl({
-        url: this._urls["checkCredit"],
+        url: this._urls["verifyOtpAndAddBeneficiaryForBank"],
         params: {},
       }),
       query_params,
-      undefined,
+      body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.AddBeneficiaryViaOtpVerificationResponse().validate(
+      response,
+      { abortEarly: false, allowUnknown: false }
+    );
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for verifyOtpAndAddBeneficiaryForBank",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {CustomerOnboardingRequest} arg.body
-   * @returns {Promise<CustomerOnboardingResponse>} - Success response
-   * @summary: API to fetch the customer credit summary
-   * @description: Use this API to fetch the customer credit summary.
+   * @param {WalletOtpRequest} arg.body
+   * @returns {Promise<WalletOtpResponse>} - Success response
+   * @summary: Send OTP on adding a wallet beneficiary
+   * @description: Use this API to send an OTP while adding a wallet beneficiary by mobile no. verification.
    */
-  customerOnboard({ body } = {}) {
-    const { error } = PaymentValidator.customerOnboard().validate(
+  async verifyOtpAndAddBeneficiaryForWallet({ body } = {}) {
+    const {
+      error,
+    } = PaymentValidator.verifyOtpAndAddBeneficiaryForWallet().validate(
       { body },
       { abortEarly: false, allowUnknown: true }
     );
@@ -1942,30 +2693,54 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.customerOnboard().validate(
+    const {
+      error: warrning,
+    } = PaymentValidator.verifyOtpAndAddBeneficiaryForWallet().validate(
       { body },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
-      console.log("Parameter Validation warrnings for customerOnboard");
-      console.log(warrning);
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for verifyOtpAndAddBeneficiaryForWallet",
+      });
+      Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
 
     const xHeaders = {};
 
-    return APIClient.execute(
+    const response = await APIClient.execute(
       this._conf,
       "post",
       constructUrl({
-        url: this._urls["customerOnboard"],
+        url: this._urls["verifyOtpAndAddBeneficiaryForWallet"],
         params: {},
       }),
       query_params,
       body,
       xHeaders
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.WalletOtpResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for verifyOtpAndAddBeneficiaryForWallet",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }