moov_ruby 26.10.0.pre.dev.2 → 26.10.0.pre.dev.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44c439b4d94110a417a35569d2db7dda5ddfcc65b61a90bc51b8388bec65828e
-  data.tar.gz: 8094b4f6307634a62a92e7d70cb1679d55cab787267f63fd09375bbef3715e32
+  metadata.gz: 7169f4edf56d294239aa603754fc8254ca57c24e14ced2aba905e2edd417b2b5
+  data.tar.gz: 4339c9ab9a0a9fd41510fc17e3db0e5303429f885516eea1760f82befd4af1e0
 SHA512:
-  metadata.gz: bdefb94aa627a0b0354a7e6540af95f8052d3ce15c5e973359373caaca569d4c5f15b671b62e39672aee2635c0025b19fbab98523090d1edeb39f222a3366d4b
-  data.tar.gz: 9f9bedb65f9eefebbe49e6c201946af482bd088de14d8f525cc65c0c659a7bb9a806e642ccade5f39a4a191c1ef565cd758445db1f5bdb38771d29ac8ce107b2
+  metadata.gz: 98a2685dfe4ad6c1e7ccec33e61c30020674bd758f8ee0261129060332ad4df7b6336d48a10a29fd1be4833d81c2123b2b2e27262896cdbfa05b98a3c5862f24
+  data.tar.gz: 88a7387b7da6e4e518cc1596be39fd443a33e651639c9c0f646222988802b7f468d968fa70c222329b30d53e4a01ba41474e1ed0c3ed6ab7f0e3fa5709427004

data/lib/crystalline/module.rb

@@ -4,7 +4,7 @@
 # frozen_string_literal: true
 
 module Crystalline
-  @union_strategy = :left_to_right
+  @union_strategy = :populated_fields
 
   class << self
     attr_accessor :union_strategy

data/lib/moov/bank_accounts.rb

@@ -590,6 +590,445 @@ module Moov
     end
 
 
