mt-sdk 0.0.1 → 0.0.2

data/lib/modern_treasury/{controllers/payment_order_controller.rb → apis/payment_order_api.rb}

@@ -4,14 +4,14 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # PaymentOrderController
-  class PaymentOrderController < BaseController
+  # PaymentOrderApi
+  class PaymentOrderApi < BaseApi
     # Create a new payment order asynchronously
     # @param [String] idempotency_key Optional parameter: This key should be
     # something unique, preferably something like an UUID.
     # @param [PaymentOrderAsyncCreateRequest] body Optional parameter: TODO:
     # type description here
-    # @return [AsyncResponse] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_async_payment_order(idempotency_key: nil,
                                    body: nil)
       @api_call
@@ -27,6 +27,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(AsyncResponse.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('403',
                                  'forbidden',
                                  ErrorMessageException))
@@ -34,11 +35,13 @@ module ModernTreasury
     end
 
     # Get a list of all payment orders
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
-    # @param [Type13Enum] type Optional parameter: Example:
-    # @param [Priority4Enum] priority Optional parameter: Either `normal` or
-    # `high`. For ACH and EFT payments, `high` represents a same-day ACH or EFT
+    # @param [Type13] type Optional parameter: Example:
+    # @param [Priority4] priority Optional parameter: Either `normal` or `high`.
+    # For ACH and EFT payments, `high` represents a same-day ACH or EFT
     # transfer, respectively. For check payments, `high` can mean an overnight
     # check rather than standard mail.
     # @param [UUID | String] counterparty_id Optional parameter: TODO: type
@@ -47,8 +50,8 @@ module ModernTreasury
     # type description here
     # @param [UUID | String] transaction_id Optional parameter: The ID of a
     # transaction that the payment order has been reconciled to.
-    # @param [Status24Enum] status Optional parameter: Example:
-    # @param [Direction15Enum] direction Optional parameter: Example:
+    # @param [Status24] status Optional parameter: Example:
+    # @param [Direction15] direction Optional parameter: Example:
     # @param [String] reference_number Optional parameter: Query for records
     # with the provided reference number
     # @param [Date] effective_date_start Optional parameter: An inclusive lower
@@ -59,10 +62,9 @@ module ModernTreasury
     # you want to query for records with metadata key `Type` and value `Loan`,
     # the query would be `metadata%5BType%5D=Loan`. This encodes the query
     # parameters.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[PaymentOrder]] Response from the API call.
