@gofynd/fdk-client-javascript 1.1.2 → 1.1.4

package/sdk/platform/Payment/PaymentPlatformApplicationClient.js

@@ -12,6 +12,70 @@ class Payment {
     this.applicationId = applicationId;
   }
 
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.terminalUniqueIdentifier - Terminal unique identifier
+   * @param {EdcUpdateRequest} arg.body
+   * @returns {Promise<EdcDeviceUpdateResponse>} - Success response
+   * @summary: Update store id and device tag of edc device
+   * @description: Use this API to Update store id and device tag of edc device
+   */
+  async addEdcDevice({ terminalUniqueIdentifier, body } = {}) {
+    const { error } = PaymentValidator.addEdcDevice().validate(
+      {
+        terminalUniqueIdentifier,
+        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.addEdcDevice().validate(
+      {
+        terminalUniqueIdentifier,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for addEdcDevice",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "put",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-device/${terminalUniqueIdentifier}`,
+      query_params,
+      body
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EdcDeviceUpdateResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for addEdcDevice",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
   /**
    * @param {Object} arg - Arg object.
    * @param {AddBeneficiaryDetailsOTPRequest} arg.body
@@ -77,6 +141,132 @@ class Payment {
     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
+   */
+  async cancelPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.cancelPaymentLink().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.cancelPaymentLink().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for cancelPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/cancel-payment-link/`,
+      query_params,
+      body
+    );
+
+    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 {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.
+   */
+  async checkAndUpdatePaymentStatus({ body } = {}) {
+    const { error } = PaymentValidator.checkAndUpdatePaymentStatus().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.checkAndUpdatePaymentStatus().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for checkAndUpdatePaymentStatus",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/confirm/polling`,
+      query_params,
+      body
+    );
+
+    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 {PaymentConfirmationRequest} arg.body
@@ -140,22 +330,1144 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.orderId -
-   * @param {string} [arg.requestHash] -
-   * @returns {Promise<RefundAccountResponse>} - Success response
-   * @summary: Get bank details
-   * @description: Use this API to get saved bank details for returned/cancelled order using order id.
+   * @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
    */
-  async getBankAccountDetailsOpenAPI({
-    orderId,
+  async createPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.createPaymentLink().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
 
-    requestHash,
-  } = {}) {
-    const { error } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.createPaymentLink().validate(
       {
-        orderId,
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for createPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
 
-        requestHash,
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/create-payment-link/`,
+      query_params,
+      body
+    );
+
+    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.
+   * @returns {Promise<EdcAggregatorAndModelListResponse>} - Success response
+   * @summary: get some information about the store and edc device
+   * @description: Use this API to get info of devices linked to a particular app.
+   */
+  async edcAggregatorsAndModelList({} = {}) {
+    const { error } = PaymentValidator.edcAggregatorsAndModelList().validate(
+      {},
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.edcAggregatorsAndModelList().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for edcAggregatorsAndModelList",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-aggregator-list`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EdcAggregatorAndModelListResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for edcAggregatorsAndModelList",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {number} [arg.pageNo] -
+   * @param {number} [arg.pageSize] -
+   * @param {boolean} [arg.isActive] -
+   * @param {number} [arg.storeId] -
+   * @param {string} [arg.deviceTag] -
+   * @returns {Promise<EdcDeviceListResponse>} - Success response
+   * @summary: get all the device list of an app
+   * @description: Use this API to get all devices linked to a particular app.
+   */
+  async edcDeviceList({ pageNo, pageSize, isActive, storeId, deviceTag } = {}) {
+    const { error } = PaymentValidator.edcDeviceList().validate(
+      {
+        pageNo,
+        pageSize,
+        isActive,
+        storeId,
+        deviceTag,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.edcDeviceList().validate(
+      {
+        pageNo,
+        pageSize,
+        isActive,
+        storeId,
+        deviceTag,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for edcDeviceList",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["page_no"] = pageNo;
+    query_params["page_size"] = pageSize;
+    query_params["is_active"] = isActive;
+    query_params["store_id"] = storeId;
+    query_params["device_tag"] = deviceTag;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-device-list`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EdcDeviceListResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for edcDeviceList",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @returns {Promise<EdcDeviceStatsResponse>} - Success response
+   * @summary: get some information about the store and edc device
+   * @description: Use this API to get info of devices linked to a particular app.
+   */
+  async edcDeviceStats({} = {}) {
+    const { error } = PaymentValidator.edcDeviceStats().validate(
+      {},
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.edcDeviceStats().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for edcDeviceStats",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-device-stats`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EdcDeviceStatsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for edcDeviceStats",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.orderId -
+   * @param {string} [arg.requestHash] -
+   * @returns {Promise<RefundAccountResponse>} - Success response
+   * @summary: Get bank details
+   * @description: Use this API to get saved bank details for returned/cancelled order using order id.
+   */
+  async getBankAccountDetailsOpenAPI({
+    orderId,
+
+    requestHash,
+  } = {}) {
+    const { error } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
+      {
+        orderId,
+
+        requestHash,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
+      {
+        orderId,
+
+        requestHash,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getBankAccountDetailsOpenAPI",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["order_id"] = orderId;
+    query_params["request_hash"] = requestHash;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/account`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RefundAccountResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getBankAccountDetailsOpenAPI",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @returns {Promise<PaymentGatewayConfigResponse>} - Success response
+   * @summary: Get All Brand Payment Gateway Config Secret
+   * @description: Get All Brand Payment Gateway Config Secret
+   */
+  async getBrandPaymentGatewayConfig({} = {}) {
+    const { error } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentGatewayConfigResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.terminalUniqueIdentifier - Terminal unique identifier
+   * @returns {Promise<EdcDeviceDetailsResponse>} - Success response
+   * @summary: get details of a single edc device
+   * @description: Use this API to get details of a single edc device
+   */
+  async getEdcDevice({ terminalUniqueIdentifier } = {}) {
+    const { error } = PaymentValidator.getEdcDevice().validate(
+      {
+        terminalUniqueIdentifier,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.getEdcDevice().validate(
+      {
+        terminalUniqueIdentifier,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getEdcDevice",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-device/${terminalUniqueIdentifier}`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.EdcDeviceDetailsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getEdcDevice",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @returns {Promise<GetPaymentCodeResponse>} - Success response
+   * @summary: List Payment Options Method Codes
+   * @description: Get all active List Payment Options Method Codes
+   */
+  async getPaymentCodeOption({} = {}) {
+    const { error } = PaymentValidator.getPaymentCodeOption().validate(
+      {},
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getPaymentCodeOption().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentCodeOption",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/codes`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.GetPaymentCodeResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPaymentCodeOption",
+      });
+      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
+   */
+  async getPaymentLink({ paymentLinkId } = {}) {
+    const { error } = PaymentValidator.getPaymentLink().validate(
+      {
+        paymentLinkId,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.getPaymentLink().validate(
+      {
+        paymentLinkId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentLink",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["payment_link_id"] = paymentLinkId;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/create-payment-link/`,
+      query_params,
+      undefined
+    );
+
+    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 {boolean} arg.refresh -
+   * @param {string} arg.requestType -
+   * @returns {Promise<PaymentOptionsResponse>} - Success response
+   * @summary: Get All Valid Payment Options
+   * @description: Use this API to get Get All Valid Payment Options for making payment
+   */
+  async getPaymentModeRoutes({ refresh, requestType } = {}) {
+    const { error } = PaymentValidator.getPaymentModeRoutes().validate(
+      {
+        refresh,
+        requestType,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getPaymentModeRoutes().validate(
+      {
+        refresh,
+        requestType,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["refresh"] = refresh;
+    query_params["request_type"] = requestType;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/options`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentOptionsResponse().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 {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<PaymentOptionsResponse>} - Success response
+   * @summary: Get All Valid Payment Options
+   * @description: Use this API to get Get All Valid Payment Options for making payment
+   */
+  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) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getPosPaymentModeRoutes().validate(
+      {
+        amount,
+        cartId,
+        pincode,
+        checkoutMode,
+        orderType,
+        refresh,
+        cardReference,
+        userDetails,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (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 response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/options/pos`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentOptionsResponse().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 {string} arg.orderId -
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
+   * @summary: List User Beneficiary
+   * @description: Get all active  beneficiary details added by the user for refund
+   */
+  async getUserBeneficiaries({ orderId } = {}) {
+    const { error } = PaymentValidator.getUserBeneficiaries().validate(
+      { orderId },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserBeneficiaries().validate(
+      { orderId },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserBeneficiaries",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["order_id"] = orderId;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/user`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserBeneficiaries",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.merchantUserId -
+   * @param {string} arg.mobileNo -
+   * @returns {Promise<GetUserCODLimitResponse>} - Success response
+   * @summary: Get COD limit for user
+   * @description: Use this API to get user cod limit and reamining limit for the payment
+   */
+  async getUserCODlimitRoutes({ merchantUserId, mobileNo } = {}) {
+    const { error } = PaymentValidator.getUserCODlimitRoutes().validate(
+      {
+        merchantUserId,
+        mobileNo,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserCODlimitRoutes().validate(
+      {
+        merchantUserId,
+        mobileNo,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["merchant_user_id"] = merchantUserId;
+    query_params["mobile_no"] = mobileNo;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.GetUserCODLimitResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.orderId -
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
+   * @summary: List Order Beneficiary
+   * @description: Get all active  beneficiary details added by the user for refund
+   */
+  async getUserOrderBeneficiaries({ orderId } = {}) {
+    const { error } = PaymentValidator.getUserOrderBeneficiaries().validate(
+      { orderId },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserOrderBeneficiaries().validate(
+      { orderId },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserOrderBeneficiaries",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["order_id"] = orderId;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/order`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserOrderBeneficiaries",
+      });
+      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.
+   */
+  async initialisePayment({ body } = {}) {
+    const { error } = PaymentValidator.initialisePayment().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.initialisePayment().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for initialisePayment",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/request`,
+      query_params,
+      body
+    );
+
+    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 {MerchantOnBoardingRequest} arg.body
+   * @returns {Promise<MerchantOnBoardingResponse>} - Success response
+   * @summary: API to push Ajiodhan merchant data to Gringotts system
+   * @description: Use this API to push Ajiodhan merchant data to Gringotts system
+   */
+  async merchantOnBoarding({ body } = {}) {
+    const { error } = PaymentValidator.merchantOnBoarding().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.merchantOnBoarding().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for merchantOnBoarding",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/merchant-onboarding`,
+      query_params,
+      body
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.MerchantOnBoardingResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for merchantOnBoarding",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {string} arg.aggregator - Aggregator
+   * @param {string} [arg.successRedirectUrl] -
+   * @param {string} [arg.failureRedirectUrl] -
+   * @returns {Promise<GetOauthUrlResponse>} - Success response
+   * @summary: API to Get the url to call for oauth
+   * @description: Use this API to Get the url to call for oauth.
+   */
+  async oauthGetUrl({
+    aggregator,
+    successRedirectUrl,
+    failureRedirectUrl,
+  } = {}) {
+    const { error } = PaymentValidator.oauthGetUrl().validate(
+      {
+        aggregator,
+        successRedirectUrl,
+        failureRedirectUrl,
+      },
+      { abortEarly: false, allowUnknown: true }
+    );
+    if (error) {
+      return Promise.reject(new FDKClientValidationError(error));
+    }
+
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.oauthGetUrl().validate(
+      {
+        aggregator,
+        successRedirectUrl,
+        failureRedirectUrl,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for oauthGetUrl",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
+    const query_params = {};
+    query_params["success_redirect_url"] = successRedirectUrl;
+    query_params["failure_redirect_url"] = failureRedirectUrl;
+
+    const response = await PlatformAPIClient.execute(
+      this.config,
+      "get",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/onboard/${aggregator}/`,
+      query_params,
+      undefined
+    );
+
+    const {
+      error: res_error,
+    } = PaymentModel.GetOauthUrlResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for oauthGetUrl",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
+  }
+
+  /**
+   * @param {Object} arg - Arg object.
+   * @param {PaymentStatusBulkHandlerRequest} arg.body
+   * @returns {Promise<PaymentStatusBulkHandlerResponse>} - Success response
+   * @summary: Get Payment status and information for a list of order_ids
+   * @description: Use this API to get Payment status and information for a list of order_ids
+   */
+  async paymentStatusBulk({ body } = {}) {
+    const { error } = PaymentValidator.paymentStatusBulk().validate(
+      {
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -164,40 +1476,33 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
+    const { error: warrning } = PaymentValidator.paymentStatusBulk().validate(
       {
-        orderId,
-
-        requestHash,
+        body,
       },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message:
-          "Parameter Validation warrnings for getBankAccountDetailsOpenAPI",
+        message: "Parameter Validation warrnings for paymentStatusBulk",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["order_id"] = orderId;
-    query_params["request_hash"] = requestHash;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/account`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/payment-status-bulk/`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.RefundAccountResponse().validate(response, {
+    } = PaymentModel.PaymentStatusBulkHandlerResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -205,8 +1510,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message:
-          "Response Validation Warnnings for getBankAccountDetailsOpenAPI",
+        message: "Response Validation Warnnings for paymentStatusBulk",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -216,13 +1520,16 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @returns {Promise<PaymentGatewayConfigResponse>} - Success response
-   * @summary: Get All Brand Payment Gateway Config Secret
-   * @description: Get All Brand Payment Gateway Config Secret
+   * @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
    */
-  async getBrandPaymentGatewayConfig({} = {}) {
-    const { error } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
-      {},
+  async pollingPaymentLink({ paymentLinkId } = {}) {
+    const { error } = PaymentValidator.pollingPaymentLink().validate(
+      {
+        paymentLinkId,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -230,34 +1537,34 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
-      {},
+    const { error: warrning } = PaymentValidator.pollingPaymentLink().validate(
+      {
+        paymentLinkId,
+      },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message:
-          "Parameter Validation warrnings for getBrandPaymentGatewayConfig",
+        message: "Parameter Validation warrnings for pollingPaymentLink",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
+    query_params["payment_link_id"] = paymentLinkId;
 
     const response = await PlatformAPIClient.execute(
       this.config,
       "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/polling-payment-link/`,
       query_params,
       undefined
     );
 
     const {
       error: res_error,
-    } = PaymentModel.PaymentGatewayConfigResponse().validate(response, {
+    } = PaymentModel.PollingPaymentLinkResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -265,8 +1572,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message:
-          "Response Validation Warnnings for getBrandPaymentGatewayConfig",
+        message: "Response Validation Warnnings for pollingPaymentLink",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -276,17 +1582,15 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {boolean} arg.refresh -
-   * @param {string} arg.requestType -
-   * @returns {Promise<PaymentOptionsResponse>} - Success response
-   * @summary: Get All Valid Payment Options
-   * @description: Use this API to get Get All Valid Payment Options for making payment
+   * @param {RepaymentDetailsSerialiserPayAll} arg.body
+   * @returns {Promise<RepaymentResponse>} - Success response
+   * @summary: API to register repayment details
+   * @description: Use this API to register any repayment record in the db and notify the aggrgator
    */
-  async getPaymentModeRoutes({ refresh, requestType } = {}) {
-    const { error } = PaymentValidator.getPaymentModeRoutes().validate(
+  async repaymentDetails({ body } = {}) {
+    const { error } = PaymentValidator.repaymentDetails().validate(
       {
-        refresh,
-        requestType,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -295,38 +1599,33 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getPaymentModeRoutes().validate(
+    const { error: warrning } = PaymentValidator.repaymentDetails().validate(
       {
-        refresh,
-        requestType,
+        body,
       },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for getPaymentModeRoutes",
+        message: "Parameter Validation warrnings for repaymentDetails",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["refresh"] = refresh;
-    query_params["request_type"] = requestType;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/options`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/repayment-details`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.PaymentOptionsResponse().validate(response, {
+    } = PaymentModel.RepaymentResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -334,7 +1633,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for getPaymentModeRoutes",
+        message: "Response Validation Warnnings for repaymentDetails",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -344,14 +1643,16 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.orderId -
-   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
-   * @summary: List User Beneficiary
-   * @description: Get all active  beneficiary details added by the user for refund
+   * @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.
    */
-  async getUserBeneficiaries({ orderId } = {}) {
-    const { error } = PaymentValidator.getUserBeneficiaries().validate(
-      { orderId },
+  async resendOrCancelPayment({ body } = {}) {
+    const { error } = PaymentValidator.resendOrCancelPayment().validate(
+      {
+        body,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -361,32 +1662,33 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.getUserBeneficiaries().validate(
-      { orderId },
+    } = PaymentValidator.resendOrCancelPayment().validate(
+      {
+        body,
+      },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for getUserBeneficiaries",
+        message: "Parameter Validation warrnings for resendOrCancelPayment",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["order_id"] = orderId;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/user`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/cancel`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+    } = PaymentModel.ResendOrCancelPaymentResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -394,7 +1696,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for getUserBeneficiaries",
+        message: "Response Validation Warnnings for resendOrCancelPayment",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -404,17 +1706,15 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.merchantUserId -
-   * @param {string} arg.mobileNo -
-   * @returns {Promise<GetUserCODLimitResponse>} - Success response
-   * @summary: Get COD limit for user
-   * @description: Use this API to get user cod limit and reamining limit for the payment
+   * @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
    */
-  async getUserCODlimitRoutes({ merchantUserId, mobileNo } = {}) {
-    const { error } = PaymentValidator.getUserCODlimitRoutes().validate(
+  async resendPaymentLink({ body } = {}) {
+    const { error } = PaymentValidator.resendPaymentLink().validate(
       {
-        merchantUserId,
-        mobileNo,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -423,38 +1723,33 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getUserCODlimitRoutes().validate(
+    const { error: warrning } = PaymentValidator.resendPaymentLink().validate(
       {
-        merchantUserId,
-        mobileNo,
+        body,
       },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for getUserCODlimitRoutes",
+        message: "Parameter Validation warrnings for resendPaymentLink",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["merchant_user_id"] = merchantUserId;
-    query_params["mobile_no"] = mobileNo;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/resend-payment-link/`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.GetUserCODLimitResponse().validate(response, {
+    } = PaymentModel.ResendPaymentLinkResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -462,7 +1757,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for getUserCODlimitRoutes",
+        message: "Response Validation Warnnings for resendPaymentLink",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -472,14 +1767,16 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.orderId -
-   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
-   * @summary: List Order Beneficiary
-   * @description: Get all active  beneficiary details added by the user for refund
+   * @param {string} arg.aggregator - Aggregator_slug
+   * @returns {Promise<RevokeOAuthToken>} - Success response
+   * @summary: API to Revoke oauth for razorpay partnership
+   * @description: Use this API to Revoke oauth for razorpay partnership
    */
-  async getUserOrderBeneficiaries({ orderId } = {}) {
-    const { error } = PaymentValidator.getUserOrderBeneficiaries().validate(
-      { orderId },
+  async revokeOauthToken({ aggregator } = {}) {
+    const { error } = PaymentValidator.revokeOauthToken().validate(
+      {
+        aggregator,
+      },
       { abortEarly: false, allowUnknown: true }
     );
     if (error) {
@@ -487,34 +1784,33 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.getUserOrderBeneficiaries().validate(
-      { orderId },
+    const { error: warrning } = PaymentValidator.revokeOauthToken().validate(
+      {
+        aggregator,
+      },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for getUserOrderBeneficiaries",
+        message: "Parameter Validation warrnings for revokeOauthToken",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["order_id"] = orderId;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/order`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/revoke/${aggregator}/`,
       query_params,
       undefined
     );
 
     const {
       error: res_error,
-    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+    } = PaymentModel.RevokeOAuthToken().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -522,7 +1818,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for getUserOrderBeneficiaries",
+        message: "Response Validation Warnnings for revokeOauthToken",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -532,23 +1828,15 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.aggregator - Aggregator
-   * @param {string} [arg.successRedirectUrl] -
-   * @param {string} [arg.failureRedirectUrl] -
-   * @returns {Promise<GetOauthUrlResponse>} - Success response
-   * @summary: API to Get the url to call for oauth
-   * @description: Use this API to Get the url to call for oauth.
+   * @param {PaymentGatewayConfigRequest} arg.body
+   * @returns {Promise<PaymentGatewayToBeReviewed>} - Success response
+   * @summary: Save Config Secret For Brand Payment Gateway
+   * @description: Save Config Secret For Brand Payment Gateway
    */
-  async oauthGetUrl({
-    aggregator,
-    successRedirectUrl,
-    failureRedirectUrl,
-  } = {}) {
-    const { error } = PaymentValidator.oauthGetUrl().validate(
+  async saveBrandPaymentGatewayConfig({ body } = {}) {
+    const { error } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
       {
-        aggregator,
-        successRedirectUrl,
-        failureRedirectUrl,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -557,37 +1845,36 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.oauthGetUrl().validate(
+    const {
+      error: warrning,
+    } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
       {
-        aggregator,
-        successRedirectUrl,
-        failureRedirectUrl,
+        body,
       },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for oauthGetUrl",
+        message:
+          "Parameter Validation warrnings for saveBrandPaymentGatewayConfig",
       });
       Logger({ level: "WARN", message: warrning });
     }
 
     const query_params = {};
-    query_params["success_redirect_url"] = successRedirectUrl;
-    query_params["failure_redirect_url"] = failureRedirectUrl;
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "get",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/onboard/${aggregator}/`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.GetOauthUrlResponse().validate(response, {
+    } = PaymentModel.PaymentGatewayToBeReviewed().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -595,7 +1882,8 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for oauthGetUrl",
+        message:
+          "Response Validation Warnnings for saveBrandPaymentGatewayConfig",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -605,15 +1893,15 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {string} arg.aggregator - Aggregator_slug
-   * @returns {Promise<RevokeOAuthToken>} - Success response
-   * @summary: API to Revoke oauth for razorpay partnership
-   * @description: Use this API to Revoke oauth for razorpay partnership
+   * @param {SetCODForUserRequest} arg.body
+   * @returns {Promise<SetCODOptionResponse>} - Success response
+   * @summary: Set COD option for user for payment
+   * @description: Use this API to set cod option as true or false for the payment
    */
-  async revokeOauthToken({ aggregator } = {}) {
-    const { error } = PaymentValidator.revokeOauthToken().validate(
+  async setUserCODlimitRoutes({ body } = {}) {
+    const { error } = PaymentValidator.setUserCODlimitRoutes().validate(
       {
-        aggregator,
+        body,
       },
       { abortEarly: false, allowUnknown: true }
     );
@@ -622,16 +1910,18 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const { error: warrning } = PaymentValidator.revokeOauthToken().validate(
+    const {
+      error: warrning,
+    } = PaymentValidator.setUserCODlimitRoutes().validate(
       {
-        aggregator,
+        body,
       },
       { abortEarly: false, allowUnknown: false }
     );
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for revokeOauthToken",
+        message: "Parameter Validation warrnings for setUserCODlimitRoutes",
       });
       Logger({ level: "WARN", message: warrning });
     }
@@ -640,15 +1930,15 @@ class Payment {
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "post",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/revoke/${aggregator}/`,
+      "put",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
       query_params,
-      undefined
+      body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.RevokeOAuthToken().validate(response, {
+    } = PaymentModel.SetCODOptionResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -656,7 +1946,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for revokeOauthToken",
+        message: "Response Validation Warnnings for setUserCODlimitRoutes",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -666,13 +1956,13 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {PaymentGatewayConfigRequest} arg.body
-   * @returns {Promise<PaymentGatewayToBeReviewed>} - Success response
-   * @summary: Save Config Secret For Brand Payment Gateway
-   * @description: Save Config Secret For Brand Payment Gateway
+   * @param {EdcAddRequest} arg.body
+   * @returns {Promise<EdcDeviceAddResponse>} - Success response
+   * @summary: map new edc device to the terminal
+   * @description: Use this API to map new edc device to the terminal
    */
-  async saveBrandPaymentGatewayConfig({ body } = {}) {
-    const { error } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
+  async updateEdcDevice({ body } = {}) {
+    const { error } = PaymentValidator.updateEdcDevice().validate(
       {
         body,
       },
@@ -683,9 +1973,7 @@ class Payment {
     }
 
     // Showing warrnings if extra unknown parameters are found
-    const {
-      error: warrning,
-    } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
+    const { error: warrning } = PaymentValidator.updateEdcDevice().validate(
       {
         body,
       },
@@ -694,8 +1982,7 @@ class Payment {
     if (warrning) {
       Logger({
         level: "WARN",
-        message:
-          "Parameter Validation warrnings for saveBrandPaymentGatewayConfig",
+        message: "Parameter Validation warrnings for updateEdcDevice",
       });
       Logger({ level: "WARN", message: warrning });
     }
@@ -705,14 +1992,14 @@ class Payment {
     const response = await PlatformAPIClient.execute(
       this.config,
       "post",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/edc-device`,
       query_params,
       body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.PaymentGatewayToBeReviewed().validate(response, {
+    } = PaymentModel.EdcDeviceAddResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -720,8 +2007,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message:
-          "Response Validation Warnnings for saveBrandPaymentGatewayConfig",
+        message: "Response Validation Warnnings for updateEdcDevice",
       });
       Logger({ level: "WARN", message: res_error });
     }
@@ -731,13 +2017,13 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
-   * @param {SetCODForUserRequest} arg.body
-   * @returns {Promise<SetCODOptionResponse>} - Success response
-   * @summary: Set COD option for user for payment
-   * @description: Use this API to set cod option as true or false for the payment
+   * @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.
    */
-  async setUserCODlimitRoutes({ body } = {}) {
-    const { error } = PaymentValidator.setUserCODlimitRoutes().validate(
+  async verifyCustomerForPayment({ body } = {}) {
+    const { error } = PaymentValidator.verifyCustomerForPayment().validate(
       {
         body,
       },
@@ -750,7 +2036,7 @@ class Payment {
     // Showing warrnings if extra unknown parameters are found
     const {
       error: warrning,
-    } = PaymentValidator.setUserCODlimitRoutes().validate(
+    } = PaymentValidator.verifyCustomerForPayment().validate(
       {
         body,
       },
@@ -759,7 +2045,7 @@ class Payment {
     if (warrning) {
       Logger({
         level: "WARN",
-        message: "Parameter Validation warrnings for setUserCODlimitRoutes",
+        message: "Parameter Validation warrnings for verifyCustomerForPayment",
       });
       Logger({ level: "WARN", message: warrning });
     }
@@ -768,15 +2054,15 @@ class Payment {
 
     const response = await PlatformAPIClient.execute(
       this.config,
-      "put",
-      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
+      "post",
+      `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/customer/validation`,
       query_params,
       body
     );
 
     const {
       error: res_error,
-    } = PaymentModel.SetCODOptionResponse().validate(response, {
+    } = PaymentModel.ValidateCustomerResponse().validate(response, {
       abortEarly: false,
       allowUnknown: false,
     });
@@ -784,7 +2070,7 @@ class Payment {
     if (res_error) {
       Logger({
         level: "WARN",
-        message: "Response Validation Warnnings for setUserCODlimitRoutes",
+        message: "Response Validation Warnnings for verifyCustomerForPayment",
       });
       Logger({ level: "WARN", message: res_error });
     }