mt-sdk 0.0.1

data/lib/modern_treasury/controllers/payment_order_controller.rb

@@ -0,0 +1,368 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # PaymentOrderController
+  class PaymentOrderController < BaseController
+    # 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.
+    def create_async_payment_order(idempotency_key: nil,
+                                   body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/payment_orders/create_async',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('basic_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AsyncResponse.method(:from_hash))
+                    .local_error('403',
+                                 'forbidden',
+                                 ErrorMessageException))
+        .execute
+    end
+
+    # Get a list of all payment orders
+    # @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
+    # transfer, respectively. For check payments, `high` can mean an overnight
+    # check rather than standard mail.
+    # @param [UUID | String] counterparty_id Optional parameter: TODO: type
+    # description here
+    # @param [UUID | String] originating_account_id Optional parameter: TODO:
+    # 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 [String] reference_number Optional parameter: Query for records
+    # with the provided reference number
+    # @param [Date] effective_date_start Optional parameter: An inclusive lower
+    # bound for searching effective_date
+    # @param [Date] effective_date_end Optional parameter: An inclusive upper
+    # bound for searching effective_date
+    # @param [Hash[String, String]] metadata Optional parameter: For example, if
+    # 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,
+                            type: nil,
+                            priority: nil,
+                            counterparty_id: nil,
+                            originating_account_id: nil,
+                            transaction_id: nil,
+                            status: nil,
+                            direction: nil,
+                            reference_number: nil,
+                            effective_date_start: nil,
+                            effective_date_end: nil,
+                            metadata: nil,
+                            after_cursor: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/payment_orders',
+                                     Server::DEFAULT)
+                   .query_param(new_parameter(per_page, key: 'per_page'))
+                   .query_param(new_parameter(type, key: 'type'))
+                   .query_param(new_parameter(priority, key: 'priority'))
+                   .query_param(new_parameter(counterparty_id, key: 'counterparty_id'))
+                   .query_param(new_parameter(originating_account_id, key: 'originating_account_id'))
+                   .query_param(new_parameter(transaction_id, key: 'transaction_id'))
+                   .query_param(new_parameter(status, key: 'status'))
+                   .query_param(new_parameter(direction, key: 'direction'))
+                   .query_param(new_parameter(reference_number, key: 'reference_number'))
+                   .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_response_array(true))
+        .execute
+    end
+
+    # Create a new Payment Order
+    # @param [Type5Enum] 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`,
+    # `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 [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
+    # 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
+    # transfer, respectively. For check payments, `high` can mean an overnight
+    # check rather than standard mail.
+    # @param [UUID | String] receiving_account_id 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
+    # internal account.
+    # @param [Accounting] accounting Optional parameter: TODO: type description
+    # here
+    # @param [UUID | String] accounting_category_id Optional parameter: The ID
+    # of one of your accounting categories. Note that these will only be
+    # accessible if your accounting system has been connected.
+    # @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 [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
+    # weekend. Format: yyyy-mm-dd.
+    # @param [String] description Optional parameter: An optional description
+    # for internal use.
+    # @param [String] statement_descriptor Optional parameter: An optional
+    # descriptor which will appear in the receiver's statement. For `check`
+    # payments this field will be used as the memo line. For `ach` the maximum
+    # length is 10 characters. Note that for ACH payments, the name on your bank
+    # account will be included automatically by the bank, so you can use the
+    # characters for other useful information. For `eft` the maximum length is
+    # 15 characters.
+    # @param [String] remittance_information Optional parameter: For `ach`, this
+    # field will be passed through on an addenda record. For `wire` payments the
+    # field will be passed through as the "Originator to Beneficiary
+    # Information", also known as OBI or Fedwire tag 6000.
+    # @param [String] purpose Optional parameter: For `wire`, this is usually
+    # the purpose which is transmitted via the "InstrForDbtrAgt" field in the
+    # ISO20022 file. If you are using Currencycloud, this is the
+    # `payment.purpose_code` field. For `eft`, this field is the 3 digit CPA
+    # 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
+    # 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
+    # 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.
+    # @param [String] foreign_exchange_contract Optional parameter: If present,
+    # indicates a specific foreign exchange contract number that has been
+    # generated by your financial institution.
+    # @param [TrueClass | FalseClass] nsf_protected Optional parameter: A
+    # boolean to determine if NSF Protection is enabled for this payment order.
+    # Note that this setting must also be turned on in your organization
+    # settings page.
+    # @param [String] originating_party_name Optional parameter: If present,
+    # this will replace your default company name on receiver's bank statement.
+    # This field can only be used for ACH payments currently. For ACH, only the
+    # first 16 characters of this string will be used. Any additional characters
+    # will be truncated.
+    # @param [String] ultimate_originating_party_name Optional parameter: Name
+    # of the ultimate originator of the payment order.
+    # @param [String] ultimate_originating_party_identifier Optional parameter:
+    # Identifier of the ultimate originator of the payment order.
+    # @param [String] ultimate_receiving_party_name Optional parameter: Name of
+    # the ultimate funds recipient.
+    # @param [String] ultimate_receiving_party_identifier Optional parameter:
+    # Identifier of the ultimate funds recipient.
+    # @param [TrueClass | FalseClass] send_remittance_advice Optional parameter:
+    # Send an email to the counterparty when the payment order is sent to the
+    # 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 [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
+    # internal account.
+    # @param [LedgerTransactionCreateRequest] ledger_transaction Optional
+    # parameter: TODO: type description here
+    # @param [Array[LineItemRequest]] line_items Optional parameter: An array of
+    # line items that must sum up to the amount of the payment order.
+    # @param [TrueClass | FalseClass] transaction_monitoring_enabled Optional
+    # parameter: A flag that determines whether a payment order should go
+    # through transaction monitoring.
+    # @param [Array[DocumentCreateRequest]] documents Optional parameter: An
+    # 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.
+    def create_payment_order(type,
+                             amount,
+                             direction,
+                             originating_account_id,
+                             content_type: nil,
+                             idempotency_key: nil,
+                             subtype: nil,
+                             priority: nil,
+                             receiving_account_id: nil,
+                             accounting: nil,
+                             accounting_category_id: nil,
+                             accounting_ledger_class_id: nil,
+                             currency: nil,
+                             effective_date: nil,
+                             description: nil,
+                             statement_descriptor: nil,
+                             remittance_information: nil,
+                             purpose: nil,
+                             metadata: nil,
+                             charge_bearer: nil,
+                             foreign_exchange_indicator: nil,
+                             foreign_exchange_contract: nil,
+                             nsf_protected: nil,
+                             originating_party_name: nil,
+                             ultimate_originating_party_name: nil,
+                             ultimate_originating_party_identifier: nil,
+                             ultimate_receiving_party_name: nil,
+                             ultimate_receiving_party_identifier: nil,
+                             send_remittance_advice: nil,
+                             expires_at: nil,
+                             fallback_type: nil,
+                             receiving_account: nil,
+                             ledger_transaction: nil,
+                             line_items: nil,
+                             transaction_monitoring_enabled: nil,
+                             documents: nil)
+      @api_call
+        .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'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .form_param(new_parameter(subtype, key: 'subtype'))
+                   .form_param(new_parameter(priority, key: 'priority'))
+                   .form_param(new_parameter(receiving_account_id, key: 'receiving_account_id'))
+                   .form_param(new_parameter(accounting, key: 'accounting'))
+                   .form_param(new_parameter(accounting_category_id, key: 'accounting_category_id'))
+                   .form_param(new_parameter(accounting_ledger_class_id, key: 'accounting_ledger_class_id'))
+                   .form_param(new_parameter(currency, key: 'currency'))
+                   .form_param(new_parameter(effective_date, key: 'effective_date'))
+                   .form_param(new_parameter(description, key: 'description'))
+                   .form_param(new_parameter(statement_descriptor, key: 'statement_descriptor'))
+                   .form_param(new_parameter(remittance_information, key: 'remittance_information'))
+                   .form_param(new_parameter(purpose, key: 'purpose'))
+                   .form_param(new_parameter(metadata, key: 'metadata'))
+                   .form_param(new_parameter(charge_bearer, key: 'charge_bearer'))
+                   .form_param(new_parameter(foreign_exchange_indicator, key: 'foreign_exchange_indicator'))
+                   .form_param(new_parameter(foreign_exchange_contract, key: 'foreign_exchange_contract'))
+                   .form_param(new_parameter(nsf_protected, key: 'nsf_protected'))
+                   .form_param(new_parameter(originating_party_name, key: 'originating_party_name'))
+                   .form_param(new_parameter(ultimate_originating_party_name, key: 'ultimate_originating_party_name'))
+                   .form_param(new_parameter(ultimate_originating_party_identifier, key: 'ultimate_originating_party_identifier'))
+                   .form_param(new_parameter(ultimate_receiving_party_name, key: 'ultimate_receiving_party_name'))
+                   .form_param(new_parameter(ultimate_receiving_party_identifier, key: 'ultimate_receiving_party_identifier'))
+                   .form_param(new_parameter(send_remittance_advice, key: 'send_remittance_advice'))
+                   .form_param(new_parameter(expires_at, key: 'expires_at'))
+                   .form_param(new_parameter(fallback_type, key: 'fallback_type'))
+                   .form_param(new_parameter(receiving_account, key: 'receiving_account'))
+                   .form_param(new_parameter(ledger_transaction, key: 'ledger_transaction'))
+                   .form_param(new_parameter(line_items, key: 'line_items'))
+                   .form_param(new_parameter(transaction_monitoring_enabled, key: 'transaction_monitoring_enabled'))
+                   .form_param(new_parameter(documents, key: 'documents'))
+                   .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
+                   .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))
+                    .local_error('400',
+                                 'parameter_invalid',
+                                 ErrorMessageException)
+                    .local_error('401',
+                                 'unsuccessful',
+                                 ErrorMessageException)
+                    .local_error('403',
+                                 'forbidden',
+                                 ErrorMessageException)
+                    .local_error('422',
+                                 'unsuccessful',
+                                 ErrorMessageException))
+        .execute
+    end
+
+    # Get details on a single payment order
+    # @param [String] id Required parameter: TODO: type description here
+    # @return [PaymentOrder] Response from the API call.
+    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')
+                                    .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))
+                    .local_error('404',
+                                 'not found',
+                                 ErrorMessageException))
+        .execute
+    end
+
+    # Update a payment order
+    # @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.
+    def update_payment_order(id,
+                             body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/api/payment_orders/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('basic_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentOrder.method(:from_hash))
+                    .local_error('404',
+                                 'not found',
+                                 ErrorMessageException)
+                    .local_error('422',
+                                 'parameter_invalid',
+                                 ErrorMessageException))
+        .execute
+    end
+  end
+end

data/lib/modern_treasury/controllers/payment_reference_controller.rb

@@ -0,0 +1,64 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # PaymentReferenceController
+  class PaymentReferenceController < BaseController
+    # TODO: type endpoint 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
+    # 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,
+                                referenceable_id: nil,
+                                referenceable_type: nil,
+                                reference_number: nil,
+                                after_cursor: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/payment_references',
+                                     Server::DEFAULT)
+                   .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_response_array(true))
+        .execute
+    end
+
+    # TODO: type endpoint description here
+    # @param [String] id Required parameter: id
+    # @return [PaymentReferenceObject] Response from the API call.
+    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')
+                                    .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)))
+        .execute
+    end
+  end
+end