-    def list_payment_orders(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_payment_orders(after_cursor: nil,
+                            per_page: nil,
                             type: nil,
                             priority: nil,
                             counterparty_id: nil,
@@ -73,12 +75,12 @@ module ModernTreasury
                             reference_number: nil,
                             effective_date_start: nil,
                             effective_date_end: nil,
-                            metadata: nil,
-                            after_cursor: nil)
+                            metadata: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/payment_orders',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(type, key: 'type'))
                    .query_param(new_parameter(priority, key: 'priority'))
@@ -91,40 +93,40 @@ module ModernTreasury
                    .query_param(new_parameter(effective_date_start, key: 'effective_date_start'))
                    .query_param(new_parameter(effective_date_end, key: 'effective_date_end'))
                    .query_param(new_parameter(metadata, key: 'metadata'))
-                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentOrder.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
 
     # Create a new Payment Order
-    # @param [Type5Enum] type Required parameter: One of `ach`, `eft`, `wire`,
+    # @param [Type5] type Required parameter: One of `ach`, `eft`, `wire`,
     # `check`, `sen`, `book`, `rtp`, `sepa`, `bacs`, `au_becs`, `interac`,
     # `signet`, `provexchange`.
     # @param [Integer] amount Required parameter: Value in specified currency's
     # smallest unit. e.g. $10 would be represented as 1000 (cents). For RTP, the
     # maximum amount allowed by the network is $100,000.
-    # @param [Direction5Enum] direction Required parameter: One of `credit`,
+    # @param [Direction5] direction Required parameter: One of `credit`,
     # `debit`. Describes the direction money is flowing in the transaction. A
     # `credit` moves money from your account to someone else's. A `debit` pulls
     # money from someone else's account to your own. Note that wire, rtp, and
     # check payments will always be `credit`.
     # @param [UUID | String] originating_account_id Required parameter: The ID
     # of one of your organization's internal accounts.
-    # @param [ContentTypeEnum] content_type Optional parameter: Example:
+    # @param [ContentType] content_type Optional parameter: Example:
     # @param [String] idempotency_key Optional parameter: This key should be
     # something unique, preferably something like an UUID.
-    # @param [SubtypeEnum] subtype Optional parameter: An additional layer of
+    # @param [Subtype] subtype Optional parameter: An additional layer of
     # classification for the type of payment order you are doing. This field is
     # only used for `ach` payment orders currently. For `ach`  payment orders,
     # the `subtype`  represents the SEC code. We currently support `CCD`, `PPD`,
     # `IAT`, `CTX`, `WEB`, `CIE`, and `TEL`.
-    # @param [PriorityEnum] priority Optional parameter: Either `normal` or
-    # `high`. For ACH and EFT payments, `high` represents a same-day ACH or EFT
+    # @param [Priority] priority Optional parameter: Either `normal` or `high`.
+    # For ACH and EFT payments, `high` represents a same-day ACH or EFT
     # transfer, respectively. For check payments, `high` can mean an overnight
     # check rather than standard mail.
     # @param [UUID | String] receiving_account_id Optional parameter: Either
@@ -139,8 +141,8 @@ module ModernTreasury
     # @param [UUID | String] accounting_ledger_class_id Optional parameter: The
     # ID of one of your accounting ledger classes. Note that these will only be
     # accessible if your accounting system has been connected.
-    # @param [CurrencyEnum] currency Optional parameter: Three-letter ISO
-    # currency code.
+    # @param [Currency] currency Optional parameter: Three-letter ISO currency
+    # code.
     # @param [Date] effective_date Optional parameter: Date transactions are to
     # be posted to the participants' account. Defaults to the current business
     # day or the next business day if the current day is a bank holiday or
@@ -165,11 +167,11 @@ module ModernTreasury
     # Code that will be attached to the payment.
     # @param [Hash[String, String]] metadata Optional parameter: Additional data
     # represented as key-value pairs. Both the key and value must be strings.
-    # @param [ChargeBearerEnum] charge_bearer Optional parameter: The party that
+    # @param [ChargeBearer] charge_bearer Optional parameter: The party that
     # will pay the fees for the payment order. Only applies to wire payment
     # orders. Can be one of shared, sender, or receiver, which correspond
     # respectively with the SWIFT 71A values `SHA`, `OUR`, `BEN`.
-    # @param [ForeignExchangeIndicatorEnum] foreign_exchange_indicator Optional
+    # @param [ForeignExchangeIndicator] foreign_exchange_indicator Optional
     # parameter: Indicates the type of FX transfer to initiate, can be either
     # `variable_to_fixed`, `fixed_to_variable`, or `null` if the payment order
     # currency matches the originating account currency.
@@ -198,10 +200,10 @@ module ModernTreasury
     # bank. If `null`, `send_remittance_advice` on the Counterparty is used.
     # @param [DateTime] expires_at Optional parameter: RFP payments require an
     # expires_at. This value must be past the effective_date.
-    # @param [FallbackTypeEnum] fallback_type Optional parameter: A payment type
-    # to fallback to if the original type is not valid for the receiving
-    # account. Currently, this only supports falling back from RTP to ACH
-    # (type=rtp and fallback_type=ach)
+    # @param [FallbackType] fallback_type Optional parameter: A payment type to
+    # fallback to if the original type is not valid for the receiving account.
+    # Currently, this only supports falling back from RTP to ACH (type=rtp and
+    # fallback_type=ach)
     # @param [ReceivingAccount1] receiving_account Optional parameter: Either
     # `receiving_account` or `receiving_account_id` must be present. When using
     # `receiving_account_id`, you may pass the id of an external account or an
@@ -217,7 +219,7 @@ module ModernTreasury
     # array of documents to be attached to the payment order. Note that if you
     # attach documents, the request's content type must be
     # `multipart/form-data`.
-    # @return [PaymentOrder] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_payment_order(type,
                              amount,
                              direction,
@@ -258,10 +260,14 @@ module ModernTreasury
         .request(new_request_builder(HttpMethodEnum::POST,
                                      '/api/payment_orders',
                                      Server::DEFAULT)
-                   .form_param(new_parameter(type, key: 'type'))
-                   .form_param(new_parameter(amount, key: 'amount'))
-                   .form_param(new_parameter(direction, key: 'direction'))
-                   .form_param(new_parameter(originating_account_id, key: 'originating_account_id'))
+                   .form_param(new_parameter(type, key: 'type')
+                                .is_required(true))
+                   .form_param(new_parameter(amount, key: 'amount')
+                                .is_required(true))
+                   .form_param(new_parameter(direction, key: 'direction')
+                                .is_required(true))
+                   .form_param(new_parameter(originating_account_id, key: 'originating_account_id')
+                                .is_required(true))
                    .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
                    .form_param(new_parameter(subtype, key: 'subtype'))
                    .form_param(new_parameter(priority, key: 'priority'))
@@ -299,6 +305,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentOrder.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('400',
                                  'parameter_invalid',
                                  ErrorMessageException)
@@ -316,19 +323,21 @@ module ModernTreasury
 
     # Get details on a single payment order
     # @param [String] id Required parameter: TODO: type description here
-    # @return [PaymentOrder] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_payment_order(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/payment_orders/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentOrder.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))
@@ -339,7 +348,7 @@ module ModernTreasury
     # @param [String] id Required parameter: TODO: type description here
     # @param [PaymentOrderUpdateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [PaymentOrder] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_payment_order(id,
                              body: nil)
       @api_call
@@ -347,6 +356,7 @@ module ModernTreasury
                                      '/api/payment_orders/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
                    .body_param(new_parameter(body))
@@ -356,6 +366,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentOrder.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException)

