mt-sdk 0.0.1 → 0.0.4

data/lib/modern_treasury/controllers/transaction_controller.rb

@@ -7,6 +7,8 @@ module ModernTreasury
   # TransactionController
   class TransactionController < BaseController
     # Get a list of all transactions.
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [UUID | String] internal_account_id Optional parameter: Specify
@@ -38,10 +40,9 @@ module ModernTreasury
     # you want to query for records with metadata key `Type` and value `Loan`,
     # the query would be `metadata%5BType%5D=Loan`. This encodes the query
     # parameters.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[Transaction]] Response from the API call.
-    def list_transactions(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_transactions(after_cursor: nil,
+                          per_page: nil,
                           internal_account_id: nil,
                           virtual_account_id: nil,
                           posted: nil,
@@ -53,12 +54,12 @@ module ModernTreasury
                           transactable_type: nil,
                           description: nil,
                           vendor_id: nil,
-                          metadata: nil,
-                          after_cursor: nil)
+                          metadata: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/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(internal_account_id, key: 'internal_account_id'))
                    .query_param(new_parameter(virtual_account_id, key: 'virtual_account_id'))
@@ -72,31 +73,33 @@ module ModernTreasury
                    .query_param(new_parameter(description, key: 'description'))
                    .query_param(new_parameter(vendor_id, key: 'vendor_id'))
                    .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(Transaction.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end
 
     # Get details on a single transaction.
     # @param [String] id Required parameter: Transaction ID
-    # @return [Transaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_transaction(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/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(Transaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))
@@ -107,7 +110,7 @@ module ModernTreasury
     # @param [String] id Required parameter: Transaction ID
     # @param [IncomingPaymentDetailUpdateRequest] body Optional parameter: TODO:
     # type description here
-    # @return [Transaction] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_transaction(id,
                            body: nil)
       @api_call
@@ -115,6 +118,7 @@ module ModernTreasury
                                      '/api/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))
@@ -124,6 +128,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(Transaction.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))

data/lib/modern_treasury/controllers/transaction_line_item_controller.rb

@@ -10,10 +10,10 @@ module ModernTreasury
     # @param [String] transaction_id Required parameter: transaction_id
     # @param [String] after_cursor Optional parameter: TODO: type description
     # here
-    # @param [Type16Enum] type Optional parameter: Example:
+    # @param [Type16] type Optional parameter: Example:
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
-    # @return [Array[TransactionLineItem]] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def list_transaction_line_items(transaction_id,
                                     after_cursor: nil,
                                     type: nil,
@@ -23,6 +23,7 @@ module ModernTreasury
                                      '/api/transactions/{transaction_id}/line_items',
                                      Server::DEFAULT)
                    .template_param(new_parameter(transaction_id, key: 'transaction_id')
+                                    .is_required(true)
                                     .should_encode(true))
                    .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(type, key: 'type'))
@@ -32,6 +33,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(TransactionLineItem.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true))
         .execute
     end

data/lib/modern_treasury/controllers/validation_controller.rb

@@ -10,25 +10,28 @@ module ModernTreasury
     # routing detail
     # @param [String] routing_number Required parameter: The routing number that
     # is being validated.
-    # @param [RoutingNumberType8Enum] routing_number_type Required parameter:
-    # One of `aba`, `au_bsb`, `br_codigo`, `ca_cpa`, `cnaps`, `gb_sort_code`,
+    # @param [RoutingNumberType8] routing_number_type Required parameter: One of
+    # `aba`, `au_bsb`, `br_codigo`, `ca_cpa`, `cnaps`, `gb_sort_code`,
     # `in_ifsc`, `my_branch_code`, or `swift`. In sandbox mode we currently only
     # support `aba` and `swift` with routing numbers '123456789' and
     # 'GRINUST0XXX' respectively.
-    # @return [RoutingNumberLookupRequest] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def validate_routing_number(routing_number,
                                 routing_number_type)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/validations/routing_numbers',
                                      Server::DEFAULT)
