bk-apimatic-sdk 1.0.0

data/lib/boku_direct_payments_api/controllers/consumer_registration_controller.rb

@@ -0,0 +1,428 @@
+# boku_direct_payments_api
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module BokuDirectPaymentsApi
+  # ConsumerRegistrationController
+  class ConsumerRegistrationController < BaseController
+    # The `optin` API call is one of two ways to initiate the opt-in process.
+    # The other is `optin-info`, which uses cached information when available.
+    # While `optin` can be used to initiate all opt-ins, it is only _required_
+    # for the following cases:
+    # - One-time Pin (OTP) opt-ins – to trigger sending an OTP SMS to the
+    # device.
+    # - Carrier gateway opt-ins* – when `optin-info` does not return a static
+    # URL and a unique URL must be generated per opt-in.
+    # After a successful `optin` call, the opt-in typically enters the
+    # `pending-validate` status.
+    # ### Supported Optin Types
+    # - `otp` – Sends a one-time PIN to the consumer via SMS, confirmed via
+    # `confirm-optin`.
+    # - `hosted` – Redirects the consumer to an issuer-provided UI for
+    # verification.
+    # - `carrier-gw`* – Verifies the consumer via a ping through the carrier
+    # gateway.
+    # - `silent-mo`* – Verifies the consumer by sending a silent SMS from the
+    # device.
+    # _*These optin types are use-case specific and not required for most
+    # integrations. Only include them if explicitly directed._
+    # ### Related Methods
+    # The `optin` method is used in conjunction with the following to complete
+    # consumer approval:
+    # - `validate-optin` – Validates the phone number (billing account) the
+    # consumer is registering as a payment method.
+    # - `submit-optin-parameters` – Submits carrier-specific parameters such as
+    # an account PIN, if required.
+    # - `confirm-optin` – Finalizes the opt-in and activates it for billing.
+    # ### OTP Optin Defaults
+    # For OTP-based opt-ins using Boku-managed PINs, the following defaults
+    # apply:
+    # - PIN length: 4 digits
+    # - Validity period: 300 seconds
+    # - Maximum attempts: 3 (_Note: Carrier-managed PINs may follow different
+    # rules_).
+    # @param [OptinRequest] body Required parameter: TODO: type description
+    # here
+    # @return [OptinResponse] Response from the API call.
+    def optin(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/optin',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('optin-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(OptinResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('optin-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The main purpose of an opt-in is to identify and verify the payment method
+    # that the end-user wants to register. In the process, the user confirms
+    # that they have control over the corresponding payment method. Once an
+    # opt-in has begun via an `optin` API call, the `validate-optin` call is
+    # used to complete this verification and in most cases retrieve the end-user
+    # details such as the account identifier of the user.
+    # Specifically for each opt-in type:
+    # * **otp**: Submit the OTP, and if correct receive confirmation that the
+    # user owns the MSISDN and handset.
+    # **Note**: default configuration on Boku-mananged PIN for the number of OTP
+    # verification attempts is 3 and the default PIN expiration is 300 seconds.
+    # * **carrier-gw**: Confirm receipt of the carrier-gw URL call on Boku's
+    # servers, and retrieve the MSISDN via a secure channel if the carrier-gw
+    # URL call itself is not sufficiently secured. Potentially block on an
+    # asynchronous user identification callback from the carrier.
+    # * **silent-mo**: Block upon receipt of the silent MO SMS if not yet
+    # received, and once complete retrieve the received MSISDN details.
+    # * **hosted**: Confirm successful authentication via opt-in UI, and
+    # retrieve the account identifier of the user.
+    # After a successful `validate-optin` call, an opt-in should usually be in
+    # status `pending-confirm` awaiting a call to `confirm-optin`. In the case
+    # of a OTP opt-in, if the PIN expires, a new opt-in will need to be
+    # initiated with a new 'optin' request.
+    # @param [ValidateOptinRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ValidateOptinResponse] Response from the API call.
+    def validate_optin(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/validate-optin',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('validate-optin-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(ValidateOptinResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('validate-optin-response')))
+        .execute
+    end
+
+    # Assuming an opt-in is in state `pending-confirm` (i.e. all necessary
+    # information about the end-user has already been collected), this call
+    # confirms that the opt-in should be activated for billing (after a
+    # successful call, optin-status should be `active`).
+    # **Note**
+    # * In some cases, such as a carrier-gw opt-in where sufficient information
+    # was returned in the carrier-gw URL call response, `confirm-optin` may be
+    # called directly without first calling `validate-optin`.
+    # * If `include-account-profile` is already set to true during
+    # `validate-optin`, Boku recommends that merchant sets the
+    # `include-account-profile` to false during `confirm-optin` to optimize the
+    # optin flow time as account-profile requires an external call to the
+    # carrier.
+    # @param [ConfirmOptinRequest] body Required parameter: TODO: type
+    # description here
+    # @return [ConfirmOptinResponse] Response from the API call.
+    def confirm_optin(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/confirm-optin',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('confirm-optin-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(ConfirmOptinResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('confirm-optin-response')))
+        .execute
+    end
+
+    # The purpose of the ‘cancel-optin’ API is for deactivating the consumer’s
+    # opt-in stored by Boku and the issuer.
+    # A merchant can use this method in the following possible scenarios:
+    # * User contacts the merchant requesting to remove their payment method
+    # * Merchant determines that the consumer’s billing account has encountered
+    # a permanent error   that should not be retried in the future
+    # A cancel-optin request **must** be sent when a user removes the payment
+    # method from the merchant account. Various payment methods enforce a 1:1
+    # mapping, that is, a single payment method account can only be associated
+    # to a single merchant account. In the case that the merchant does not call
+    # cancel-optin, a user would be unable to associate their payment method
+    # account with any other merchant account, even though the user has already
+    # requested to remove the payment method from the merchant account.
+    # The 'optin-id' received from the 'optin' request at the time the consumer
+    # added their payment method must be supplied in the 'cancel-optin' request.
+    # @param [CancelOptinRequest] body Required parameter: TODO: type
+    # description here
+    # @return [CancelOptinResponse] Response from the API call.
+    def cancel_optin(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/cancel-optin',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('cancel-optin-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(CancelOptinResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('cancel-optin-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # Check the carrier billing eligibility of a previously authenticated
+    # consumer.  The request requires an optin-id.  The eligibility check
+    # consists of checking the account status of the consumer as well as the
+    # billing eligibility.
+    # @param [CheckEligibilityRequest] body Required parameter: TODO: type
+    # description here
+    # @return [CheckEligibilityResponse] Response from the API call.
+    def check_eligibility(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/check-eligibility',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('check-eligibility-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(CheckEligibilityResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('check-eligibility-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # Sends a PIN code via SMS to device associated with consumer's active
+    # opt-in to verify the consumer still controls the device.
+    # For OTP validity semantics, see the 'optin' API method.
+    # For resend functionality see the 'resend-otp' API method.
+    # @param [VerifyDeviceRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [VerifyDeviceResponse] Response from the API call.
+    def verify_device(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/verify-device',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('verify-device-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(VerifyDeviceResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('verify-device-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # Confirm consumer has received PIN code sent to device associated with the
+    # active approval.
+    # @param [ConfirmVerifyDeviceRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [ConfirmVerifyDeviceResponse] Response from the API call.
+    def confirm_verify_device(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/confirm-verify-device',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('confirm-verify-device-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(ConfirmVerifyDeviceResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('confirm-verify-device-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The purpose of the ‘msisdn-network’ API is to identify the mobile operator
+    # network for a provided msisdn. If the mobile operator network is
+    # successfully determined, a Boku network identifier is returned.
+    # @param [MsisdnNetworkRequest] body Required parameter: TODO: type
+    # description here
+    # @return [MsisdnNetworkResponse] Response from the API call.
+    def get_msisdn_network(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/msisdn-network',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('msisdn-network-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(MsisdnNetworkResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('msisdn-network-response')))
+        .execute
+    end
+
+    # The 'optin-info' call returns available opt-in methods on a per-carrier
+    # basis, for all supported carriers. Namely, while the 'network-info'
+    # request returns all carrier networks in a country, the 'optin-info'
+    # request returns only carrier networks that support carrier billing with
+    # the merchant. The returned data is intended to be used for selecting from
+    # available opt-in methods, and where possible allow a client device to
+    # initiate an opt-in using only the data returned by this call, rather than
+    # having to make a round-trip call to `optin`. The data returned from
+    # 'optin-info' is not specific to any one specific transaction or set of
+    # parameters, and is designed to be reused across multiple opt-ins.
+    # # Referenced opt-in methods
+    # Several opt-in methods are provided. The appropriate opt-in method will
+    # vary based on consumer platform and consumer connectivity.
+    # The use of a one-time PIN optin can be used with consumers on any platform
+    # and with any connectivity.  The carrier gateway method and the silent MO
+    # methods can be used to optimize the experience of consumers on mobile
+    # devices.
+    # | Optin Method | Platform | Connectivity |
+    # |--------------|----------|--------------|
+    # | **opt**: send a one-time PIN to the end-user via SMS, which will be
+    # confirmed via confirm-optin | Any | Carrier data network, Wifi |
+    # | **carrier-gw**: attempt to verify the consumer using a ping through a
+    # carrier gateway | Mobile device | Carrier data network |
+    # | **silent-mo**: verify the consumer by sending a silent SMS from the
+    # device | Mobile device | Carrier data network, WiFi |
+    # # 'optin-info' caching
+    # The `optin-info` data is relatively static, and usually only changes due
+    # to either a carrier system migration (changing URL or short-code), or in
+    # rare cases an emergency re-routing of traffic via an alternate route in
+    # the case of carrier outages. Therefore, optin-info data is cacheable for
+    # relatively long periods - Boku recommends roughly 5 minutes. HTTP cache
+    # control headers are provided with the response which, if followed,
+    # implement Boku's recommended caching strategy.
+    # # 'optin-info' placeholder values
+    # The `client-call` `url` and `send-sms` body returned by an optin-info call
+    # may contain values that must be filled out at runtime specific to the
+    # current request in the form of '{placeholder-name}'.
+    # When using these strings, all placeholders must be replaced. If an unknown
+    # placeholder is encountered, the containing element should be treated as
+    # invalid.
+    # The current list of placeholder values is as follows:
+    # * **merchant-request-id**: This value has the same semantics as the
+    # `merchant-request-id` value in an `optin-request`. It must be replaced
+    # with a ID unique to each usage of the URL / SMS message / etc.
+    # @param [String] merchant_id Required parameter: TODO: type description
+    # here
+    # @return [OptinInfo] Response from the API call.
+    def get_optin_info(merchant_id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/optin/3.0/optin-info/{merchantId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(merchant_id, key: 'merchantId')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/xml', key: 'accept')))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(OptinInfo)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('optin-info')))
+        .execute
+    end
+
+    # Retrieves the status and all details of optin matching the given request
+    # criteria.
+    # Requires the following values to be exclusively provided: optin-id,
+    # merchant-id
+    # @param [QueryOptinRequest] body Optional parameter: TODO: type description
+    # here
+    # @return [QueryOptinResponse] Response from the API call.
+    def query_optin(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/query-optin',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('query-optin-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(QueryOptinResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('query-optin-response')))
+        .execute
+    end
+
+    # When a user has started an opt-in using the `otpin` method or a
+    # re-verification session using `verify-device` method, they may
+    # subsequently request the OTP to be re-sent. This may be required if
+    # network related issues prevented the successful delivery of the OTP
+    # message to the user. Currently 'resend-otp' is limited to three calls per
+    # unique opt-in. The PIN expiration is not reset when this method is called.
+    # @param [ResendOtpRequest] body Optional parameter: TODO: type description
+    # here
+    # @return [ResendOtpResponse] Response from the API call.
+    def resend_otp(body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/optin/3.0/resend-otp',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('resend-otp-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(ResendOtpResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('resend-otp-response')))
+        .execute
+    end
+  end
+end

data/lib/boku_direct_payments_api/controllers/forex_controller.rb

@@ -0,0 +1,38 @@
+# boku_direct_payments_api
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module BokuDirectPaymentsApi
+  # ForexController
+  class ForexController < BaseController
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The 'forex' request retrieves the latest foreign exchange rate for a given
+    # source and destination currency. Boku's foreign exchange rates are daily
+    # average mid-point rates and are updated every 24 hours.
+    # @param [ForexRequest] body Required parameter: TODO: type description
+    # here
+    # @return [ForexResponse] Response from the API call.
+    def forex(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/billing/3.0/forex',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('forex-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(ForexResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('forex-response')))
+        .execute
+    end
+  end
+end

data/lib/boku_direct_payments_api/controllers/fund_check_controller.rb

@@ -0,0 +1,39 @@
+# boku_direct_payments_api
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module BokuDirectPaymentsApi
+  # FundCheckController
+  class FundCheckController < BaseController
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The 'fund-check' request schedules a balance check for a given optin for
+    # the amount send in request. If there is not enough balance, sms is send
+    # for further user action to top-up balance. Sms will only be send once
+    # every seven days for any number of fund-check request.
+    # @param [FundCheckRequest] body Required parameter: TODO: type description
+    # here
+    # @return [FundCheckResponse] Response from the API call.
+    def schedule_fund_check(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/billing/3.0/fund-check',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('fund-check-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(FundCheckResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('fund-check-response')))
+        .execute
+    end
+  end
+end

data/lib/boku_direct_payments_api/controllers/refund_controller.rb

@@ -0,0 +1,80 @@
+# boku_direct_payments_api
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module BokuDirectPaymentsApi
+  # RefundController
+  class RefundController < BaseController
+    # Refunds a confirmed payment from the consumer. The refund request must
+    # include the ID of the original charge and a valid reason code that matches
+    # one of Boku’s supported [refund codes](page:refund-reason-codes). By
+    # default, the full amount of the referenced charge is refunded.
+    # If the issuer supports partial refunds, merchants can specify a refund
+    # amount less than the full charge. Partial refunds may be issued multiple
+    # times until the full amount of the original charge has been refunded.
+    # @param [RefundChargeRequest] body Required parameter: TODO: type
+    # description here
+    # @param [String] host Optional parameter: TODO: type description here
+    # @return [RefundChargeResponse] Response from the API call.
+    def refund_charge(body,
+                      host: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/billing/3.0/refund-charge',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('refund-charge-request'))
+                   .header_param(new_parameter(host, key: 'Host'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(RefundChargeResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('refund-charge-response')))
+        .execute
+    end
+
+    # Retrieves the status and all details of prior refunds matching the given
+    # request criteria.
+    # Each returned refund element is similar to a refund-charge-response:
+    # although some elements are missing, all present elements have the same
+    # names, format, and meaning as those in the original
+    # refund-charge-response.
+    # The query-refund API call is guaranteed to return transactions up to 1
+    # year old. If the transaction was created before that period, this API may
+    # return no results.
+    # Criteria are evaluated in an AND fashion, i.e. if more than one field is
+    # supplied then all will be used to filter the returned refund elements. In
+    # normal usage, this is not relevant, since you would only supply one of the
+    # three fields by itself.
+    # The query-refund request one of the following values to be exclusively
+    # provided: refund-id or merchant-request-id.
+    # @param [QueryRefundRequest] body Required parameter: TODO: type
+    # description here
+    # @return [QueryRefundResponse] Response from the API call.
+    def query_refund(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/billing/3.0/query-refund',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('query-refund-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(QueryRefundResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('query-refund-response')))
+        .execute
+    end
+  end
+end

data/lib/boku_direct_payments_api/controllers/seller_of_record_controller.rb

@@ -0,0 +1,69 @@
+# boku_direct_payments_api
+#
+# This file was automatically generated by
+# APIMATIC v3.0 ( https://www.apimatic.io ).
+
+module BokuDirectPaymentsApi
+  # SellerOfRecordController
+  class SellerOfRecordController < BaseController
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The register-payment-method call notifies Boku to initiate the onboarding
+    # of a payment method. Once the payment method is "approved", the seller of
+    # record can accept payments using the requested payment method.
+    # @param [RegisterPaymentMethodRequest] body Required parameter: TODO: type
+    # description here
+    # @return [RegisterPaymentMethodResponse] Response from the API call.
+    def register_payment_method(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/seller-of-record/1.0/register-payment-method',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('register-payment-method-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(RegisterPaymentMethodResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('register-payment-method-response')))
+        .execute
+    end
+
+    # **DISCLAIMER: This API or element is use-case specific and not needed for
+    # generic usage of our payment product. Please disregard unless otherwise
+    # directed to include in your integration.**
+    # The 'register-seller-of-record' API collects required information for the
+    # seller of record to be onboarded on the Boku platform. Information
+    # provided here may be used to enable the seller of record with various
+    # payment methods. This API call returns a response with a
+    # seller-of-record-id, which will be used in subsequent API calls.
+    # @param [RegisterSellerOfRecordRequest] body Required parameter: TODO: type
+    # description here
+    # @return [RegisterSellerOfRecordResponse] Response from the API call.
+    def register_seller_of_record(body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/seller-of-record/1.0/register-seller-of-record',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/xml', key: 'Content-Type'))
+                   .xml_attributes(XmlAttributes.new
+                                                .value(body)
+                                                .root_element_name('register-seller-of-record-request'))
+                   .header_param(new_parameter('application/xml', key: 'accept'))
+                   .body_serializer(XmlUtilities.method(:serialize_to_xml)))
+        .response(new_response_handler
+                    .deserializer(XmlUtilities.method(:deserialize_xml))
+                    .deserialize_into(RegisterSellerOfRecordResponse)
+                    .is_xml_response(true)
+                    .xml_attribute(XmlAttributes.new
+                                                .root_element_name('register-seller-of-record-response')))
+        .execute
+    end
+  end
+end