schematichq 1.5.2 → 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

@@ -12,6 +12,10 @@ module Schematic
 
         field :billing_cycle_anchor, -> { String }, optional: true, nullable: false
 
+        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
@@ -32,6 +36,8 @@ module Schematic
 
         field :require_no_migration, -> { Internal::Types::Boolean }, optional: true, nullable: false
 
+        field :scheduled_at, -> { String }, optional: true, nullable: false
+
         field :send_invoice, -> { Internal::Types::Boolean }, optional: true, nullable: false
 
         field :tax_id, -> { Schematic::Types::TaxIdInput }, optional: true, nullable: false

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

@@ -10,6 +10,8 @@ module Schematic
 
         field :billing_cycle_anchor, -> { String }, optional: true, nullable: false
 
+        field :billing_start_date, -> { String }, optional: true, nullable: false
+
         field :customer_email, -> { String }, optional: false, nullable: false
 
         field :days_until_due, -> { Integer }, optional: true, nullable: false

data/lib/schematic/rules_engine.rb

@@ -73,12 +73,38 @@ module Schematic
     end
 
     def check_flag(flag, company = nil, user = nil)
+      check_flag_with_options(flag, company, user, nil)
+    end
+
+    # Evaluate a flag with preflight options: a simulated usage, an event-scoped
+    # usage, or a pre-computed per-credit cost. The engine applies them to the
+    # conditions they match without mutating any state, so a caller can ask
+    # "would this call still be allowed after it lands".
+    #
+    # options is a hash with any of :credit_cost (credit id to cost),
+    # :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
 
       # Build combined JSON envelope (same format as Python/C#)
       envelope = { flag: strip_nulls(flag) }
       envelope[:company] = strip_nulls(company) if company
       envelope[:user] = strip_nulls(user) if user
+      # Omitted entirely when empty, so the engine uses its own defaults.
+      envelope[:options] = strip_nulls(engine_options(options)) if options && !options.empty?
 
       json_bytes = JSON.generate(envelope).encode("UTF-8")
 
@@ -123,6 +149,29 @@ module Schematic
 
     private
 
+    # The options as the engine takes them. usage and event_usage.quantity
+    # deserialize as i64 there, so a value with a decimal point fails the whole
+    # check. Rounded through the helper every other wire field uses, so a caller
+    # passing a preflight straight to check_flag_with_entitlement is asked the
+    # same question a lease check asks, and an infinite usage is handed over
+    # rather than raising out of ceil.
+    def engine_options(options)
+      out = options.dup
+      usage_key = out.key?(:usage) ? :usage : "usage"
+      out[usage_key] = Credits::Leases.wire_quantity(out[usage_key]) if out[usage_key].is_a?(Numeric)
+      event_key = out.key?(:event_usage) ? :event_usage : "event_usage"
+      event_usage = out[event_key]
+      return out unless event_usage.is_a?(Hash)
+
+      quantity_key = event_usage.key?(:quantity) ? :quantity : "quantity"
+      return out unless event_usage[quantity_key].is_a?(Numeric)
+
+      out[event_key] = event_usage.merge(
+        quantity_key => Credits::Leases.wire_quantity(event_usage[quantity_key])
+      )
+      out
+    end
+
     def export_func(name)
       exp = @instance.export(name)
       raise "WASM export '#{name}' not found" unless exp

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