-                   .query_param(new_parameter(routing_number, key: 'routing_number'))
-                   .query_param(new_parameter(routing_number_type, key: 'routing_number_type'))
+                   .query_param(new_parameter(routing_number, key: 'routing_number')
+                                 .is_required(true))
+                   .query_param(new_parameter(routing_number_type, key: 'routing_number_type')
+                                 .is_required(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(RoutingNumberLookupRequest.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException)

data/lib/modern_treasury/controllers/virtual_account_controller.rb

@@ -7,6 +7,8 @@ module ModernTreasury
   # VirtualAccountController
   class VirtualAccountController < BaseController
     # Get a list of virtual accounts.
+    # @param [String] after_cursor Optional parameter: TODO: type description
+    # here
     # @param [Integer] per_page Optional parameter: TODO: type description
     # here
     # @param [UUID | String] internal_account_id Optional parameter: TODO: type
@@ -17,28 +19,27 @@ module ModernTreasury
     # you want to query for records with metadata key `Type` and value `Loan`,
     # the query would be `metadata%5BType%5D=Loan`. This encodes the query
     # parameters.
-    # @param [String] after_cursor Optional parameter: TODO: type description
-    # here
-    # @return [Array[VirtualAccount]] Response from the API call.
-    def list_virtual_accounts(per_page: nil,
+    # @return [ApiResponse] Complete http response with raw body and status code.
+    def list_virtual_accounts(after_cursor: nil,
+                              per_page: nil,
                               internal_account_id: nil,
                               counterparty_id: nil,
-                              metadata: nil,
-                              after_cursor: nil)
+                              metadata: nil)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/virtual_accounts',
                                      Server::DEFAULT)
+                   .query_param(new_parameter(after_cursor, key: 'after_cursor'))
                    .query_param(new_parameter(per_page, key: 'per_page'))
                    .query_param(new_parameter(internal_account_id, key: 'internal_account_id'))
                    .query_param(new_parameter(counterparty_id, key: 'counterparty_id'))
                    .query_param(new_parameter(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(VirtualAccount.method(:from_hash))
+                    .is_api_response(true)
                     .is_response_array(true)
                     .local_error('401',
                                  'unsuccessful',
@@ -51,7 +52,7 @@ module ModernTreasury
     # something unique, preferably something like an UUID.
     # @param [VirtualAccountCreateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [VirtualAccount] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def create_virtual_account(idempotency_key: nil,
                                body: nil)
       @api_call
@@ -67,6 +68,7 @@ module ModernTreasury
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
                     .deserialize_into(VirtualAccount.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('401',
                                  'unauthorized',
                                  ErrorMessageException)
@@ -78,19 +80,21 @@ module ModernTreasury
 
     # TODO: type endpoint description here
     # @param [String] id Required parameter: Virtual Acccount ID
-    # @return [VirtualAccount] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def get_virtual_account(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::GET,
                                      '/api/virtual_accounts/{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(VirtualAccount.method(:from_hash))
+                    .is_api_response(true)
                     .local_error('404',
                                  'not found',
                                  ErrorMessageException))
@@ -101,7 +105,7 @@ module ModernTreasury
     # @param [String] id Required parameter: Virtual Acccount ID
     # @param [VirtualAccountUpdateRequest] body Optional parameter: TODO: type
     # description here
-    # @return [VirtualAccount] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def update_virtual_account(id,
                                body: nil)
       @api_call
@@ -109,6 +113,7 @@ module ModernTreasury
                                      '/api/virtual_accounts/{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))
@@ -117,25 +122,28 @@ module ModernTreasury
                    .auth(Single.new('basic_auth')))
         .response(new_response_handler
                     .deserializer(APIHelper.method(:custom_type_deserializer))
-                    .deserialize_into(VirtualAccount.method(:from_hash)))
+                    .deserialize_into(VirtualAccount.method(:from_hash))
+                    .is_api_response(true))
         .execute
     end
 
     # TODO: type endpoint description here
     # @param [String] id Required parameter: Virtual Acccount ID
