modern_treasury 0.1.0.pre.alpha.21 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6545344e52ee8011782e1a9a5f3cec4a92310c31816c73f155d6f3ff7cc207a
-  data.tar.gz: d5d6a14ca7c9820c7dc53475f228581cd7369a3d74f0e892e51f676e13018d14
+  metadata.gz: 581026f5fdefb4ecafbb971dc320b00c833ee17b7e6467437e46e964ec67134d
+  data.tar.gz: 4eab42899864540e6ca98a5c5687c3c330da0d45e34bfe463f072aa6035e972e
 SHA512:
-  metadata.gz: 835ae7e37e8b518b6262bf89029df5df1b13f42b58b531c8fc01efb8ba89b96df092b8e1b05f6a9e752e8e65bab135676359aae6b16c5aa3f0adb82fe46b6ec3
-  data.tar.gz: cb3e668b989d2f719d23ee95833f4d4cb604b51257e6e5daf9715e81f06de08cce77f789ff1d73a73edf13efdde7685d451d9b0dab9c25baf67ca6b02e8987d4
+  metadata.gz: fb4beec913eefc5ee728d8a5cddbc0edd53cc35d928cd4b386cf65a0d3571eff2341d8b6087503c148d45ef3d6ed6b472ecd4fdd8dca3ae04730621496940139
+  data.tar.gz: 61dc97956b212b16371044a170acde7ec5433e83fff2d2952ca8a339e27952bce8685853059dfbffc1b64ce7e00a20bf4f25ada55e40efc12f45e4bdc2c5e7f8

data/CHANGELOG.md

@@ -1,5 +1,70 @@
 # Changelog
 
