mt-sdk 0.0.1 → 0.0.2

data/lib/modern_treasury/{controllers/ledger_transaction_controller.rb → apis/ledger_transaction_api.rb}

@@ -4,14 +4,14 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # LedgerTransactionController
-  class LedgerTransactionController < BaseController
+  # LedgerTransactionApi
+  class LedgerTransactionApi < BaseApi
     # Create a ledger transaction reversal.
     # @param [String] id Required parameter: The id of ledger transaction to
     # reverse.
     # @param [LedgerTransactionReversalCreateRequest] body Optional parameter:
     # TODO: type description here
-    # @return [LedgerTransaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_ledger_transaction_reversal(id,
                                            body: nil)
       @api_call
@@ -19,6 +19,7 @@ module ModernTreasury
                                      '/api/ledger_transactions/{id}/reversal',
                                      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))
@@ -28,6 +29,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LedgerTransaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException)
@@ -38,6 +40,8 @@ module ModernTreasury
     end
 
     # Get a list of ledger transaction versions.
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [Hash[String, DateTime]] created_at Optional parameter: Use `gt`
@@ -53,30 +57,29 @@ module ModernTreasury
     # @param [String] ledger_account_statement_id Optional parameter: Get all
     # ledger transaction versions that are included in the ledger account
     # statement.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[LedgerTransactionVersion]] Response from the API call.
-    def list_ledger_transaction_versions(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_ledger_transaction_versions(after_cursor: nil,
+                                         per_page: nil,
                                          created_at: nil,
                                          version: nil,
                                          ledger_transaction_id: nil,
-                                         ledger_account_statement_id: nil,
-                                         after_cursor: nil)
+                                         ledger_account_statement_id: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/ledger_transaction_versions',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(created_at, key: 'created_at'))
                    .query_param(new_parameter(version, key: 'version'))
                    .query_param(new_parameter(ledger_transaction_id, key: 'ledger_transaction_id'))
                    .query_param(new_parameter(ledger_account_statement_id, key: 'ledger_account_statement_id'))
-                   .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(LedgerTransactionVersion.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true)
                     .local_error('404',
                                  'not found',
@@ -85,6 +88,8 @@ module ModernTreasury
     end
 
     # Get a list of ledger transactions.
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [Hash[String, String]] id Optional parameter: TODO: type
@@ -117,7 +122,7 @@ module ModernTreasury
     # `effective_at` in `asc` or `desc` order. For example, to order by
     # `effective_at asc`, use `order_by%5Beffective_at%5D=asc`. Ordering by only
     # one field at a time is supported.
-    # @param [Status22Enum] status Optional parameter: Example:
+    # @param [Status22] status Optional parameter: Example:
     # @param [String] external_id Optional parameter: TODO: type description
     # here
     # @param [String] ledger_account_category_id Optional parameter: TODO: type
@@ -128,12 +133,10 @@ module ModernTreasury
     # type description here
     # @param [String] ledgerable_id Optional parameter: TODO: type description
     # here
-    # @param [LedgerableType6Enum] ledgerable_type Optional parameter:
-    # Example:
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[LedgerTransaction]] Response from the API call.
-    def list_ledger_transactions(per_page: nil,
+    # @param [LedgerableType6] ledgerable_type Optional parameter: Example:
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_ledger_transactions(after_cursor: nil,
+                                 per_page: nil,
                                  id: nil,
                                  metadata: nil,
                                  ledger_id: nil,
@@ -149,12 +152,12 @@ module ModernTreasury
                                  ledger_account_payout_id: nil,
                                  reverses_ledger_transaction_id: nil,
                                  ledgerable_id: nil,
-                                 ledgerable_type: nil,
-                                 after_cursor: nil)
+                                 ledgerable_type: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/ledger_transactions',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(id, key: 'id'))
                    .query_param(new_parameter(metadata, key: 'metadata'))
@@ -172,12 +175,12 @@ module ModernTreasury
                    .query_param(new_parameter(reverses_ledger_transaction_id, key: 'reverses_ledger_transaction_id'))
                    .query_param(new_parameter(ledgerable_id, key: 'ledgerable_id'))
                    .query_param(new_parameter(ledgerable_type, key: 'ledgerable_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(LedgerTransaction.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true)
                     .local_error('422',
                                  'parameter invalid',
@@ -190,7 +193,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [LedgerTransactionCreateRequest] body Optional parameter: TODO:
     # type description here
-    # @return [LedgerTransaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_ledger_transaction(idempotency_key: nil,
                                   body: nil)
       @api_call
@@ -206,6 +209,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LedgerTransaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('403',
                                  'forbidden',
                                  ErrorMessageException)
@@ -223,19 +227,21 @@ module ModernTreasury
 
     # Get details on a single ledger transaction.
     # @param [String] id Required parameter: id
-    # @return [LedgerTransaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_ledger_transaction(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/ledger_transactions/{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(LedgerTransaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))
@@ -246,7 +252,7 @@ module ModernTreasury
     # @param [String] id Required parameter: id
     # @param [LedgerTransactionUpdateRequest] body Optional parameter: TODO:
     # type description here
-    # @return [LedgerTransaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_ledger_transaction(id,
                                   body: nil)
       @api_call
@@ -254,6 +260,7 @@ module ModernTreasury
                                      '/api/ledger_transactions/{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))
@@ -263,6 +270,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LedgerTransaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('400',
                                  'parameter_invalid',
                                  ErrorMessageException)
@@ -294,7 +302,7 @@ module ModernTreasury
     # @param [Hash[String, Integer]] version Optional parameter: Use `gt` (>),
     # `gte` (>=), `lt` (<), `lte` (<=), or `eq` (=) to filter by the version.
     # For example, for all versions after 2, use version%5Bgt%5D=2.
-    # @return [Array[LedgerTransactionVersion]] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def list_ledger_transaction_versions1(id,
                                           after_cursor: nil,
                                           per_page: nil,
@@ -305,6 +313,7 @@ module ModernTreasury
                                      '/api/ledger_transactions/{id}/versions',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: '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'))
@@ -315,6 +324,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LedgerTransactionVersion.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true)
                     .local_error('404',
                                  'not found',

data/lib/modern_treasury/{controllers/ledgerable_event_controller.rb → apis/ledgerable_event_api.rb}

@@ -4,15 +4,15 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # LedgerableEventController
-  class LedgerableEventController < BaseController
+  # LedgerableEventApi
+  class LedgerableEventApi < BaseApi
     # Translation missing:
     # en.openapi.descriptions.ledger.operations.create_ledgerable_event
     # @param [String] idempotency_key Optional parameter: This key should be
     # something unique, preferably something like an UUID.
     # @param [LedgerableEventCreateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [LedgerableEvent] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_ledgerable_event(idempotency_key: nil,
                                 body: nil)
       @api_call
