tesser-api-sdk 1.0.0

data/lib/tesser_apiv1/controllers/accounts_controller.rb

@@ -0,0 +1,193 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # AccountsController
+  class AccountsController < BaseController
+    # Retrieve all accounts (both bank and wallet accounts) for your workspace.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [Type4Enum] type Optional parameter: Filter by account type
+    # @param [String] tenant_id Optional parameter: Filter by tenant ID. At most
+    # one of tenant_id or counterparty_id may be provided.
+    # @param [String] counterparty_id Optional parameter: Filter by counterparty
+    # ID. At most one of tenant_id or counterparty_id may be provided.
+    # @param [TrueClass | FalseClass] include_sensitive Optional parameter: If
+    # true, includes sensitive fields like bank_account_number.
+    # @return [AccountListResponse] Response from the API call.
+    def find_all(authorization,
+                 type: nil,
+                 tenant_id: nil,
+                 counterparty_id: nil,
+                 include_sensitive: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .query_param(new_parameter(type, key: 'type'))
+                   .query_param(new_parameter(tenant_id, key: 'tenant_id'))
+                   .query_param(new_parameter(counterparty_id, key: 'counterparty_id'))
+                   .query_param(new_parameter(include_sensitive, key: 'include_sensitive'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AccountListResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Create a new fiat bank account.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [CreateBankRequest] body Required parameter: Bank account details
+    # @return [CreateBankResponse] Response from the API call.
+    def create_bank(authorization,
+                    body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/accounts/banks',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateBankResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Create a new stablecoin wallet account.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [CreateWalletRequest] body Required parameter: Wallet account
+    # details
+    # @return [CreateWalletResponse] Response from the API call.
+    def create_wallet(authorization,
+                      body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/accounts/wallets',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateWalletResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve a specific account (wallet or bank) by its unique identifier
+    # @param [String] id Required parameter: Account ID (UUID)
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [TrueClass | FalseClass] include_sensitive Optional parameter: If
+    # true, includes sensitive fields like bank_account_number.
+    # @return [AccountResponse] Response from the API call.
+    def find_one2(id,
+                  authorization,
+                  include_sensitive: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/accounts/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .query_param(new_parameter(include_sensitive, key: 'include_sensitive'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(AccountResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Update an existing account's information.
+    # @param [String] id Required parameter: Account ID (UUID)
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [UpdateAccountRequest] body Required parameter: TODO: type
+    # description here
+    # @return [UpdateAccountResponse] Response from the API call.
+    def update(id,
+               authorization,
+               body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/accounts/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateAccountResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/base_controller.rb

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

data/lib/tesser_apiv1/controllers/counterparties_controller.rb

@@ -0,0 +1,171 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # CounterpartiesController
+  class CounterpartiesController < BaseController
+    # Create a new counterparty for your workspace.
+    # A counterparty is any external party that your organization transacts
+    # with,
+    # such as vendors, customers, or partners.
+    # **Classifications:**
+    # - **individual**: A natural person (requires first/last name)
+    # - **business**: A legal entity (requires legal name)
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [CreateCounterpartyRequest] body Required parameter: TODO: type
+    # description here
+    # @return [CreateCounterpartyResponse] Response from the API call.
+    def create(authorization,
+               body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/entities/counterparties',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CreateCounterpartyResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve all counterparties for your workspace with optional filtering.
+    # Use query parameters to filter results:
+    # - **classification**: Filter by 'individual' or 'business'
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [Classification7Enum] classification Optional parameter: Filter by
+    # classification
+    # @param [TrueClass | FalseClass] include_secure Optional parameter: Include
+    # secure fields (PII)
+    # @return [CounterpartyListResponse] Response from the API call.
+    def find_all1(authorization,
+                  classification: nil,
+                  include_secure: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/entities/counterparties',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .query_param(new_parameter(classification, key: 'classification'))
+                   .query_param(new_parameter(include_secure, key: 'include_secure'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CounterpartyListResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve a specific counterparty by its unique identifier
+    # @param [String] id Required parameter: Counterparty ID (UUID)
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [Classification7Enum] classification Optional parameter: Filter by
+    # classification ('individual' or 'business').
+    # @param [TrueClass | FalseClass] include_secure Optional parameter: Include
+    # secure fields (PII)
+    # @return [CounterpartyResponse] Response from the API call.
+    def find_one(id,
+                 authorization,
+                 classification: nil,
+                 include_secure: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/entities/counterparties/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .query_param(new_parameter(classification, key: 'classification'))
+                   .query_param(new_parameter(include_secure, key: 'include_secure'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(CounterpartyResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Update an existing counterparty's information.
+    # Only provide the fields you want to update. At least one field must be
+    # provided.
+    # **Note:** If changing classification from 'individual' to 'business' (or
+    # vice versa),
+    # make sure to also provide the appropriate fields for the new
+    # classification.
+    # @param [String] id Required parameter: Counterparty ID (UUID)
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [UpdateCounterpartyRequest] body Required parameter: TODO: type
+    # description here
+    # @return [UpdateCounterpartyResponse] Response from the API call.
+    def update1(id,
+                authorization,
+                body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/entities/counterparties/{id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(id, key: 'id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(UpdateCounterpartyResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/currencies_controller.rb

@@ -0,0 +1,39 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # CurrenciesController
+  class CurrenciesController < BaseController
+    # Retrieve list of all supported currencies (crypto and fiat). Returns an
+    # array with currency name, key, decimals, and network information.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @return [Array[Currency]] Response from the API call.
+    def get_currencies(authorization)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/currencies',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Currency.method(:from_hash))
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/experimental_controller.rb

@@ -0,0 +1,49 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # ExperimentalController
+  class ExperimentalController < BaseController
+    # Accepts a signature for a payment step. Currently echoes the request,
+    # structured for future execution logic.
+    # @param [String] payment_id Required parameter: Payment ID to execute.
+    # @param [String] step_id Required parameter: Transfer step ID to execute.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @param [ExecutePaymentRequestDto] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def execute_payment(payment_id,
+                        step_id,
+                        authorization,
+                        body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{payment_id}/steps/{step_id}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_id, key: 'payment_id')
+                                    .should_encode(true))
+                   .template_param(new_parameter(step_id, key: 'step_id')
+                                    .should_encode(true))
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentResponse.method(:from_hash)))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/health_controller.rb

@@ -0,0 +1,24 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # HealthController
+  class HealthController < BaseController
+    # TODO: type endpoint description here
+    # @return [Response] Response from the API call.
+    def get_health
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Response.method(:from_hash)))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/networks_controller.rb

@@ -0,0 +1,39 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # NetworksController
+  class NetworksController < BaseController
+    # Retrieve list of all supported blockchain networks. Returns an array with
+    # network key and display name.
+    # @param [String] authorization Required parameter: Bearer token for
+    # authentication.   To obtain a token, make a request to Auth0:  ```bash
+    # curl --request POST \   --url
+    # https://dev-awqy75wdabpsnsvu.us.auth0.com/oauth/token \   --header
+    # 'content-type: application/json' \   --data '{
+    # "client_id":"YOUR_CLIENT_ID",     "client_secret":"YOUR_CLIENT_SECRET",
+    #  "audience":"https://sandbox.tesserx.co",
+    # "grant_type":"client_credentials"   }' ```  The response will contain an
+    # `access_token` field which should be used as the Bearer token.
+    # @return [Array[Network]] Response from the API call.
+    def get_networks(authorization)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/networks',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(Network.method(:from_hash))
+                    .is_response_array(true)
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end