-    # @return [VirtualAccount] Response from the API call.
+    # @return [ApiResponse] Complete http response with raw body and status code.
     def delete_virtual_account(id)
       @api_call
         .request(new_request_builder(HttpMethodEnum::DELETE,
                                      '/api/virtual_accounts/{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(VirtualAccount.method(:from_hash)))
+                    .deserialize_into(VirtualAccount.method(:from_hash))
+                    .is_api_response(true))
         .execute
     end
   end

data/lib/modern_treasury/http/api_response.rb

@@ -0,0 +1,19 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # Http response received.
+  class ApiResponse < CoreLibrary::ApiResponse
+    # The constructor
+    # @param [HttpResponse] http_response The original, raw response from the api.
+    # @param [Object] data The data field specified for the response.
+    # @param [Array<String>] errors Any errors returned by the server.
+    def initialize(http_response,
+                   data: nil,
+                   errors: nil)
+      super
+    end
+  end
+end

data/lib/modern_treasury/logging/configuration/api_logging_configuration.rb

@@ -0,0 +1,186 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # Initializes a new instance of RequestLoggingConfiguration.
+  class RequestLoggingConfiguration < CoreLibrary::ApiRequestLoggingConfiguration
+    # @param log_body [Boolean] Indicates whether the message body should be logged. Default is false.
+    # @param log_headers [Boolean] Indicates whether the message headers should be logged. Default is false.
+    # @param headers_to_exclude [Array<String>] Array of headers not displayed in logging. Default is an empty array.
+    # @param headers_to_include [Array<String>] Array of headers to be displayed in logging. Default is an empty array.
+    # @param headers_to_unmask [Array<String>] Array of headers which values are non-sensitive to display in logging.
+    #   Default is an empty array.
+    def initialize(log_body: false, log_headers: false, headers_to_include: nil,
+                   headers_to_exclude: nil, headers_to_unmask: nil,
+                   include_query_in_path: false)
+      super(
+        log_body,
+        log_headers,
+        headers_to_exclude,
+        headers_to_include,
+        headers_to_unmask,
+        include_query_in_path
+      )
+    end
+
+    def clone_with(log_body: nil, log_headers: nil, headers_to_include: nil,
+                   headers_to_exclude: nil, headers_to_unmask: nil, include_query_in_path: nil)
+      log_body ||= self.log_body
+      log_headers ||= self.log_headers
+      headers_to_include ||= self.headers_to_include
+      headers_to_exclude ||= self.headers_to_exclude
+      headers_to_unmask ||= self.headers_to_unmask
+      include_query_in_path ||= self.include_query_in_path
+
+      RequestLoggingConfiguration.new(
+        log_body: log_body,
+        log_headers: log_headers,
+        headers_to_include: headers_to_include,
+        headers_to_exclude: headers_to_exclude,
+        headers_to_unmask: headers_to_unmask,
+        include_query_in_path: include_query_in_path
+      )
+    end
+
+    def self.from_env
+      log_body = ENV['REQUEST_LOG_BODY']
+      log_headers = ENV['REQUEST_LOG_HEADERS']
+      headers_to_include = ENV['REQUEST_HEADERS_TO_INCLUDE']
+      headers_to_exclude = ENV['REQUEST_HEADERS_TO_EXCLUDE']
+      headers_to_unmask = ENV['REQUEST_HEADERS_TO_UNMASK']
+      include_query_in_path = ENV['REQUEST_INCLUDE_QUERY_IN_PATH']
+
+      new(
+        log_body: log_body,
+        log_headers: log_headers,
+        headers_to_include: headers_to_include,
+        headers_to_exclude: headers_to_exclude,
+        headers_to_unmask: headers_to_unmask,
+        include_query_in_path: include_query_in_path
+      )
+    end
+
+    def self.any_logging_configured?
+      %w[
+        REQUEST_LOG_BODY
+        REQUEST_LOG_HEADERS
+        REQUEST_HEADERS_TO_INCLUDE
+        REQUEST_HEADERS_TO_EXCLUDE
+        REQUEST_HEADERS_TO_UNMASK
+        REQUEST_INCLUDE_QUERY_IN_PATH
+      ].any? { |key| ENV.key?(key) && !ENV[key].nil? && !ENV[key].empty? }
+    end
+  end
+
+  # Initializes a new instance of ResponseLoggingConfiguration.
+  class ResponseLoggingConfiguration < CoreLibrary::ApiResponseLoggingConfiguration
+    def initialize(log_body: false, log_headers: false, headers_to_include: nil,
+                   headers_to_exclude: nil, headers_to_unmask: nil)
+      super(
+        log_body,
+        log_headers,
+        headers_to_exclude,
+        headers_to_include,
+        headers_to_unmask
+      )
+    end
+
+    def clone_with(log_body: nil, log_headers: nil, headers_to_include: nil,
+                   headers_to_exclude: nil, headers_to_unmask: nil)
+      log_body ||= self.log_body
+      log_headers ||= self.log_headers
+      headers_to_include ||= self.headers_to_include
+      headers_to_exclude ||= self.headers_to_exclude
+      headers_to_unmask ||= self.headers_to_unmask
+
+      ResponseLoggingConfiguration.new(
+        log_body: log_body,
+        log_headers: log_headers,
+        headers_to_include: headers_to_include,
+        headers_to_exclude: headers_to_exclude,
+        headers_to_unmask: headers_to_unmask
+      )
+    end
+
+    def self.from_env
+      log_body = ENV['RESPONSE_LOG_BODY']
+      log_headers = ENV['RESPONSE_LOG_HEADERS']
+      headers_to_include = ENV['RESPONSE_HEADERS_TO_INCLUDE']
+      headers_to_exclude = ENV['RESPONSE_HEADERS_TO_EXCLUDE']
+      headers_to_unmask = ENV['RESPONSE_HEADERS_TO_UNMASK']
+
+      new(
+        log_body: log_body,
+        log_headers: log_headers,
+        headers_to_include: headers_to_include,
+        headers_to_exclude: headers_to_exclude,
+        headers_to_unmask: headers_to_unmask
+      )
+    end
+
+    def self.any_logging_configured?
+      %w[
+        RESPONSE_LOG_BODY
+        RESPONSE_LOG_HEADERS
+        RESPONSE_HEADERS_TO_INCLUDE
+        RESPONSE_HEADERS_TO_EXCLUDE
+        RESPONSE_HEADERS_TO_UNMASK
+      ].any? { |key| ENV.key?(key) && !ENV[key].nil? && !ENV[key].empty? }
+    end
+  end
+
+  # Initializes a new instance of LoggingConfiguration.
+  class LoggingConfiguration < CoreLibrary::ApiLoggingConfiguration
+    def initialize(logger: nil, log_level: nil, mask_sensitive_headers: true,
+                   request_logging_config: nil,
+                   response_logging_config: nil)
+      request_logging_config ||= RequestLoggingConfiguration.new
+      response_logging_config ||= ResponseLoggingConfiguration.new
+      super(
+        logger,
+        log_level,
+        request_logging_config,
+        response_logging_config,
+        mask_sensitive_headers
+      )
+    end
+
+    def clone_with(logger: nil, log_level: nil, mask_sensitive_headers: nil,
+                   request_logging_config: nil, response_logging_config: nil)
+      logger ||= self.logger
+      log_level ||= self.log_level
+      mask_sensitive_headers ||= self.mask_sensitive_headers
+      request_logging_config ||= self.request_logging_config.clone
+      response_logging_config ||= self.response_logging_config.clone
+
+      LoggingConfiguration.new(
+        logger: logger,
+        log_level: log_level,
+        mask_sensitive_headers: mask_sensitive_headers,
+        request_logging_config: request_logging_config,
+        response_logging_config: response_logging_config
+      )
+    end
+
+    def self.from_env
+      log_level = ENV['LOG_LEVEL']
+      mask_sensitive_headers = ENV['MASK_SENSITIVE_HEADERS']
+
+      new(
+        log_level: log_level,
+        mask_sensitive_headers: mask_sensitive_headers,
+        request_logging_config: RequestLoggingConfiguration.from_env,
+        response_logging_config: ResponseLoggingConfiguration.from_env
+      )
+    end
+
+    def self.any_logging_configured?
+      RequestLoggingConfiguration.any_logging_configured? ||
+        ResponseLoggingConfiguration.any_logging_configured? ||
+        ENV.key?('LOG_LEVEL') ||
+        ENV.key?('MASK_SENSITIVE_HEADERS')
+    end
+  end
+end

data/lib/modern_treasury/logging/sdk_logger.rb

@@ -0,0 +1,17 @@
+# modern_treasury
+#
+# This file was automatically generated by APIMATIC v3.0 (
+# https://www.apimatic.io ).
+
+module ModernTreasury
+  # Represents the generic logger facade
+  class AbstractLogger < Logger
+    # Logs a message with a specified log level and additional parameters.
+    # @param level [Symbol] The log level of the message.
+    # @param message [String] The message to log.
+    # @param params [Hash] Additional parameters to include in the log message.
+    def log(level, message, params)
+      raise NotImplementedError, 'This method needs to be implemented in a child class.'
+    end
+  end
+end

data/lib/modern_treasury/models/account.rb

@@ -39,11 +39,11 @@ module ModernTreasury
     attr_accessor :discarded_at
 
     # Can be `checking`, `savings` or `other`.
-    # @return [AccountTypeEnum]
+    # @return [AccountType]
     attr_accessor :account_type
 
     # Either `individual` or `business`.
-    # @return [PartyTypeEnum]
+    # @return [PartyType]
     attr_accessor :party_type
 
     # Either `individual` or `business`.
@@ -85,7 +85,7 @@ module ModernTreasury
 
     # If the external account links to a ledger account in Modern Treasury, the
     # id of the ledger account will be populated here.
-    # @return [VerificationStatusEnum]
+    # @return [VerificationStatus]
     attr_accessor :verification_status
 
     # A mapping from model property names to API property names.
@@ -145,12 +145,12 @@ module ModernTreasury
       ]
     end
 