@@ -28,6 +28,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LedgerableEvent.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('403',
                                  'forbidden',
                                  ErrorMessageException)
@@ -39,19 +40,21 @@ module ModernTreasury
 
     # Get details on a single ledgerable event.
     # @param [String] id Required parameter: id
-    # @return [LedgerableEvent] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_ledgerable_event(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/ledgerable_events/{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(LedgerableEvent.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))

data/lib/modern_treasury/{controllers/line_item_controller.rb → apis/line_item_api.rb}

@@ -4,18 +4,18 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # LineItemController
-  class LineItemController < BaseController
+  # LineItemApi
+  class LineItemApi < BaseApi
     # Get a list of line items
     # @param [String] itemizable_id Required parameter: The ID of the payment
     # order or expected payment.
-    # @param [ItemizableType1Enum] itemizable_type Required parameter: One of
+    # @param [ItemizableType1] itemizable_type Required parameter: One of
     # `payment_orders` or `expected_payments`.
     # @param [String] after_cursor Optional parameter: TODO: type description
     # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
-    # @return [Array[LineItem]] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def list_line_items(itemizable_id,
                         itemizable_type,
                         after_cursor: nil,
@@ -25,8 +25,10 @@ module ModernTreasury
                                      '/api/{itemizable_type}/{itemizable_id}/line_items',
                                      Server::DEFAULT)
                    .template_param(new_parameter(itemizable_id, key: 'itemizable_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .template_param(new_parameter(itemizable_type, key: 'itemizable_type')
+                                    .is_required(true)
                                     .should_encode(true))
                    .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
@@ -35,6 +37,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LineItem.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
@@ -42,10 +45,10 @@ module ModernTreasury
     # Get a single line item
     # @param [String] itemizable_id Required parameter: The ID of the payment
     # order or expected payment.
-    # @param [ItemizableType1Enum] itemizable_type Required parameter: One of
+    # @param [ItemizableType1] itemizable_type Required parameter: One of
     # `payment_orders` or `expected_payments`.
     # @param [String] id Required parameter: The ID of the line item.
-    # @return [LineItem] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_line_item(itemizable_id,
                       itemizable_type,
                       id)
@@ -54,28 +57,32 @@ module ModernTreasury
                                      '/api/{itemizable_type}/{itemizable_id}/line_items/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(itemizable_id, key: 'itemizable_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .template_param(new_parameter(itemizable_type, key: 'itemizable_type')
+                                    .is_required(true)
                                     .should_encode(true))
                    .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(LineItem.method(:from_hash)))
+                    .deserialize_into(LineItem.method(:from_hash))
+                    .is_api_response(true))
         .execute
     end
 
     # TODO: type endpoint description here
     # @param [String] itemizable_id Required parameter: The ID of the payment
     # order or expected payment.
-    # @param [ItemizableType1Enum] itemizable_type Required parameter: One of
+    # @param [ItemizableType1] itemizable_type Required parameter: One of
     # `payment_orders` or `expected_payments`.
     # @param [String] id Required parameter: The ID of the line item.
     # @param [LineItemUpdateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [LineItem] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_line_item(itemizable_id,
                          itemizable_type,
                          id,