+    sig { params(create_bank_account_attestation: Models::Components::CreateBankAccountAttestation, account_id: ::String, bank_account_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::CreateBankAccountAttestationResponse) }
+    def create_attestation(create_bank_account_attestation:, account_id:, bank_account_id:, timeout_ms: nil, http_headers: nil)
+      # create_attestation -   Submit a new authorization attestation for a bank account in an `errored` status due to an R29 ACH return (`Corporate Customer Advises Not Authorized`).
+      #
+      #   After obtaining new authorization from the receiver, submit an attestation with the date the authorization was obtained and a brief description of how the authorization was obtained. If the attestation is accepted, the bank account transitions from `errored` to `verified`.
+      #
+      #   Constraints
+      #
+      #   - The bank account's current errored status must be the result of an R29 return.
+      #   - `attestedAt` must be on or after the date of the bank account's most recent R29 return and cannot be a future date.
+      #   - Only one attestation may be submitted for a bank account. Use the [Get attestation eligibility](https://docs.moov.io/api/sources/bank-accounts/attestation-eligibility/) endpoint to confirm eligibility before submitting an attestation.
+      #
+      #   This endpoint is available only to allowlisted partners. Contact Moov Support for more information.
+      request = Models::Operations::CreateBankAccountAttestationRequest.new(
+        account_id: account_id,
+        bank_account_id: bank_account_id,
+        create_bank_account_attestation: create_bank_account_attestation
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::CreateBankAccountAttestationRequest,
+        base_url,
+        '/accounts/{accountID}/bank-accounts/{bankAccountID}/attestations',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :create_bank_account_attestation, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form && !form.empty?
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'createBankAccountAttestation',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::BankAccountAttestation)
+          response = Models::Operations::CreateBankAccountAttestationResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: http_response.headers,
+            bank_account_attestation: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400', '409'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::GenericError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['422'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BankAccountAttestationValidationError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401', '403', '404', '429'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['500', '504'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(account_id: ::String, bank_account_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListBankAccountAttestationsResponse) }
+    def list_attestations(account_id:, bank_account_id:, timeout_ms: nil, http_headers: nil)
+      # list_attestations - List the attestations submitted for a bank account.
+      request = Models::Operations::ListBankAccountAttestationsRequest.new(
+        account_id: account_id,
+        bank_account_id: bank_account_id
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::ListBankAccountAttestationsRequest,
+        base_url,
+        '/accounts/{accountID}/bank-accounts/{bankAccountID}/attestations',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'listBankAccountAttestations',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+
+      begin
+        http_response = T.must(connection).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Crystalline::Array.new(Models::Components::BankAccountAttestationSummary))
+          response = Models::Operations::ListBankAccountAttestationsResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: http_response.headers,
+            bank_account_attestation_summaries: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401', '403', '404', '429'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['500', '504'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(account_id: ::String, bank_account_id: ::String, attested_at: T.nilable(::Date), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::GetBankAccountAttestationEligibilityResponse) }
+    def get_attestation_eligibility(account_id:, bank_account_id:, attested_at: nil, timeout_ms: nil, http_headers: nil)
+      # get_attestation_eligibility - Check whether a bank account is currently eligible for a new authorization attestation without submitting one.
+      #
+      # - `enabled` indicates whether the calling account has access to the attestations feature. If `enabled` is `false`, `eligible` is always `false`.
+      # - When `enabled` is `true`, `eligible` indicates whether the bank account currently meets the eligibility requirements for a new attestation: the bank account must be `errored` due to an R29 return, with no prior attestations.
+      #
+      # This endpoint always returns `200`, including when the bank account is not eligible. Check the `eligible` field to determine eligibility.
+      #
+      # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/)
+      # you'll need to specify the `/accounts/{accountID}/bank-accounts.read` scope.
+      request = Models::Operations::GetBankAccountAttestationEligibilityRequest.new(
+        account_id: account_id,
+        bank_account_id: bank_account_id,
+        attested_at: attested_at
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::GetBankAccountAttestationEligibilityRequest,
+        base_url,
+        '/accounts/{accountID}/bank-accounts/{bankAccountID}/attestations-eligibility',
+        request
+      )
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::GetBankAccountAttestationEligibilityRequest, request, nil)
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'getBankAccountAttestationEligibility',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+
+      begin
+        http_response = T.must(connection).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          req.params = query_params
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::BankAccountAttestationEligibility)
+          response = Models::Operations::GetBankAccountAttestationEligibilityResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: http_response.headers,
+            bank_account_attestation_eligibility: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::GenericError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401', '403', '404'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['500', '504'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
     sig { params(account_id: ::String, bank_account_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::InitiateMicroDepositsResponse) }
     def initiate_micro_deposits(account_id:, bank_account_id:, timeout_ms: nil, http_headers: nil)
       # initiate_micro_deposits - Micro-deposits help confirm bank account ownership, helping reduce fraud and the risk of unauthorized activity. 

data/lib/moov/card_issuing.rb

@@ -745,7 +745,7 @@ module Moov
       # Only use this endpoint if you have provided Moov with a copy of your PCI attestation of compliance.
       #
       # To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-      # you'll need to specify the `/accounts/{accountID}/issued-cards.read-secure` scope.
