ps-apimatic-sdk 0.0.1

data/lib/paysecure_api_documentation_live/apis/api.rb

@@ -0,0 +1,91 @@
+# paysecure_api_documentation_live
+#
+# This file was automatically generated
+# by APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PaysecureApiDocumentationLive
+  # Api
+  class Api < BaseApi
+    # ## Refund Scenarios
+    # ### Partial Refund
+    # Purchase Amount: 10
+    # Refund Amount: 8
+    # Result:
+    # - Refunded Amount: 8
+    # 
+    # - Remaining Refundable Amount: 2
+    # 
+    # - Transaction Status: PARTIALLY_REFUNDED
+    # 
+    # Full Refund Using Partial Refund API
+    # Purchase Amount: 10
+    # Refund Amount: 10
+    # Result:
+    # - Refunded Amount: 10
+    # 
+    # - Remaining Refundable Amount: 0
+    # 
+    # - Transaction Status: PARTIAL REFUNDED
+    # 
+    # ### Multiple Partial Refunds
+    # Purchase Amount: 10
+    # - Refund #1: 3
+    # 
+    # - Refund #2: 2
+    # 
+    # - Refund #3: 5
+    # 
+    # Result:
+    # - Total Refunded Amount: 10
+    # 
+    # - Remaining Refundable Amount: 0
+    # 
+    # Final Transaction Status: PARTIAL REFUNDED
+    # @param [String] accept Required parameter: TODO: type description here
+    # @param [PartialRefundApiRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def partial_refund_api(accept,
+                           body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v1/purchases/purchaseid/refund',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(accept, key: 'Accept')
+                                  .is_required(true))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 Success51Exception))
+        .execute
+    end
+
+    # TODO: type endpoint description here
+    # @param [PartialRefundStatusApiRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def partial_refund_status_api(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v1/refundStatus/purchaseid',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .is_response_void(true)
+                    .is_api_response(true)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 Success51Exception))
+        .execute
+    end
+  end
+end

data/lib/paysecure_api_documentation_live/apis/base_api.rb

@@ -0,0 +1,67 @@
+# paysecure_api_documentation_live
+#
+# This file was automatically generated
+# by APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PaysecureApiDocumentationLive
+  # BaseApi.
+  class BaseApi
+    include CoreLibrary
+    attr_accessor :config, :http_call_back
+
+    def self.user_agent
+      'Ruby-SDK/0.0.1 (OS: {os-info}, Engine: {engine}/{engine-version})'
+    end
+
+    def self.user_agent_parameters
+      {
+        '{engine}' => { 'value' => RUBY_ENGINE, 'encode' => false },
+        '{engine-version}' => { 'value' => RUBY_ENGINE_VERSION, 'encode' => false },
+        '{os-info}' => { 'value' => RUBY_PLATFORM, 'encode' => false }
+      }
+    end
+
+    GLOBAL_ERRORS = {
+      'default' => ErrorCase.new
+                            .error_message('HTTP response not OK.')
+                            .exception_type(APIException)
+    }.freeze
+
+    # Initialization constructor.
+    # @param [GlobalConfiguration] global_configuration The instance of GlobalConfiguration.
+    def initialize(global_configuration)
+      @global_configuration = global_configuration
+      @config = @global_configuration.client_configuration
+      @http_call_back = @config.http_callback
+      @api_call = ApiCall.new(@global_configuration)
+    end
+
+    # Creates a new instance of the request builder.
+    # @param [String] http_method The HTTP method to use in the request.
+    # @param [String] path The endpoint path to use in the request.
+    # @param [String] server The server to extract the base uri for the request.
+    # @return [RequestBuilder] The instance of RequestBuilder.
+    def new_request_builder(http_method, path, server)
+      RequestBuilder.new
+                    .http_method(http_method)
+                    .path(path)
+                    .server(server)
+    end
+
+    # Creates a new instance of the response handler.
+    # @return [ResponseHandler] The instance of ResponseHandler.
+    def new_response_handler
+      ResponseHandler.new
+    end
+
+    # Creates a new instance of the parameter.
+    # @param [String|optional] key The key of the parameter.
+    # @param [Object] value The value of the parameter.
+    # @return [Parameter] The instance of Parameter.
+    def new_parameter(value, key: nil)
+      Parameter.new
+               .key(key)
+               .value(value)
+    end
+  end
+end

data/lib/paysecure_api_documentation_live/apis/cashier_ap_is_api.rb

@@ -0,0 +1,466 @@
+# paysecure_api_documentation_live
+#
+# This file was automatically generated
+# by APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module PaysecureApiDocumentationLive
+  # CashierApIsApi
+  class CashierApIsApi < BaseApi
+    # **OVERIEW**
+    # The **createCustomer API** allows merchants to create a customer profile
+    # on PaySecure when a user visits their website, facilitating a seamless
+    # payment experience by pre-filling the customer's details, on the PaySecure
+    # Cashier. The API takes in customer information and returns a unique
+    # customerID that can be passed in purchase payload, eliminating the need
+    # for customers to manually enter their details during transactions.
+    # | Parameter | Type | **Required** | Description | Example |
+    # | --- | --- | --- | --- | --- |
+    # | merchantCustomerId | String | Yes | unique customer ID provided by
+    # merchant. This can be email, mobile or an alphanumeric string |
+    # [rahultestcustomer@paysecure.net](https://mailto:rahultestcustomer@paysecu
+    # re.net) |
+    # | fullName | String | Yes | Full name of the customer. | Rahul Agarwal |
+    # | emailId | String | Yes | Email address of the customer. |
+    # [test@paysecure.net](https://mailto:test@paysecure.net) |
+    # | dateOfBirth | String | Optional | Customer's date of birth in YYYY-MM-DD
+    # format. | 1995-12-27 |
+    # | phoneNo | String | Yes | Customer's phone number. Preferred with the
+    # country code | +91 797639082 |
+    # | city | String | Optional | City of the customer. | Jaipur |
+    # | stateCode | String | Yes | State code of the customer. | RJ |
+    # | zipCode | String | Optional | Postal code of the customer's location. |
+    # 302018 |
+    # | address | String | Optional | Full address of the customer. | House
+    # Number 53, Vaishali Nagar, Jaipur |
+    # | country | String | Yes | Country code (ISO 3166-1 alpha-2). | IN |
+    # | custRegDate | Sting | Optional | Customer registration date on merchant
+    # site in YYYY-MM-DD format. | 2023-12-27 |
+    # | successTxn | String | Optional | Number of successful transactions
+    # customer has carried on merchant site. | 32 |
+    # ### **User Flow**
+    # 1. **Customer visits merchant's website**: The customer selects the
+    # product or service and proceeds to checkout page.
+    # 
+    # 2. **Merchant calls the** **`createCustomer`** **API**: The merchant sends
+    # a `POST` request to the Paysecure API with the customer's details.
+    # 
+    # 3. **Customer ID generation**: Paysecure processes the request and
+    # generates a unique `customerId` which is returned in the response.
+    # 
+    # 4. **Payment Process**: The merchant uses the `customerId` for subsequent
+    # session creation, ensuring the customer doesn’t need to re-enter their
+    # details for future payments.
+    # 
+    # ---
+    # ### **Benefits**
+    # - **Seamless user experience**: The customer does not have to enter their
+    # details manually for every purchase.
+    # 
+    # - **Faster Checkout**: The merchant can use the `customerId` for faster
+    # payment processing.
+    # 
+    # - **Data Security**: Customer details are stored securely and can be
+    # reused across transactions, reducing the chances of errors.
+    # 
+    # ### Implementing createCustomer on merchant site:
+    # The `createCustomer` can be implemented on merchant site in one of two
+    # ways, depending on merchant’s integration flow:
+    # **At Checkout:**
+    # When a customer initiates the checkout process, your system should invoke
+    # the `createCustomer` API, before actually starting the session.
+    # - **Call** **`createCustomer`**: This API call generates a unique customer
+    # ID.
+    # 
+    # - **Use of Customer ID:** Pass the returned customer ID in Session API,
+    # when creating a payment session.
+    # 
+    # **Upon Customer Login:**
+    # Alternatively, merchants may choose to call `createCustomer` at the time
+    # of customer login on their site.
+    # - **Persistent Customer Profiles:** This approach can help build or
+    # maintain a persistent customer profile, ensuring the customer ID is
+    # available for any subsequent payment sessions without needing to call
+    # `createCustomer` again.
+    # 
+    # - **Integration Flexibility:** This is useful for merchants who want to
+    # initialize customer data early in the customer journey rather than during
+    # checkout.
+    # 
+    # The method you choose depends on your business requirements and how your
+    # system is architected. Regardless of when you call it, the resulting
+    # customer ID must be passed to the `createSession` API to initiate a
+    # payment session.
+    # @param [String] brand_id Required parameter: TODO: type description here
+    # @param [CustomerRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def customer(brand_id,
+                 body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v1/customer',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter(brand_id, key: 'BrandId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Success19.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 FailureException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 ExistingCustomerException))
+        .execute
+    end
+
+    # This endpoint makes an HTTP GET request to retrieve customer information
+    # from the Paysecure API.
+    # ### Request
+    # The request does not include any query parameters, but it uses a raw
+    # request body with the following parameter "merchantCustomerId", which will
+    # be the customer id on the merchant's side.
+    # ### Response
+    # The response of this request can be documented as a JSON schema.
+    # @param [String] brand_id Required parameter: TODO: type description here
+    # @param [String] accept Required parameter: TODO: type description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def customer1(brand_id,
+                  accept)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/customer',
+                                     Server::SERVER_2)
+                   .header_param(new_parameter(brand_id, key: 'BrandId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(accept, key: 'Accept')
+                                  .is_required(true)))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Success19.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 InvalidCustomerException))
+        .execute
+    end
+
+    # Whenever a customer or the merchant updates customer details on the
+    # merchant site, a PATCH request must be made to synchronize these changes
+    # with Paysecure.
+    # This API endpoint allows you to update the customer details using an HTTP
+    # PATCH request. The request should be sent to
+    # [https://api.paysecure.net/api/v1/{customerId}/patchCustomer](https://api.
+    # paysecure.net/api/v1/%7BcustomerId%7D/patchCustomer).
+    # ### Request Body
+    # The request body should be in raw format and include the following
+    # parameters:
+    # - `fullName` (string): The full name of the customer.
+    # 
+    # - `emailId` (string): The email address of the customer.
+    # 
+    # - `dateOfBirth` (string): The date of birth of the customer.
+    # 
+    # - `phoneNo` (string): The phone number of the customer.
+    # 
+    # - `city` (string): The city of the customer.
+    # 
+    # - `stateCode` (string): The state code of the customer.
+    # 
+    # - `zipCode` (string): The zip code of the customer.
+    # 
+    # - `address` (string): The address of the customer.
+    # 
+    # - `country` (string): The country of the customer.
+    # 
+    # - `createdOn` (string): Time when the customer was created.
+    # 
+    # - `custRegDate` (string): Customer registration date (Non-Mandatory).
+    # 
+    # - `successTxn` (string): Success transaction details (Non-Mandatory).
+    # 
+    # - `lastActivity` (string): Time of the last activity.
+    # 
+    # - `lastUpdated` (string): Time when the last patch was called.
+    # 
+    # - `extraParam` (object): Additional parameters including `param1`,
+    # `param2`, `param3`, `param4` with their respective values.
+    # 
+    # ### Response
+    # The response will contain the updated customer details or a success
+    # message upon successful update.
+    # @param [String] brand_id Required parameter: TODO: type description here
+    # @param [String] accept Required parameter: TODO: type description here
+    # @param [CustomerRequest1] body Required parameter: TODO: type description
+    # here
+    # @param [String] paysecure_customer_id Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def customer2(brand_id,
+                  accept,
+                  body,
+                  paysecure_customer_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/api/v1/{PaysecureCustomerId}/patchCustomer',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter(brand_id, key: 'BrandId')
+                                  .is_required(true))
+                   .header_param(new_parameter(accept, key: 'Accept')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .template_param(new_parameter(paysecure_customer_id, key: 'PaysecureCustomerId')
+                                    .is_required(true)
+                                    .should_encode(true))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Success19.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # **OVERIEW**
+    # The `createSession` API is designed to initiate a payment session for a
+    # customer after their profile has been created via the **createCustomer**
+    # API. The session is automatically generated at the backend on the
+    # merchant’s checkout URL. This session allows the customer to continue with
+    # their transaction without having to manually interact with the session
+    # URL, and ensures the session remains active until the payment is completed
+    # or the session expires.
+    # This API improves the user experience by reducing transaction failures and
+    # enhancing the overall payment process, thus reducing transaction churn
+    # rates.
+    # ### Mandatory Parameters
+    # | Parameter | Type | Description | Example |
+    # | --- | --- | --- | --- |
+    # | customerId | String | The unique ID of the customer (generated from
+    # createCustomer). | 6731a609b6bb5a43ad66c4a6 |
+    # #### Show Crypto Conversion
+    # Additionally, there are some default extra parameters that you can pass
+    # for allowing Crypto Conversion on Paysecure's cashier itself.
+    # |  | **Type** | **Description** | **Example** |
+    # | --- | --- | --- | --- |
+    # | extraParam.showCryptoConversion | String | This optional parameter
+    # allows customer to see crypto value equivelant to the Fiat amount the
+    # customer is planning to pay. | Yes |
+    # | extraParam.cryptoCurrencies | String | Pass here the allowed crypto
+    # tokens on the cashier, where customer can see the the conversion value |
+    # \[\\"BTC\\",\\"ETH\\",\\"USDT\\",\\"XRP\\",\\"LTC\\",\\"DOGE\\",\\"ETC\\",
+    # \\"BNB\\",\\"USDC\\",\\"SOL\\",\\"ADA\\",\\"BCH\\",\\"DASH\\",\\"BTG\\",\\
+    # "ZEC\\",\\"DGB\\",\\"EOS\\",\\"XLM\\",\\"TRX\\",\\"QTUM\\",\\"POL\\",\\"SH
+    # IB\\",\\"LINK\\",\\"DAI\\",\\"TON\\",\\"AVAX\\",\\"FDUSD\\",\\"ARB\\",\\"O
+    # P\\"\] |
+    # ### **Usage Flow**
+    # 1. **Customer completes the** **`createCustomer`** **API**: Once the
+    # customer is created via the `createCustomer` API, the merchant proceeds to
+    # call the `createSession` API to generate a session.
+    # 
+    # 2. **Merchant sends** **`createSession`** **request**: The merchant sends
+    # a `POST` request to the `createSession` API with the customer’s
+    # `customerId` and the merchant’s `brandId`.
+    # 
+    # 3. **Session created automatically on the checkout URL**: PaySecure
+    # creates the session and associates it with the merchant’s checkout page.
+    # This session remains active on the backend, allowing the customer to
+    # continue the payment process without interruption.
+    # 
+    # 4. **Customer proceeds to checkout**: The customer is redirected to the
+    # checkout page as part of the merchant's payment flow, where the session is
+    # automatically validated. The session remains active for a set period,
+    # allowing the customer to complete the payment without needing to manually
+    # interact with the session URL.
+    # 
+    # 5. **Session Expiry**: The session expires after the set expiration time
+    # (`expiryOn`), ensuring the payment process is completed within the defined
+    # window. Default is 15 mins from the creation time.
+    # 
+    # ---
+    # ### **Benefits**
+    # - **Seamless Checkout**: The session URL is automatically generated and
+    # active at the backend, ensuring a smoother and uninterrupted customer
+    # experience.
+    # 
+    # - **Reduced Transaction Failures**: By ensuring the session remains active
+    # during the payment process, the chances of transaction failures due to
+    # session timeouts are minimized.
+    # 
+    # - **Improved User Experience**: The customer does not need to click on a
+    # session URL or navigate away from the page, leading to faster and more
+    # secure payment processing.
+    # @param [String] brand_id Required parameter: TODO: type description here
+    # @param [String] accept Required parameter: TODO: type description here
+    # @param [PurchaseSessionRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def purchase_session(brand_id,
+                         accept,
+                         body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v1/createSession',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter(brand_id, key: 'BrandId')
+                                  .is_required(true))
+                   .header_param(new_parameter(accept, key: 'Accept')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Success14.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 InvalidSessionException))
+        .execute
+    end
+
+    # This API is used to initiate a payout session for a customer. By passing
+    # the `customerId` (generated via the `createCustomer` API) and specifying
+    # `"type": "payout"`, a payout session is started.
+    # A `sessionURL` is returned in the response, which can be used to redirect
+    # the customer to the payout cashier. The customer can then select the
+    # payout method, pass required parameters, and the payout will be processed.
+    # #### Parameters:
+    # | **Parameter** | **Type** | **Description** |
+    # | --- | --- | --- |
+    # | **customerId** | string | The unique ID of the customer for whom the
+    # payout session is created. This ID is generated by the `createCustomer`
+    # API. |
+    # | **currency** | string | The currency of the payout session (e.g., USD).
+    # |
+    # | **products** | array | A list of products associated with the payout
+    # (e.g., name and price). |
+    # | **totalAmount** | string | The total payout amount (optional. calculated
+    # dynamically if value is not passed). |
+    # | **tax_amount** | string | The tax amount to be applied (optional). |
+    # | **tax_percent** | string | The tax percentage to be applied (optional).
+    # |
+    # | **type** | string | Should be set to "payout" to initiate a payout
+    # session. |
+    # | **success_redirect** | string | The URL where the customer will be
+    # redirected after a successful payout. |
+    # | **pending_redirect** | string | The URL where the customer will be
+    # redirected after a pending payout. |
+    # | **failure_redirect** | string | The URL where the customer will be
+    # redirected after a failed payout attempt. |
+    # | **success_callback** | string | The callback URL for successful payout.
+    # |
+    # | **failure_callback** | string | The callback URL for failed payout. |
+    # | **extraParam** | object | Contains additional parameters for the payout
+    # session. |
+    # | **extraParam.showCryptoConversion** | string | Set to "yes" to display
+    # cryptocurrency conversion. |
+    # | **extraParam.cryptoCurrencies** | string | A list of accepted
+    # cryptocurrencies (e.g., BTC, ETH, USDT). |
+    # #### Request Headers:
+    # - **BrandId**: Your unique brand ID (required).
+    # 
+    # - **Content-Type**: application/json (required).
+    # 
+    # #### Response:
+    # The API will return a JSON object containing the `sessionURL` that can be
+    # used to redirect the customer to the payout cashier.
+    # ``` json
+    # {
+    #     "sessionUrl":
+    # "https://api.paysecure.net/payoutSession/68341ad35f895955355d5452/",
+    #     "brandId": "brand_id_value",
+    #     "customerId": "67c9983fba18400ab6cceb8f",
+    #     "sessionId": "68341ad35f895955355d5452",
+    #     "expiryOn": 1748246103,
+    #     "createdOn": 1748245203
+    # }
+    #  ```
+    # @param [String] brand_id Required parameter: TODO: type description here
+    # @param [String] accept Required parameter: TODO: type description here
+    # @param [PayoutSessionRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def payout_session(brand_id,
+                       accept,
+                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/v1/createSession',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter(brand_id, key: 'BrandId')
+                                  .is_required(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(accept, key: 'Accept')
+                                  .is_required(true))
+                   .body_param(new_parameter(body)
+                                .is_required(true))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PayoutSession.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+
+    # This endpoint retrieves the details of a session identified by the
+    # provided session ID.
+    # > Note that this API only respond once the SessionURL, received in the
+    # response for session API, is clicked.
+    # 
+    # > Once the SessionURL is clicked and the user has selected a payment
+    # method and click on "Pay" button, a purchase is created on our backend. If
+    # you call this API before that, you will get an error.
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def check_status_payin
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/purchases/{Session ID}',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(M202Success.method(:from_hash))
+                    .is_api_response(true)
+                    .local_error('400',
+                                 'Bad Request',
+                                 M400BadRequestException)
+                    .local_error('401',
+                                 'Unauthorized',
+                                 M401UnauthorizedException))
+        .execute
+    end
+
+    # This API tells you about all the details of a Payout, including its
+    # history
+    # ### Mandatory
+    # you need to pass the payoutId or session id in the API URL
+    # ### Possible Value of Status
+    # | **Status** | **Notes** |
+    # | --- | --- |
+    # | paid | Transaction Successful |
+    # | payout_in_process | payout is under Processing. |
+    # | error | Transaction has Failed. |
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def check_status_payout
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/v1/getpayout/{Session ID}',
+                                     Server::SERVER_3)
+                   .header_param(new_parameter('application/json', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Success29.method(:from_hash))
+                    .is_api_response(true))
+        .execute
+    end
+  end
+end