tesser-api-sdk 1.0.0

data/lib/tesser_apiv1/controllers/payments_controller.rb

@@ -0,0 +1,202 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # PaymentsController
+  class PaymentsController < BaseController
+    # Retrieve all payments for the authenticated user's organization.
+    # @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 [String] start_date Optional parameter: Filter payments created on
+    # or after this ISO 8601 date.
+    # @param [String] end_date Optional parameter: Filter payments created
+    # before this ISO 8601 date.
+    # @param [PaymentType3Enum] payment_type Optional parameter: Filter payments
+    # by type ('withdrawal', 'deposit', 'onramp', 'offramp', 'payment',
+    # 'transfer').
+    # @param [Float] page Optional parameter: Page number for pagination
+    # (1-based).
+    # @param [Float] limit Optional parameter: Number of items per page.
+    # @return [PaymentListResponse] Response from the API call.
+    def get_payments(authorization,
+                     start_date: nil,
+                     end_date: nil,
+                     payment_type: nil,
+                     page: nil,
+                     limit: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .query_param(new_parameter(start_date, key: 'start_date'))
+                   .query_param(new_parameter(end_date, key: 'end_date'))
+                   .query_param(new_parameter(payment_type, key: 'payment_type'))
+                   .query_param(new_parameter(page, key: 'page'))
+                   .query_param(new_parameter(limit, key: 'limit'))
+                   .header_param(new_parameter('application/json', key: 'accept'))
+                   .auth(Single.new('bearer')))
+        .response(new_response_handler
+                    .deserializer(APIHelper.method(:custom_type_deserializer))
+                    .deserialize_into(PaymentListResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Create a payment. Returns the created payment details.
+    # @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 [CreatePaymentRequest] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def create_payment(authorization,
+                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments',
+                                     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(PaymentResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve a specific payment by ID.
+    # @param [String] payment_id Required parameter: TODO: type description
+    # here
+    # @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 [PaymentResponse] Response from the API call.
+    def get_payment_by_id(payment_id,
+                          authorization)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/payments/{paymentId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_id, key: 'paymentId')
+                                    .should_encode(true))
+                   .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(PaymentResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Update a payment with accounts.
+    # @param [String] payment_id Required parameter: TODO: type description
+    # here
+    # @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 [UpdatePaymentRequest] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def update_payment(payment_id,
+                       authorization,
+                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/payments/{paymentId}',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_id, key: 'paymentId')
+                                    .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))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Manually review and approve or reject a payment requiring risk review.
+    # @param [UUID | String] payment_id Required parameter: Unique identifier of
+    # the payment to review
+    # @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 [ReviewPaymentRequest] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def review_payment(payment_id,
+                       authorization,
+                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/payments/{paymentId}/review',
+                                     Server::DEFAULT)
+                   .template_param(new_parameter(payment_id, key: 'paymentId')
+                                    .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))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/tenants_controller.rb