+      # you'll need to specify the `/accounts/{accountID}/issued-cards.read-private` scope.
       request = Models::Operations::GetFullIssuedCardRequest.new(
         account_id: account_id,
         issued_card_id: issued_card_id

data/lib/moov/images.rb

@@ -167,7 +167,7 @@ module Moov
     sig { params(image_upload_request_multi_part: Models::Components::ImageUploadRequestMultiPart, account_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::UploadImageResponse) }
     def upload(image_upload_request_multi_part:, account_id:, timeout_ms: nil, http_headers: nil)
       # upload -   Upload a new PNG, JPEG, or WebP image with optional metadata. 
-      #   Duplicate images, and requests larger than 16MB will be rejected.
+      #   Duplicate images return the existing image's metadata with a 409 status. Requests larger than 16MB will be rejected.
       request = Models::Operations::UploadImageRequest.new(
         account_id: account_id,
         image_upload_request_multi_part: image_upload_request_multi_part
@@ -282,7 +282,7 @@ module Moov
         else
           raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
-      elsif Utils.match_status_code(http_response.status, ['400', '409'])
+      elsif Utils.match_status_code(http_response.status, ['400'])
         if Utils.match_content_type(content_type, 'application/json')
           http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
@@ -297,6 +297,21 @@ module Moov
         else
           raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
+      elsif Utils.match_status_code(http_response.status, ['409'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ImageMetadataError)
+          obj.raw_response = http_response
+          raise obj
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
       elsif Utils.match_status_code(http_response.status, ['422'])
         if Utils.match_content_type(content_type, 'application/json')
           http_response = @sdk_configuration.hooks.after_success(

data/lib/moov/institutions.rb

@@ -168,7 +168,7 @@ module Moov
 
     sig { params(name: T.nilable(::String), routing_number: T.nilable(::String), state: T.nilable(::String), limit: T.nilable(::Integer), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListInstitutionsResponse) }
     def search(name: nil, routing_number: nil, state: nil, limit: nil, timeout_ms: nil, http_headers: nil)
-      # search - This endpoint has been deprecated and will be removed in a future release. Use [/institutions](https://docs.moov.io/api/enrichment/form-shortening/institutions/get/).
+      # search - This endpoint has been deprecated and will be removed in a future release. Use [/institutions](https://docs.moov.io/api/enrichment/institutions/get/).
       #
       # Search for institutions by either their name or routing number.
       #

data/lib/moov/models/components/account.rb

@@ -15,9 +15,9 @@ module Moov
         # Unique identifier for this account.
         field :account_id, ::String, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('accountID'), required: true } }
         # The operating mode for an account.
-        field :mode, Models::Components::Mode, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('mode'), required: true, 'decoder': ::Moov::Utils.enum_from_string(Models::Components::Mode, false) } }
+        field :mode, Models::Components::Mode, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('mode'), required: true, 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::Mode, false) } }
         # The type of entity represented by this account.
-        field :account_type, Models::Components::AccountType, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('accountType'), required: true, 'decoder': ::Moov::Utils.enum_from_string(Models::Components::AccountType, false) } }
+        field :account_type, Models::Components::AccountType, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('accountType'), required: true, 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::AccountType, false) } }
 
         field :display_name, ::String, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('displayName'), required: true } }
         # Describes a Moov account profile. A profile will have a business, individual, or guest depending on the account's type.

data/lib/moov/models/components/accountnameverification.rb

@@ -13,13 +13,13 @@ module Moov
         include Crystalline::MetadataFields
 
         # Verification result of the cardholder's first name.
-        field :first_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('firstName'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::CardVerificationResult, true) } }
+        field :first_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('firstName'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::CardVerificationResult, true) } }
         # Verification result of the cardholder's last name.
-        field :last_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('lastName'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::CardVerificationResult, true) } }
+        field :last_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('lastName'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::CardVerificationResult, true) } }
         # Verification result of the cardholder's middle name.
-        field :middle_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('middleName'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::CardVerificationResult, true) } }
+        field :middle_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('middleName'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::CardVerificationResult, true) } }
         # Verification result of the cardholder's full name.
-        field :full_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('fullName'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::CardVerificationResult, true) } }
+        field :full_name, Crystalline::Nilable.new(Models::Components::CardVerificationResult), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('fullName'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::CardVerificationResult, true) } }
 
         sig { params(first_name: T.nilable(Models::Components::CardVerificationResult), last_name: T.nilable(Models::Components::CardVerificationResult), middle_name: T.nilable(Models::Components::CardVerificationResult), full_name: T.nilable(Models::Components::CardVerificationResult)).void }
         def initialize(first_name: nil, last_name: nil, middle_name: nil, full_name: nil)

data/lib/moov/models/components/accounttype.rb

@@ -8,12 +8,14 @@ module Moov
   module Models
     module Components
       # AccountType - The type of entity represented by this account.