-    def initialize(id = SKIP, object = SKIP, live_mode = SKIP,
-                   created_at = SKIP, updated_at = SKIP, discarded_at = SKIP,
-                   account_type = SKIP, party_type = SKIP, party_address = SKIP,
-                   name = SKIP, account_details = SKIP, routing_details = SKIP,
-                   metadata = SKIP, party_name = SKIP, contact_details = SKIP,
-                   ledger_account_id = SKIP, verification_status = SKIP)
+    def initialize(id: SKIP, object: SKIP, live_mode: SKIP, created_at: SKIP,
+                   updated_at: SKIP, discarded_at: SKIP, account_type: SKIP,
+                   party_type: SKIP, party_address: SKIP, name: SKIP,
+                   account_details: SKIP, routing_details: SKIP, metadata: SKIP,
+                   party_name: SKIP, contact_details: SKIP,
+                   ledger_account_id: SKIP, verification_status: SKIP)
       @id = id unless id == SKIP
       @object = object unless object == SKIP
       @live_mode = live_mode unless live_mode == SKIP
@@ -235,23 +235,23 @@ module ModernTreasury
         hash.key?('verification_status') ? hash['verification_status'] : SKIP
 
       # Create object from extracted values.
-      Account.new(id,
-                  object,
-                  live_mode,
-                  created_at,
-                  updated_at,
-                  discarded_at,
-                  account_type,
-                  party_type,
-                  party_address,
-                  name,
-                  account_details,
-                  routing_details,
-                  metadata,
-                  party_name,
-                  contact_details,
-                  ledger_account_id,
-                  verification_status)
+      Account.new(id: id,
+                  object: object,
+                  live_mode: live_mode,
+                  created_at: created_at,
+                  updated_at: updated_at,
+                  discarded_at: discarded_at,
+                  account_type: account_type,
+                  party_type: party_type,
+                  party_address: party_address,
+                  name: name,
+                  account_details: account_details,
+                  routing_details: routing_details,
+                  metadata: metadata,
+                  party_name: party_name,
+                  contact_details: contact_details,
+                  ledger_account_id: ledger_account_id,
+                  verification_status: verification_status)
     end
 
     def to_custom_created_at