@@ -0,0 +1,156 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # TenantsController
+  class TenantsController < BaseController
+    # Create a new tenant for your workspace. Tenants are business customers
+    # that integrate via APIs.
+    # @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 [CreateTenantRequest] body Required parameter: TODO: type
+    # description here
+    # @return [CreateTenantResponse] Response from the API call.
+    def create1(authorization,
+                body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/entities/tenants',
+                                     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(CreateTenantResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve all tenants for your workspace with optional search filtering.
+    # @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_secure Optional parameter: Include
+    # secure fields (PII)
+    # @return [TenantListResponse] Response from the API call.
+    def find_all2(authorization,
+                  include_secure: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/entities/tenants',
+                                     Server::DEFAULT)
+                   .header_param(new_parameter(authorization, key: 'Authorization'))
+                   .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(TenantListResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Retrieve a specific tenant by its unique identifier
+    # @param [String] id Required parameter: Tenant 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_secure Optional parameter: Include
+    # secure fields (PII)
+    # @return [TenantResponse] Response from the API call.
+    def find_one1(id,
+                  authorization,
+                  include_secure: nil)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::GET,
+                                     '/entities/tenants/{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_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(TenantResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Update an existing tenant's information.
+    # Only the following fields can be updated:
+    # - business_legal_name
+    # - business_dba
+    # - business_address_country
+    # - webhook_url
+    # At least one field must be provided.
+    # @param [String] id Required parameter: Tenant 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 [UpdateTenantRequest] body Required parameter: TODO: type
+    # description here
+    # @return [UpdateTenantResponse] Response from the API call.
+    def update2(id,
+                authorization,
+                body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::PATCH,
+                                     '/entities/tenants/{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(UpdateTenantResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/controllers/treasury_controller.rb

@@ -0,0 +1,77 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # TreasuryController
+  class TreasuryController < BaseController
+    # Create a deposit payment.
+    # @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 [CreateDepositRequest] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def create_deposit(authorization,
+                       body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/treasury/deposit',
+                                     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(PaymentResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+
+    # Create a withdrawal payment.
+    # @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 [CreateWithdrawalRequest] body Required parameter: TODO: type
+    # description here
+    # @return [PaymentResponse] Response from the API call.
+    def create_withdrawal(authorization,
+                          body)
+      @api_call
+        .request(new_request_builder(HttpMethodEnum::POST,
+                                     '/treasury/withdrawal',
+                                     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(PaymentResponse.method(:from_hash))
+                    .local_error('400',
+                                 'Details coming soon',
+                                 APIException))
+        .execute
+    end
+  end
+end

data/lib/tesser_apiv1/exceptions/api_exception.rb

@@ -0,0 +1,21 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # Class for exceptions when there is a network error, status code error, etc.
+  class APIException < CoreLibrary::ApiException
+    # Provides a human-readable string representation of the object.
+    def to_s
+      class_name = self.class.name.split('::').last
+      "<#{class_name} status_code: #{@response_code}, reason: #{@reason}>"
+    end
+
+    # Provides a debugging-friendly string with detailed object information.
+    def inspect
+      class_name = self.class.name.split('::').last
+      "<#{class_name} status_code: #{@response_code.inspect}, reason: #{@reason.inspect}>"
+    end
+  end
+end

data/lib/tesser_apiv1/http/auth/o_auth2.rb

@@ -0,0 +1,53 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # Utility class for OAuth 2 authorization and token management.
+  class OAuth2 < CoreLibrary::HeaderAuth
+    include CoreLibrary
+    # Display error message on occurrence of authentication failure.
+    # @returns [String] The oAuth error message.
+    def error_message
+      'BearerAuth: access_token is undefined.'
+    end
+
+    # Initialization constructor.
+    def initialize(bearer_auth_credentials)
+      auth_params = {}
+      @_access_token = bearer_auth_credentials.access_token unless
+        bearer_auth_credentials.nil? || bearer_auth_credentials.access_token.nil?
+      auth_params[:Authorization] = "Bearer #{@_access_token}" unless @_access_token.nil?
+
+      super auth_params
+    end
+  end
+
+  # Data class for BearerAuthCredentials.
+  class BearerAuthCredentials
+    attr_reader :access_token
+
+    def initialize(access_token:)
+      raise ArgumentError, 'access_token cannot be nil' if access_token.nil?
+
+      @access_token = access_token
+    end
+
+    def self.from_env
+      access_token = ENV['ACCESS_TOKEN']
+      all_nil = [
+        access_token
+      ].all?(&:nil?)
+      return nil if all_nil
+
+      new(access_token: access_token)
+    end
+
+    def clone_with(access_token: nil)
+      access_token ||= self.access_token
+
+      BearerAuthCredentials.new(access_token: access_token)
+    end
+  end
+end

data/lib/tesser_apiv1/http/http_call_back.rb

@@ -0,0 +1,10 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # HttpCallBack allows defining callables for pre and post API calls.
+  class HttpCallBack < CoreLibrary::HttpCallback
+  end
+end

data/lib/tesser_apiv1/http/http_method_enum.rb

@@ -0,0 +1,10 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # HTTP Methods Enumeration.
+  class HttpMethodEnum < CoreLibrary::HttpMethod
+  end
+end

data/lib/tesser_apiv1/http/http_request.rb

@@ -0,0 +1,10 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # Represents a single Http Request.
+  class HttpRequest < CoreLibrary::HttpRequest
+  end
+end

data/lib/tesser_apiv1/http/http_response.rb

@@ -0,0 +1,10 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  # Http response received.
+  class HttpResponse < CoreLibrary::HttpResponse
+  end
+end

data/lib/tesser_apiv1/http/proxy_settings.rb

@@ -0,0 +1,22 @@
+# tesser_apiv1
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module TesserApiv1
+  ##
+  # ProxySettings encapsulates HTTP proxy configuration for Faraday,
+  # including optional basic authentication.
+  #
+  class ProxySettings < CoreLibrary::ProxySettings
+    def self.from_env
+      address = ENV['PROXY_ADDRESS']
+      port = ENV['PROXY_PORT']
+      username = ENV['PROXY_USERNAME']
+      password = ENV['PROXY_PASSWORD']
+      return nil if address.nil? || address.strip.empty?
+
+      new(address: address, port: port, username: username, password: password)
+    end
+  end
+end