data/lib/modern_treasury/{controllers/payment_reference_controller.rb → apis/payment_reference_api.rb}

@@ -4,60 +4,63 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # PaymentReferenceController
-  class PaymentReferenceController < BaseController
+  # PaymentReferenceApi
+  class PaymentReferenceApi < BaseApi
     # TODO: type endpoint description here
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [String] referenceable_id Optional parameter: The id of the
     # referenceable to search for. Must be accompanied by the referenceable_type
     # or will return an error.
-    # @param [ReferenceableType1Enum] referenceable_type Optional parameter: One
-    # of the referenceable types. This must be accompanied by the id of the
+    # @param [ReferenceableType1] referenceable_type Optional parameter: One of
+    # the referenceable types. This must be accompanied by the id of the
     # referenceable or will return an error.
     # @param [String] reference_number Optional parameter: The actual reference
     # number assigned by the bank.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[PaymentReferenceObject]] Response from the API call.
-    def list_payment_references(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_payment_references(after_cursor: nil,
+                                per_page: nil,
                                 referenceable_id: nil,
                                 referenceable_type: nil,
-                                reference_number: nil,
-                                after_cursor: nil)
+                                reference_number: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/payment_references',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(referenceable_id, key: 'referenceable_id'))
                    .query_param(new_parameter(referenceable_type, key: 'referenceable_type'))
                    .query_param(new_parameter(reference_number, key: 'reference_number'))
-                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentReferenceObject.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
 
     # TODO: type endpoint description here
     # @param [String] id Required parameter: id
-    # @return [PaymentReferenceObject] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_payment_reference(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/payment_references/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(PaymentReferenceObject.method(:from_hash)))
+                    .deserialize_into(PaymentReferenceObject.method(:from_hash))
+                    .is_api_response(true))
         .execute
     end
   end

data/lib/modern_treasury/{controllers/ping_controller.rb → apis/ping_api.rb}

@@ -4,11 +4,11 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # PingController
-  class PingController < BaseController
+  # PingApi
+  class PingApi < BaseApi
     # A test endpoint often used to confirm credentials and headers are being
     # passed in correctly.
-    # @return [PingResponse] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def ping_api
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
@@ -19,6 +19,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PingResponse.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('401',
                                  'unsuccessful',
                                  ErrorMessageException)

data/lib/modern_treasury/{controllers/return_controller.rb → apis/return_api.rb}

@@ -4,9 +4,11 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # ReturnController
-  class ReturnController < BaseController
+  # ReturnApi
+  class ReturnApi < BaseApi
     # Get a list of returns.
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [String] internal_account_id Optional parameter: Specify
@@ -17,33 +19,32 @@ module ModernTreasury
     # counterparty.
     # @param [String] returnable_id Optional parameter: The ID of a valid
     # returnable. Must be accompanied by `returnable_type`.
-    # @param [ReturnableType1Enum] returnable_type Optional parameter: One of
+    # @param [ReturnableType1] returnable_type Optional parameter: One of
     # `payment_order`, `paper_item`, `reversal`, or `incoming_payment_detail`.
     # Must be accompanied by `returnable_id`.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[Return]] Response from the API call.
-    def list_returns(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_returns(after_cursor: nil,
+                     per_page: nil,
                      internal_account_id: nil,
                      counterparty_id: nil,
                      returnable_id: nil,
-                     returnable_type: nil,
-                     after_cursor: nil)
+                     returnable_type: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/returns',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(internal_account_id, key: 'internal_account_id'))
                    .query_param(new_parameter(counterparty_id, key: 'counterparty_id'))
                    .query_param(new_parameter(returnable_id, key: 'returnable_id'))
                    .query_param(new_parameter(returnable_type, key: 'returnable_type'))
-                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Return.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true)
                     .local_error('401',
                                  'unsuccessful',
@@ -56,7 +57,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [ReturnCreateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [Return] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_return(idempotency_key: nil,
                       body: nil)
       @api_call
@@ -72,6 +73,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Return.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'unsuccessful',
                                  ErrorMessageException)
@@ -83,19 +85,21 @@ module ModernTreasury
 
     # Get a single return.
     # @param [String] id Required parameter: The ID of an existing return.
-    # @return [Return] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_return(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/returns/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Return.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))

data/lib/modern_treasury/{controllers/reversal_controller.rb → apis/reversal_api.rb}

@@ -4,8 +4,8 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # ReversalController
-  class ReversalController < BaseController
+  # ReversalApi
+  class ReversalApi < BaseApi
     # Get a list of all reversals of a payment order.
     # @param [String] payment_order_id Required parameter: The ID of the
     # relevant Payment Order.
@@ -13,7 +13,7 @@ module ModernTreasury
     # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
-    # @return [Array[Reversal]] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def list_reversals(payment_order_id,
                        after_cursor: nil,
                        per_page: nil)
@@ -22,6 +22,7 @@ module ModernTreasury
                                      '/api/payment_orders/{payment_order_id}/reversals',
                                      Server::DEFAULT)
                    .template_param(new_parameter(payment_order_id, key: 'payment_order_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
@@ -30,6 +31,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Reversal.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
@@ -41,7 +43,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [ReversalCreateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [Reversal] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_reversal(payment_order_id,
                         idempotency_key: nil,
                         body: nil)
@@ -50,6 +52,7 @@ module ModernTreasury
                                      '/api/payment_orders/{payment_order_id}/reversals',
                                      Server::DEFAULT)
                    .template_param(new_parameter(payment_order_id, key: 'payment_order_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'Content-Type'))
                    .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
@@ -60,6 +63,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Reversal.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'unsuccessful',
                                  ErrorMessageException)
@@ -74,7 +78,7 @@ module ModernTreasury
     # payment order being reversed.
     # @param [UUID | String] reversal_id Required parameter: The ID of the
     # reversal.
-    # @return [Reversal] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_reversal(payment_order_id,
                      reversal_id)
       @api_call
@@ -82,14 +86,17 @@ module ModernTreasury
                                      '/api/payment_orders/{payment_order_id}/reversals/{reversal_id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(payment_order_id, key: 'payment_order_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .template_param(new_parameter(reversal_id, key: 'reversal_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter('application/json', key: 'accept'))
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Reversal.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))