+## 0.1.0 (2025-08-02)
+
+Full Changelog: [v0.1.0-alpha.22...v0.1.0](https://github.com/Modern-Treasury/modern-treasury-ruby/compare/v0.1.0-alpha.22...v0.1.0)
+
+### Features
+
+* **api:** api update ([bc8de9c](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/bc8de9c156d8b75282e5ba888d497deff4b25948))
+* **api:** api update ([95b4873](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/95b48736c2249d8ccc4fe706b3fa526b2f468dc2))
+* **api:** api update ([a62983f](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/a62983f37beadf31634a2a9a9b05837b6b095f63))
+* **api:** api update ([b70a332](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/b70a332777ce561b2fe2f93954aae68cb17b5cf2))
+* **api:** api update ([21fda11](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/21fda11f539d2ea327078312237e2a444b958bfe))
+* **api:** api update ([7d169fa](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/7d169fa6917ce333c76f12628fdd7756aed457ce))
+* **api:** api update ([52d87f6](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/52d87f65e23cc16e10e52fde4ccc81e16a5555ed))
+* **api:** api update ([d466528](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/d46652814f67800f534a702724f406845fd1d416))
+* **api:** api update ([e909ebb](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/e909ebb243d92bc2bd4d23253286e2bdde19eac7))
+* **api:** api update ([f258c75](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/f258c75ae2ae55f46b3318a6d668b670b68eabd2))
+* **api:** api update ([0e4f36d](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/0e4f36dfe47b52ae6eb0738028f4461ef7549051))
+* **api:** manual updates ([12a73dd](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/12a73dd911d167d15d43eb33804f4cda8f3cdd97))
+* **api:** manual updates ([fd4e901](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/fd4e9014ddc3073041f9e5d9b57414f38100f741))
+* **api:** manual updates ([8f250b4](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/8f250b4874e7be94b4823d695bb2a1a93df4afed))
+* **api:** manual updates ([d172b95](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/d172b955661a9a12bc3b59479d8a24a05961c992))
+* **api:** manual updates ([27b506d](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/27b506d96912a07b4753d1686556bf45cc96f269))
+* **api:** manual updates ([b28aa54](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/b28aa54fb130b017a9047236cbfdf4350cb7c72b))
+* **api:** manual updates ([7cfaf73](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/7cfaf730ca33e1405eda1a7472f2e0fa76c7e126))
+
+
+### Bug Fixes
+
+* **api:** make Legal Entity change backwards compatibile ([d4be112](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/d4be112f8ca0f26e72f47cf12738a336b2d591c2))
+* **client:** unique model names ([b35f861](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/b35f86118ac5ca888f11ac7a03c3fc46eeb96540))
+* **internal:** ensure sorbet test always runs serially ([245ad18](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/245ad18fda1d808d934cd93019f1463c9e22132d))
+
+
+### Chores
+
+* **internal:** increase visibility of internal helper method ([5ab5275](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/5ab5275f39dd4309e6fa034071004c2370ea4d4d))
+* update contribute.md ([503a762](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/503a762153cde391cc8b30c87255517e313e7524))
+
+## 0.1.0-alpha.22 (2025-07-07)
+
+Full Changelog: [v0.1.0-alpha.21...v0.1.0-alpha.22](https://github.com/Modern-Treasury/modern-treasury-ruby/compare/v0.1.0-alpha.21...v0.1.0-alpha.22)
+
+### Features
+
+* **api:** api update ([f9b7650](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/f9b765072627604455f57237b76a32e07a03e30a))
+* **api:** api update ([9a357cc](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/9a357cc723fd191f542d6975b4f84cb5acc555e1))
+* **api:** api update ([0ea5708](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/0ea5708a1c1057643b10481fe3f28599c238b387))
+* **api:** api update ([a9e4c9b](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/a9e4c9b8984b08a8887e3897f44e45b32222af0e))
+* **api:** api update ([7e4655b](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/7e4655b211def4398f04e5f190c264eb82b92487))
+* **api:** api update ([b387235](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/b387235b089476f0ed63ac717eb2308f1fbbb6f8))
+
+
+### Bug Fixes
+
+* **ci:** release-doctor — report correct token name ([e04ac73](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/e04ac73389f3bcec56f7403dea71e818a03022cf))
+* issue where we cannot mutate arrays on base model derivatives ([e387253](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/e387253acf1d48294e42fee99ce023668308aedf))
+
+
+### Chores
+
+* **ci:** enable for pull requests ([00b3946](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/00b394631003a1c1e8f961e838b25bb1b5391805))
+* **ci:** link to correct github repo ([c7048da](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/c7048dad5371a6b9e7c5467bd0aefa0df97df3b4))
+* **ci:** only run for pushes and fork pull requests ([1d387c6](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/1d387c65cbf539ef9b5a188a2201c1af732b60e7))
+* **internal:** allow streams to also be unwrapped on a per-row basis ([658a566](https://github.com/Modern-Treasury/modern-treasury-ruby/commit/658a566873f97d28b0734af37806a4e0a16e3740))
+
 ## 0.1.0-alpha.21 (2025-06-04)
 
 Full Changelog: [v0.1.0-alpha.20...v0.1.0-alpha.21](https://github.com/Modern-Treasury/modern-treasury-ruby/compare/v0.1.0-alpha.20...v0.1.0-alpha.21)

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "modern_treasury", "~> 0.1.0.pre.alpha.21"
+gem "modern_treasury", "~> 0.1.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/modern_treasury/client.rb

@@ -60,9 +60,6 @@ module ModernTreasury
     # @return [ModernTreasury::Resources::Ledgers]
     attr_reader :ledgers
 
-    # @return [ModernTreasury::Resources::LedgerableEvents]
-    attr_reader :ledgerable_events
-
     # @return [ModernTreasury::Resources::LedgerAccountCategories]
     attr_reader :ledger_account_categories
 
@@ -78,9 +75,6 @@ module ModernTreasury
     # @return [ModernTreasury::Resources::LedgerEntries]
     attr_reader :ledger_entries
 
-    # @return [ModernTreasury::Resources::LedgerEventHandlers]
-    attr_reader :ledger_event_handlers
-
     # @return [ModernTreasury::Resources::LedgerTransactions]
     attr_reader :ledger_transactions
 
@@ -105,9 +99,6 @@ module ModernTreasury
     # @return [ModernTreasury::Resources::Validations]
     attr_reader :validations
 
-    # @return [ModernTreasury::Resources::PaperItems]
-    attr_reader :paper_items
-
     # @return [ModernTreasury::Resources::VirtualAccounts]
     attr_reader :virtual_accounts
 
@@ -226,14 +217,12 @@ module ModernTreasury
       @routing_details = ModernTreasury::Resources::RoutingDetails.new(client: self)
       @internal_accounts = ModernTreasury::Resources::InternalAccounts.new(client: self)
       @ledgers = ModernTreasury::Resources::Ledgers.new(client: self)
-      @ledgerable_events = ModernTreasury::Resources::LedgerableEvents.new(client: self)
       @ledger_account_categories = ModernTreasury::Resources::LedgerAccountCategories.new(client: self)
       @ledger_accounts = ModernTreasury::Resources::LedgerAccounts.new(client: self)
       @ledger_account_balance_monitors =
         ModernTreasury::Resources::LedgerAccountBalanceMonitors.new(client: self)
       @ledger_account_statements = ModernTreasury::Resources::LedgerAccountStatements.new(client: self)
       @ledger_entries = ModernTreasury::Resources::LedgerEntries.new(client: self)
-      @ledger_event_handlers = ModernTreasury::Resources::LedgerEventHandlers.new(client: self)
       @ledger_transactions = ModernTreasury::Resources::LedgerTransactions.new(client: self)
       @line_items = ModernTreasury::Resources::LineItems.new(client: self)
       @payment_flows = ModernTreasury::Resources::PaymentFlows.new(client: self)
@@ -242,7 +231,6 @@ module ModernTreasury
       @returns = ModernTreasury::Resources::Returns.new(client: self)
       @transactions = ModernTreasury::Resources::Transactions.new(client: self)
       @validations = ModernTreasury::Resources::Validations.new(client: self)
-      @paper_items = ModernTreasury::Resources::PaperItems.new(client: self)
       @virtual_accounts = ModernTreasury::Resources::VirtualAccounts.new(client: self)
       @bulk_requests = ModernTreasury::Resources::BulkRequests.new(client: self)
       @bulk_results = ModernTreasury::Resources::BulkResults.new(client: self)

data/lib/modern_treasury/errors.rb

@@ -9,6 +9,28 @@ module ModernTreasury
     end
 
     class ConversionError < ModernTreasury::Errors::Error
+      # @return [StandardError, nil]
+      def cause = @cause.nil? ? super : @cause
+
+      # @api private
+      #
+      # @param on [Class<StandardError>]
+      # @param method [Symbol]
+      # @param target [Object]
+      # @param value [Object]
+      # @param cause [StandardError, nil]
+      def initialize(on:, method:, target:, value:, cause: nil)
+        cls = on.name.split("::").last
+
+        message = [
+          "Failed to parse #{cls}.#{method} from #{value.class} to #{target.inspect}.",
+          "To get the unparsed API response, use #{cls}[#{method.inspect}].",
+          cause && "Cause: #{cause.message}"
+        ].filter(&:itself).join(" ")
+
+        @cause = cause
+        super(message)
+      end
     end
 
     class APIError < ModernTreasury::Errors::Error

data/lib/modern_treasury/internal/transport/base_client.rb

@@ -365,7 +365,7 @@ module ModernTreasury
         #
         # @raise [ModernTreasury::Errors::APIError]
         # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
           url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout)
           input = {
             **request.except(:timeout),
@@ -478,6 +478,7 @@ module ModernTreasury
           self.class.validate!(req)
           model = req.fetch(:model) { ModernTreasury::Internal::Type::Unknown }
           opts = req[:options].to_h
+          unwrap = req[:unwrap]
           ModernTreasury::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
@@ -494,11 +495,18 @@ module ModernTreasury
           decoded = ModernTreasury::Internal::Util.decode_content(response, stream: stream)
           case req
           in {stream: Class => st}
-            st.new(model: model, url: url, status: status, response: response, stream: decoded)
+            st.new(
+              model: model,
+              url: url,
+              status: status,
+              response: response,
+              unwrap: unwrap,
+              stream: decoded
+            )
           in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
-            unwrapped = ModernTreasury::Internal::Util.dig(decoded, req[:unwrap])
+            unwrapped = ModernTreasury::Internal::Util.dig(decoded, unwrap)
             ModernTreasury::Internal::Type::Converter.coerce(model, unwrapped)
           end
         end

data/lib/modern_treasury/internal/type/array_of.rb

@@ -62,10 +62,14 @@ module ModernTreasury
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Array<Object>, Object]
@@ -74,6 +78,7 @@ module ModernTreasury
 
           unless value.is_a?(Array)
             exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Array}")
             return value
           end
 

data/lib/modern_treasury/internal/type/base_model.rb

@@ -60,7 +60,7 @@ module ModernTreasury
                 [ModernTreasury::Internal::Type::Converter.type_info(type_info), type_info]
               end
 
-            setter = "#{name_sym}="
+            setter = :"#{name_sym}="
             api_name = info.fetch(:api_name, name_sym)
             nilable = info.fetch(:nil?, false)
             const = if required && !nilable
@@ -84,28 +84,61 @@ module ModernTreasury
                 type_fn: type_fn
               }
 
-            define_method(setter) { @data.store(name_sym, _1) }
+            define_method(setter) do |value|
+              target = type_fn.call
+              state = ModernTreasury::Internal::Type::Converter.new_coerce_state(translate_names: false)
+              coerced = ModernTreasury::Internal::Type::Converter.coerce(target, value, state: state)
+              status = @coerced.store(name_sym, state.fetch(:error) || true)
+              stored =
+                case [target, status]
+                in [ModernTreasury::Internal::Type::Converter | Symbol, true]
+                  coerced
+                else
+                  value
+                end
+              @data.store(name_sym, stored)
+            end
 
+            # rubocop:disable Style/CaseEquality
+            # rubocop:disable Metrics/BlockLength
             define_method(name_sym) do
               target = type_fn.call
-              value = @data.fetch(name_sym) { const == ModernTreasury::Internal::OMIT ? nil : const }
-              state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-              if (nilable || !required) && value.nil?
-                nil
-              else
-                ModernTreasury::Internal::Type::Converter.coerce(
-                  target, value, state: state
+
+              case @coerced[name_sym]
+              in true | false if ModernTreasury::Internal::Type::Converter === target
+                @data.fetch(name_sym)
+              in ::StandardError => e
+                raise ModernTreasury::Errors::ConversionError.new(
+                  on: self.class,
+                  method: __method__,
+                  target: target,
+                  value: @data.fetch(name_sym),
+                  cause: e
                 )
+              else
+                Kernel.then do
+                  value = @data.fetch(name_sym) { const == ModernTreasury::Internal::OMIT ? nil : const }
+                  state = ModernTreasury::Internal::Type::Converter.new_coerce_state(translate_names: false)
+                  if (nilable || !required) && value.nil?
+                    nil
+                  else
+                    ModernTreasury::Internal::Type::Converter.coerce(
+                      target, value, state: state
+                    )
+                  end
+                rescue StandardError => e
+                  raise ModernTreasury::Errors::ConversionError.new(
+                    on: self.class,
+                    method: __method__,
+                    target: target,
+                    value: value,
+                    cause: e
+                  )
+                end
               end
-            rescue StandardError => e
-              cls = self.class.name.split("::").last
-              message = [
-                "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}.",
-                "To get the unparsed API response, use #{cls}[#{__method__.inspect}].",
-                "Cause: #{e.message}"
-              ].join(" ")
-              raise ModernTreasury::Errors::ConversionError.new(message)
             end
+            # rubocop:enable Metrics/BlockLength
+            # rubocop:enable Style/CaseEquality
           end
 
           # @api private
@@ -205,23 +238,28 @@ module ModernTreasury
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [self, Object]
           def coerce(value, state:)
             exactness = state.fetch(:exactness)
 
-            if value.is_a?(self.class)
+            if value.is_a?(self)
               exactness[:yes] += 1
               return value
             end
 
             unless (val = ModernTreasury::Internal::Util.coerce_hash(value)).is_a?(Hash)
               exactness[:no] += 1
+              state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
               return value
             end
             exactness[:yes] += 1
@@ -229,13 +267,15 @@ module ModernTreasury
             keys = val.keys.to_set
             instance = new
             data = instance.to_h
+            status = instance.instance_variable_get(:@coerced)
 
             # rubocop:disable Metrics/BlockLength
             fields.each do |name, field|
               mode, required, target = field.fetch_values(:mode, :required, :type)
               api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
+              src_name = state.fetch(:translate_names) ? api_name : name
 
-              unless val.key?(api_name)
+              unless val.key?(src_name)
                 if required && mode != :dump && const == ModernTreasury::Internal::OMIT
                   exactness[nilable ? :maybe : :no] += 1
                 else
@@ -244,9 +284,10 @@ module ModernTreasury
                 next
               end
 
-              item = val.fetch(api_name)
-              keys.delete(api_name)
+              item = val.fetch(src_name)
+              keys.delete(src_name)
 
+              state[:error] = nil
               converted =
                 if item.nil? && (nilable || !required)
                   exactness[nilable ? :yes : :maybe] += 1
@@ -260,6 +301,8 @@ module ModernTreasury
                     item
                   end
                 end
+
+              status.store(name, state.fetch(:error) || true)
               data.store(name, converted)
             end
             # rubocop:enable Metrics/BlockLength
@@ -403,10 +446,10 @@ module ModernTreasury
         # @return [Hash{Symbol=>Object}]
         #
         # @example
-        #   # `async_response` is a `ModernTreasury::AsyncResponse`
-        #   async_response => {
-        #     id: id,
-        #     object: object
+        #   # `accounting` is a `ModernTreasury::Accounting`
+        #   accounting => {
+        #     account_id: account_id,
+        #     class_id: class_id
         #   }
         def deconstruct_keys(keys)
           (keys || self.class.known_fields.keys)
@@ -437,7 +480,18 @@ module ModernTreasury
         # Create a new instance of a model.
         #
         # @param data [Hash{Symbol=>Object}, self]
-        def initialize(data = {}) = (@data = ModernTreasury::Internal::Util.coerce_hash!(data).to_h)
+        def initialize(data = {})
+          @data = {}
+          @coerced = {}
+          ModernTreasury::Internal::Util.coerce_hash!(data).each do
+            if self.class.known_fields.key?(_1)
+              public_send(:"#{_1}=", _2)
+            else
+              @data.store(_1, _2)
+              @coerced.store(_1, false)
+            end
+          end
+        end
 
         class << self
           # @api private

data/lib/modern_treasury/internal/type/boolean.rb

@@ -31,14 +31,20 @@ module ModernTreasury
         class << self
           # @api private
           #
+          # Coerce value to Boolean if possible, otherwise return the original value.
+          #
           # @param value [Boolean, Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Boolean, Object]

data/lib/modern_treasury/internal/type/converter.rb

@@ -15,10 +15,14 @@ module ModernTreasury
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Object]
@@ -94,6 +98,21 @@ module ModernTreasury
             end
           end
 
+          # @api private
+          #
+          # @param translate_names [Boolean]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def new_coerce_state(translate_names: true)
+            {
+              translate_names: translate_names,
+              strictness: true,
+              exactness: {yes: 0, no: 0, maybe: 0},
+              error: nil,
+              branched: 0
+            }
+          end
+
           # @api private
           #
           # Based on `target`, transform `value` into `target`, to the extent possible:
@@ -110,14 +129,11 @@ module ModernTreasury
           #
           # @param value [Object]
           #
-          # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`, or `:strong`. This informs the
-          # coercion strategy when we have to decide between multiple possible conversion
-          # targets:
+          # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`. This informs the coercion strategy
+          # when we have to decide between multiple possible conversion targets:
           #
           # - `true`: the conversion must be exact, with minimum coercion.
           # - `false`: the conversion can be approximate, with some coercion.
-          # - `:strong`: the conversion must be exact, with no coercion, and raise an error
-          #   if not possible.
           #
           # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
           # any given conversion attempt, the exactness will be updated based on how closely
@@ -130,21 +146,20 @@ module ModernTreasury
           #
           # See implementation below for more details.
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Object]
-          def coerce(
-            target,
-            value,
-            state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-          )
-            # rubocop:disable Lint/SuppressedException
+          def coerce(target, value, state: ModernTreasury::Internal::Type::Converter.new_coerce_state)
             # rubocop:disable Metrics/BlockNesting
-            strictness, exactness = state.fetch_values(:strictness, :exactness)
+            exactness = state.fetch(:exactness)
 
             case target
             in ModernTreasury::Internal::Type::Converter
@@ -160,29 +175,26 @@ module ModernTreasury
                 exactness[value.nil? ? :yes : :maybe] += 1
                 return nil
               in -> { _1 <= Integer }
-                if value.is_a?(Integer)
+                case value
+                in Integer
                   exactness[:yes] += 1
                   return value
-                elsif strictness == :strong && Integer(value, exception: false) != value
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise value.is_a?(Numeric) ? ArgumentError.new(message) : TypeError.new(message)
                 else
                   Kernel.then do
                     return Integer(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= Float }
                 if value.is_a?(Numeric)
                   exactness[:yes] += 1
                   return Float(value)
-                elsif strictness == :strong
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise TypeError.new(message)
                 else
                   Kernel.then do
                     return Float(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= String }
@@ -194,16 +206,13 @@ module ModernTreasury
                   exactness[:yes] += 1
                   return value.string
                 else
-                  if strictness == :strong
-                    message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                    raise TypeError.new(message)
-                  end
+                  state[:error] = TypeError.new("#{value.class} can't be coerced into #{String}")
                 end
               in -> { _1 <= Date || _1 <= Time }
                 Kernel.then do
                   return target.parse(value).tap { exactness[:yes] += 1 }
                 rescue ArgumentError, TypeError => e
-                  raise e if strictness == :strong
+                  state[:error] = e
                 end
               in -> { _1 <= StringIO } if value.is_a?(String)
                 exactness[:yes] += 1
@@ -221,10 +230,8 @@ module ModernTreasury
                   return value
                 end
               else
-                if strictness == :strong
-                  message = "cannot convert non-matching #{value.class} into #{target.inspect}"
-                  raise ArgumentError.new(message)
-                end
+                message = "cannot convert non-matching #{value.class} into #{target.inspect}"
+                state[:error] = ArgumentError.new(message)
               end
             else
             end
@@ -232,7 +239,6 @@ module ModernTreasury
             exactness[:no] += 1
             value
             # rubocop:enable Metrics/BlockNesting
-            # rubocop:enable Lint/SuppressedException
           end
 
           # @api private
@@ -277,8 +283,10 @@ module ModernTreasury
         define_sorbet_constant!(:CoerceState) do
           T.type_alias do
             {
-              strictness: T.any(T::Boolean, Symbol),
+              translate_names: T::Boolean,
+              strictness: T::Boolean,
               exactness: {yes: Integer, no: Integer, maybe: Integer},
+              error: T::Class[StandardError],
               branched: Integer
             }
           end

data/lib/modern_treasury/internal/type/enum.rb

@@ -77,10 +77,14 @@ module ModernTreasury
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Symbol, Object]
@@ -91,8 +95,12 @@ module ModernTreasury
           if values.include?(val)
             exactness[:yes] += 1
             val
+          elsif values.first&.class == val.class
+            exactness[:maybe] += 1
+            value
           else
-            exactness[values.first&.class == val.class ? :maybe : :no] += 1
+            exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{self}")
             value
           end
         end