-      class AccountType < T::Enum
+      class AccountType
+        include ::Crystalline::Enum
         enums do
           INDIVIDUAL = new('individual')
           BUSINESS = new('business')
           GUEST = new('guest')
         end
+        open!
       end
     end
   end

data/lib/moov/models/components/accountverificationstatus.rb

@@ -10,7 +10,8 @@ module Moov
       # AccountVerificationStatus - Possible states an account verification can be in.
       #
       # @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
-      class AccountVerificationStatus < T::Enum
+      class AccountVerificationStatus
+        include ::Crystalline::Enum
         enums do
           UNVERIFIED = new('unverified')
           PENDING = new('pending')
@@ -19,6 +20,7 @@ module Moov
           VERIFIED = new('verified')
           FAILED = new('failed')
         end
+        open!
       end
     end
   end

data/lib/moov/models/components/achcredittransferprocessingdetails.rb

@@ -12,6 +12,8 @@ module Moov
         extend T::Sig
         include Crystalline::MetadataFields
 
+        # Status of a transaction within the ACH lifecycle.
+        field :status, Models::Components::ACHTransactionStatus, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('status'), required: true, 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::ACHTransactionStatus, false) } }
 
         field :trace_number, ::String, { 'format_json': { 'letter_case': ::Moov::Utils.field_name('traceNumber'), required: true } }
 
@@ -19,8 +21,9 @@ module Moov
 
         field :correction, Crystalline::Nilable.new(Models::Components::ACHException), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('correction') } }
 
-        sig { params(trace_number: ::String, return_: T.nilable(Models::Components::ACHException), correction: T.nilable(Models::Components::ACHException)).void }
-        def initialize(trace_number:, return_: nil, correction: nil)
+        sig { params(status: Models::Components::ACHTransactionStatus, trace_number: ::String, return_: T.nilable(Models::Components::ACHException), correction: T.nilable(Models::Components::ACHException)).void }
+        def initialize(status:, trace_number:, return_: nil, correction: nil)
+          @status = status
           @trace_number = trace_number
           @return_ = return_
           @correction = correction
@@ -29,6 +32,7 @@ module Moov
         sig { params(other: T.untyped).returns(T::Boolean) }
         def ==(other)
           return false unless other.is_a? self.class
+          return false unless @status == other.status
           return false unless @trace_number == other.trace_number
           return false unless @return_ == other.return_
           return false unless @correction == other.correction

data/lib/moov/models/components/achcredittransferprocessingdetails.rbi

@@ -8,6 +8,8 @@ end
 
 
 class Moov::Models::Components::ACHCreditTransferProcessingDetails
+  def status(); end
+  def status=(str_); end
   def trace_number(); end
   def trace_number=(str_); end
   def return_(); end

data/lib/moov/models/components/achdebitoptions.rb

@@ -17,9 +17,9 @@ module Moov
         # An optional override of the default NACHA company name for a transfer.
         field :originating_company_name, Crystalline::Nilable.new(::String), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('originatingCompanyName') } }
         # Code used to identify the ACH authorization method.
-        field :sec_code, Crystalline::Nilable.new(Models::Components::SECCode), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('secCode'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::SECCode, true) } }
+        field :sec_code, Crystalline::Nilable.new(Models::Components::SECCode), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('secCode'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::SECCode, true) } }
         # An optional override of your default ACH hold period in banking days. The hold period must be longer than or equal to your default setting.
-        field :debit_hold_period, Crystalline::Nilable.new(Models::Components::DebitHoldPeriod), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('debitHoldPeriod'), 'decoder': ::Moov::Utils.enum_from_string(Models::Components::DebitHoldPeriod, true) } }
+        field :debit_hold_period, Crystalline::Nilable.new(Models::Components::DebitHoldPeriod), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('debitHoldPeriod'), 'decoder': ::Moov::Utils.open_enum_from_string(Models::Components::DebitHoldPeriod, true) } }
 
         field :addenda, Crystalline::Nilable.new(Crystalline::Array.new(Models::Components::TransferACHAddendaRecord)), { 'format_json': { 'letter_case': ::Moov::Utils.field_name('addenda') } }