data/lib/modern_treasury/controllers/ping_controller.rb

@@ -0,0 +1,34 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # PingController
+  class PingController < BaseController
+    # A test endpoint often used to confirm credentials and headers are being
+    # passed in correctly.
+    # @return [PingResponse] Response from the API call.
+    def ping_api
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/ping',
+                                     Server::DEFAULT)
+                   .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(PingResponse.method(:from_hash))
+                    .local_error('401',
+                                 'unsuccessful',
+                                 ErrorMessageException)
+                    .local_error('429',
+                                 'unsuccessful',
+                                 APIException)
+                    .local_error('500',
+                                 'internal server error',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/modern_treasury/controllers/return_controller.rb

@@ -0,0 +1,105 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # ReturnController
+  class ReturnController < BaseController
+    # Get a list of returns.
+    # @param [Integer] per_page Optional parameter: TODO: type description
+    # here
+    # @param [String] internal_account_id Optional parameter: Specify
+    # `internal_account_id` if you wish to see returns to/from a specific
+    # account.
+    # @param [String] counterparty_id Optional parameter: Specify
+    # `counterparty_id` if you wish to see returns that occurred with a specific
+    # 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
+    # `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,
+                     internal_account_id: nil,
+                     counterparty_id: nil,
+                     returnable_id: nil,
+                     returnable_type: nil,
+                     after_cursor: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/returns',
+                                     Server::DEFAULT)
+                   .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_response_array(true)
+                    .local_error('401',
+                                 'unsuccessful',
+                                 ErrorMessageException))
+        .execute
+    end
+
+    # Create a return.
+    # @param [String] idempotency_key Optional parameter: This key should be
+    # something unique, preferably something like an UUID.
+    # @param [ReturnCreateRequest] body Optional parameter: TODO: type
+    # description here
+    # @return [Return] Response from the API call.
+    def create_return(idempotency_key: nil,
+                      body: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/api/returns',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'Content-Type'))
+                   .header_param(new_parameter(idempotency_key, key: 'Idempotency-Key'))
+                   .body_param(new_parameter(body))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .body_serializer(proc do |param| param.to_json unless param.nil? end)
+                   .auth(Single.new('basic_auth')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Return.method(:from_hash))
+                    .local_error('404',
+                                 'unsuccessful',
+                                 ErrorMessageException)
+                    .local_error('422',
+                                 'unsuccessful',
+                                 ErrorMessageException))
+        .execute
+    end
+
+    # Get a single return.
+    # @param [String] id Required parameter: The ID of an existing return.
+    # @return [Return] Response from the API call.
+    def get_return(id)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/api/returns/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .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))
+                    .local_error('404',
+                                 'not found',
+                                 ErrorMessageException))
+        .execute
+    end
+  end
+end