@@ -85,10 +92,13 @@ module ModernTreasury
                                      '/api/{itemizable_type}/{itemizable_id}/line_items/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(itemizable_id, key: 'itemizable_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .template_param(new_parameter(itemizable_type, key: 'itemizable_type')
+                                    .is_required(true)
                                     .should_encode(true))
                    .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))
@@ -98,6 +108,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(LineItem.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('422',
                                  'unsuccessful',
                                  ErrorMessageException))

data/lib/modern_treasury/{controllers/paper_item_controller.rb → apis/paper_item_api.rb}

@@ -4,8 +4,8 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # PaperItemController
-  class PaperItemController < BaseController
+  # PaperItemApi
+  class PaperItemApi < BaseApi
     # Get a list of all paper items.
     # @param [String] lockbox_number Optional parameter: Specify
     # `lockbox_number` if you wish to see paper items that are associated with a
@@ -14,16 +14,16 @@ module ModernTreasury
     # start date (YYYY-MM-DD) when filtering by deposit_date
     # @param [Date] deposit_date_end Optional parameter: Specify an inclusive
     # end date (YYYY-MM-DD) when filtering by deposit_date
-    # @param [Integer] per_page Optional parameter: TODO: type description
-    # here
     # @param [String] after_cursor Optional parameter: TODO: type description
     # here
-    # @return [Array[PaperItem]] Response from the API call.
+    # @param [Integer] per_page Optional parameter: TODO: type description
+    # here
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def list_paper_items(lockbox_number: nil,
                          deposit_date_start: nil,
                          deposit_date_end: nil,
-                         per_page: nil,
-                         after_cursor: nil)
+                         after_cursor: nil,
+                         per_page: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/paper_items',
@@ -31,32 +31,35 @@ module ModernTreasury
                    .query_param(new_parameter(lockbox_number, key: 'lockbox_number'))
                    .query_param(new_parameter(deposit_date_start, key: 'deposit_date_start'))
                    .query_param(new_parameter(deposit_date_end, key: 'deposit_date_end'))
-                   .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(after_cursor, key: 'after_cursor'))
+                   .query_param(new_parameter(per_page, key: 'per_page'))
                    .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(PaperItem.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
 
     # Get details on a single paper item.
     # @param [String] id Required parameter: id
-    # @return [PaperItem] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_paper_item(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/paper_items/{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(PaperItem.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('403',
                                  'forbidden',
                                  ErrorMessageException)

data/lib/modern_treasury/{controllers/payment_flow_controller.rb → apis/payment_flow_api.rb}

@@ -4,9 +4,11 @@
 # https://www.apimatic.io ).
 
 module ModernTreasury
-  # PaymentFlowController
-  class PaymentFlowController < BaseController
+  # PaymentFlowApi
+  class PaymentFlowApi < 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] client_token Optional parameter: TODO: type description
@@ -20,21 +22,20 @@ module ModernTreasury
     # description here
     # @param [String] payment_order_id Optional parameter: TODO: type
     # description here
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[PaymentFlow]] Response from the API call.
-    def list_payment_flows(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_payment_flows(after_cursor: nil,
+                           per_page: nil,
                            client_token: nil,
                            status: nil,
                            counterparty_id: nil,
                            receiving_account_id: nil,
                            originating_account_id: nil,
-                           payment_order_id: nil,
-                           after_cursor: nil)
+                           payment_order_id: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/payment_flows',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(client_token, key: 'client_token'))
                    .query_param(new_parameter(status, key: 'status'))
@@ -42,12 +43,12 @@ module ModernTreasury
                    .query_param(new_parameter(receiving_account_id, key: 'receiving_account_id'))
                    .query_param(new_parameter(originating_account_id, key: 'originating_account_id'))
                    .query_param(new_parameter(payment_order_id, key: 'payment_order_id'))
-                   .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(PaymentFlow.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
@@ -57,7 +58,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [PaymentFlowCreateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [PaymentFlow] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_payment_flow(idempotency_key: nil,
                             body: nil)
       @api_call
@@ -73,6 +74,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentFlow.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('422',
                                  'unsuccessful',
                                  ErrorMessageException))
@@ -83,7 +85,7 @@ module ModernTreasury
     # @param [String] id Required parameter: id
     # @param [String] idempotency_key Optional parameter: This key should be
     # something unique, preferably something like an UUID.
-    # @return [PaymentFlow] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_payment_flow(id,
                          idempotency_key: nil)
       @api_call
@@ -91,13 +93,15 @@ module ModernTreasury
                                      '/api/payment_flows/{id}',
                                      Server::DEFAULT)
                    .template_param(new_parameter(id, key: 'id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
                    .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(PaymentFlow.method(:from_hash)))
+                    .deserialize_into(PaymentFlow.method(:from_hash))
+                    .is_api_response(true))
         .execute
     end
 
@@ -107,7 +111,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [PaymentFlowUpdateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [PaymentFlow] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_payment_flow(id,
                             idempotency_key: nil,
                             body: nil)
@@ -116,6 +120,7 @@ module ModernTreasury
                                      '/api/payment_flows/{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'))
                    .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
@@ -126,6 +131,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(PaymentFlow.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException)