schematichq 1.5.3 → 1.5.4

data/lib/schematic/plans/client.rb

@@ -49,7 +49,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::UpdateCompanyPlansResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -72,7 +80,7 @@ module Schematic
       #   client.plans.list_custom_plan_billings(
       #     company_id: "company_id",
       #     plan_id: "plan_id",
-      #     plan_billing_source: "custom_plan",
+      #     plan_billing_source: "amendment",
       #     status: "active",
       #     statuses: ["active"],
       #     limit: 1000000,
@@ -108,7 +116,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::ListCustomPlanBillingsResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -132,14 +148,11 @@ module Schematic
       # @return [Schematic::Plans::Types::MarkCustomPlanBillingPaidResponse]
       def mark_custom_plan_billing_paid(request_options: {}, **params)
         params = Schematic::Internal::Types::Utils.normalize_keys(params)
-        path_param_names = %i[custom_plan_billing_id]
-        body_params = params.except(*path_param_names)
-
         request = Schematic::Internal::JSON::Request.new(
           base_url: request_options[:base_url],
           method: "PUT",
           path: "custom-plan-billings/#{URI.encode_uri_component(params[:custom_plan_billing_id].to_s)}/mark-paid",
-          body: body_params,
+          body: params[:request],
           request_options: request_options
         )
         begin
@@ -152,7 +165,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::MarkCustomPlanBillingPaidResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -195,7 +216,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::RetryCustomPlanBillingResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -233,7 +262,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::CreateCustomPlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -331,7 +368,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::ListPlansResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -369,7 +414,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::CreatePlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -412,7 +465,14 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::GetPlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -454,7 +514,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::UpdatePlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -489,7 +557,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::DeletePlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -532,7 +608,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::UpsertBillingProductPlanResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -572,7 +656,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::UpsertPlanForBillingProductResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -622,7 +714,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::ListBillingProductMatchCompaniesResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -672,7 +772,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::CountBillingProductMatchCompaniesResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -770,7 +878,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::CountPlansResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -814,7 +930,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::ListPlanIssuesResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -857,7 +981,65 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::DeletePlanVersionResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
+        end
+      end
+
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :plan_version_id
+      # @option params [String, nil] :against
+      #
+      # @example
+      #   client.plans.get_plan_version_diff(
+      #     plan_version_id: "plan_version_id",
+      #     against: "against"
+      #   )
+      #
+      # @return [Schematic::Plans::Types::GetPlanVersionDiffResponse]
+      def get_plan_version_diff(request_options: {}, **params)
+        params = Schematic::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params["against"] = params[:against] if params.key?(:against)
+
+        request = Schematic::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "plans/version/#{URI.encode_uri_component(params[:plan_version_id].to_s)}/diff",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Schematic::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          (response.body.to_s.empty? ? nil : Schematic::Plans::Types::GetPlanVersionDiffResponse.load(response.body))
+        else
+          error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
+          error_types = {
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -901,7 +1083,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Plans::Types::PublishPlanVersionResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
     end

data/lib/schematic/plans/types/get_plan_version_diff_params.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Plans
+    module Types
+      # Input parameters
+      class GetPlanVersionDiffParams < Internal::Types::Model
+        field :against, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/plans/types/get_plan_version_diff_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Plans
+    module Types
+      class GetPlanVersionDiffRequest < Internal::Types::Model
+        field :plan_version_id, -> { String }, optional: false, nullable: false
+
+        field :against, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/plans/types/get_plan_version_diff_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Schematic
+  module Plans
+    module Types
+      class GetPlanVersionDiffResponse < Internal::Types::Model
+        field :data, -> { Schematic::Types::PlanVersionDiffResponseData }, optional: false, nullable: false
+
+        field :params, -> { Schematic::Plans::Types::GetPlanVersionDiffParams }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/schematic/plans/types/publish_plan_version_request_body.rb

@@ -14,6 +14,8 @@ module Schematic
 
         field :billing_start_date, -> { String }, optional: true, nullable: false
 
+        field :collection_method, -> { Schematic::Types::BillingCollectionMethod }, optional: true, nullable: false
+
         field :coupon_external_id, -> { String }, optional: true, nullable: false
 
         field :custom_field_values, -> { Internal::Types::Array[Schematic::Types::CheckoutFieldValue] }, optional: true, nullable: false

data/lib/schematic/rules_engine.rb

@@ -82,8 +82,20 @@ module Schematic
     # "would this call still be allowed after it lands".
     #
     # options is a hash with any of :credit_cost (credit id to cost),
-    # :usage, and :event_usage ({ event_subtype:, quantity: }). The engine reads
-    # them snake_case in both directions, so they go on the envelope as given.
+    # :usage, :event_usage ({ event_subtype:, quantity: }), and
+    # :event_quantities ({ event_subtype:, quantity:, quantities: }). The engine
+    # reads them snake_case in both directions, so they go on the envelope as
+    # given.
+    #
+    # event_quantities prices an event against credit-balance conditions whose
+    # event_subtype matches, the way the API burns it: quantity times the
+    # condition's consumption_rate, plus each named quantity times its rate in
+    # the condition's quantity_rates. For an inference call, quantity is the
+    # request count and quantities the token counts as the event reports them
+    # (input tokens including the cached and cache-creation subsets). Keys
+    # without a rate cost nothing; an absent or zero quantity means one. It
+    # ranks below credit_cost and above event_usage and usage, and the engine
+    # reads its values as floats, so unlike event_usage they are not rounded.
     def check_flag_with_options(flag, company = nil, user = nil, options = nil)
       raise "WASM rules engine not initialized" unless @initialized
 

data/lib/schematic/scheduledcheckout/client.rb

@@ -56,7 +56,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Scheduledcheckout::Types::ListScheduledCheckoutsResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -96,7 +104,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Scheduledcheckout::Types::CreateScheduledCheckoutResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -131,7 +147,14 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Scheduledcheckout::Types::GetScheduledCheckoutResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
 
@@ -171,7 +194,15 @@ module Schematic
           (response.body.to_s.empty? ? nil : Schematic::Scheduledcheckout::Types::UpdateScheduledCheckoutResponse.load(response.body))
         else
           error_class = Schematic::Errors::ResponseError.subclass_for_code(code)
-          raise error_class.new(response.body, code: code)
+          error_types = {
+            400 => Schematic::Types::ApiError,
+            401 => Schematic::Types::ApiError,
+            403 => Schematic::Types::ApiError,
+            404 => Schematic::Types::ApiError,
+            500 => Schematic::Types::ApiError
+          }
+          error_body = Schematic::Errors::ResponseError.load_error_body(code, response.body, error_types)
+          raise error_class.new(response.body, code: code, body: error_body)
         end
       end
     end

data/lib/schematic/schematic_client.rb

@@ -175,9 +175,8 @@ module Schematic
 
     # default_value overrides the registered flag default on every path that
     # cannot answer from the flag itself: offline, an API error, or a response
-    # with no value. Leaving it nil keeps the registered default. timeout_ms is
-    # threaded to the API call, but see the note on check: the generated
-    # transport does not yet apply a per-request timeout.
+    # with no value. Leaving it nil keeps the registered default. timeout_ms
+    # bounds each attempt of the API call.
     def check_flag_with_entitlement(flag_key, company: nil, user: nil, preflight: nil, default_value: nil,
                                     timeout_ms: nil)
       get_default = -> { resolve_default_value(flag_key, default_value) }
@@ -345,10 +344,9 @@ module Schematic
     # governs that fallback too, so a check that cannot reach the credit path
     # still answers the way the caller asked.
     #
-    # timeout_ms is carried on the API request but not yet applied: the
-    # generated transport takes its timeout from the construction of its HTTP
-    # client, and nothing exposes that, so no per-check or client-level timeout
-    # is configurable today.
+    # timeout_ms bounds each attempt of the API calls the check makes (the
+    # plain flag check, check-and-reserve, or a lease acquire or extend), and
+    # caps how long the check waits on another caller's acquire or extend.
     def check(flag_key, company: nil, user: nil, usage: nil, event_subtype: nil, on_acquire_failure: nil,
               default_value: nil, timeout_ms: nil)
       options = {
@@ -657,6 +655,20 @@ module Schematic
     # Cache providers that serialize (RedisCacheProvider) hand back a Hash, not
     # the CheckFlagResponse that was stored; the in-memory cache returns the
     # object itself. Normalize so callers can use the response API either way.
+    # The REST preflight body has no event_quantities yet; only the local
+    # engine applies it. Sending it would ask the API a question it cannot
+    # read, so it comes off here, and the check answers without it. A preflight
+    # left empty becomes nil, so the check is a plain, cacheable one.
+    def rest_preflight(flag_key, preflight)
+      return preflight unless preflight.is_a?(Hash)
+      return preflight unless preflight.key?(:event_quantities) || preflight.key?("event_quantities")
+
+      @logger.warn("Preflight event_quantities for flag '#{flag_key}' is only applied by local evaluation; " \
+                   "the API check ignores it, so the check answers without it")
+      rest = preflight.reject { |key, _| key.to_s == "event_quantities" }
+      rest.empty? ? nil : rest
+    end
+
     def coerce_cached_response(cached)
       return cached unless cached.is_a?(Hash)
 
@@ -665,6 +677,7 @@ module Schematic
 
     def check_flag_via_api(flag_key, company, user, preflight: nil, timeout_ms: nil, get_default: nil)
       get_default ||= -> { get_flag_default(flag_key) }
+      preflight = rest_preflight(flag_key, preflight)
       cache_key = build_cache_key(flag_key, company, user)
       # The cache is keyed by flag, company and user, so a preflighted check and
       # a plain one collide on one entry while asking different questions ("is
@@ -736,10 +749,8 @@ module Schematic
       end
     end
 
-    # The generated transport reads its timeout from its own construction, not
-    # from a request, so timeout_in_seconds is carried but not yet honored.
-    # Sending it anyway means a per-check timeout starts working the moment the
-    # transport does, without another change here.
+    # The generated transport reads timeout_in_seconds per request, falling
+    # back to its client-wide timeout when the key is absent.
     def api_request_options(timeout_ms)
       return {} if timeout_ms.nil?
 

data/lib/schematic/types/billing_coupon_response_data.rb

@@ -7,7 +7,7 @@ module Schematic
 
       field :amount_off, -> { Integer }, optional: true, nullable: false
 
-      field :currency, -> { String }, optional: true, nullable: false
+      field :currency, -> { Schematic::Types::Currency }, optional: true, nullable: false
 
       field :duration, -> { String }, optional: true, nullable: false
 
@@ -27,7 +27,7 @@ module Schematic
 
       field :name, -> { String }, optional: false, nullable: false
 
-      field :percent_off, -> { Integer }, optional: true, nullable: false
+      field :percent_off, -> { Float }, optional: true, nullable: false
 
       field :provider_type, -> { Schematic::Types::BillingProviderType }, optional: false, nullable: false
 

data/lib/schematic/types/billing_credit_grant_response_data.rb

@@ -19,7 +19,7 @@ module Schematic
 
       field :credit_name, -> { String }, optional: false, nullable: false
 
-      field :currency, -> { String }, optional: true, nullable: false
+      field :currency, -> { Schematic::Types::Currency }, optional: true, nullable: false
 
       field :expires_at, -> { String }, optional: true, nullable: false
 
@@ -35,25 +35,25 @@ module Schematic
 
       field :postpaid_charge_amount, -> { Integer }, optional: true, nullable: false
 
-      field :postpaid_charge_currency, -> { String }, optional: true, nullable: false
+      field :postpaid_charge_currency, -> { Schematic::Types::Currency }, optional: true, nullable: false
 
-      field :postpaid_charged_credits, -> { Integer }, optional: true, nullable: false
+      field :postpaid_charged_credits, -> { Float }, optional: true, nullable: false
 
       field :price, -> { Schematic::Types::BillingPriceResponseData }, optional: true, nullable: false
 
-      field :quantity, -> { Integer }, optional: false, nullable: false
+      field :quantity, -> { Float }, optional: false, nullable: false
 
-      field :quantity_remaining, -> { Integer }, optional: false, nullable: false
+      field :quantity_remaining, -> { Float }, optional: false, nullable: false
 
-      field :quantity_used, -> { Integer }, optional: false, nullable: false
+      field :quantity_used, -> { Float }, optional: false, nullable: false
 
       field :renewal_enabled, -> { Internal::Types::Boolean }, optional: false, nullable: false
 
       field :renewal_period, -> { Schematic::Types::BillingPlanCreditGrantResetCadence }, optional: true, nullable: false
 
-      field :reserved, -> { Integer }, optional: true, nullable: false
+      field :reserved, -> { Float }, optional: true, nullable: false
 
-      field :settled, -> { Integer }, optional: true, nullable: false
+      field :settled, -> { Float }, optional: true, nullable: false
 
       field :source_grant_id, -> { String }, optional: true, nullable: false
 

data/lib/schematic/types/billing_customer_subscription.rb

@@ -3,7 +3,7 @@
 module Schematic
   module Types
     class BillingCustomerSubscription < Internal::Types::Model
-      field :currency, -> { String }, optional: false, nullable: false
+      field :currency, -> { Schematic::Types::Currency }, optional: false, nullable: false
 
       field :expired_at, -> { String }, optional: true, nullable: false
 

data/lib/schematic/types/billing_plan_credit_grant_response_data.rb

@@ -57,7 +57,7 @@ module Schematic
 
       field :license_id, -> { String }, optional: true, nullable: false
 
-      field :overdraft_limit, -> { Integer }, optional: true, nullable: false
+      field :overdraft_limit, -> { Float }, optional: true, nullable: false
 
       field :plan, -> { Schematic::Types::PreviewObjectResponseData }, optional: true, nullable: false