inttegro 3.0.1 → 4.2.1

data/lib/inttegro/generated/operations.rb

@@ -31,6 +31,10 @@ module Inttegro
       "/customers/lookup" => Inttegro::CustomerResponse,
       "/customers/update" => Inttegro::CustomerResponse,
       "/customers/page" => Inttegro::PageCustomersResponse,
+      "/checkout/lookup" => Inttegro::CheckoutOrderResponse,
+      "/checkout/pay" => Inttegro::CheckoutOrderResponse,
+      "/checkout/confirm_payment" => Inttegro::CheckoutOrderResponse,
+      "/checkout/request_confirmation" => Inttegro::CheckoutOrderResponse,
       "/orders/create" => Inttegro::OrderEnvelope,
       "/orders/lookup" => Inttegro::OrderEnvelope,
       "/orders/update" => Inttegro::OrderEnvelope,
@@ -150,6 +154,10 @@ module Inttegro
       "/customers/lookup" => "Inttegro::LookupCustomerRequest",
       "/customers/update" => "Inttegro::UpdateCustomerRequest",
       "/customers/page" => "Inttegro::PageCustomersRequest",
+      "/checkout/lookup" => "Inttegro::CheckoutOrderReferenceRequest",
+      "/checkout/pay" => "Inttegro::CheckoutPayRequest",
+      "/checkout/confirm_payment" => "Inttegro::CheckoutConfirmPaymentRequest",
+      "/checkout/request_confirmation" => "Inttegro::CheckoutOrderReferenceRequest",
       "/orders/create" => "T.any(Inttegro::CreateOrderNewCustomer, Inttegro::CreateOrderExistingCustomer)",
       "/orders/lookup" => "Inttegro::LookupOrderRequest",
       "/orders/update" => "Inttegro::UpdateOrderRequest",
@@ -233,7 +241,7 @@ module Inttegro
       "/purchase_intents/cancel" => "Inttegro::CancelPurchaseIntentRequest",
       "/purchase_intents/lookup" => "Inttegro::LookupPurchaseIntentRequest",
       "/purchase_intents/page" => "Inttegro::PagePurchaseIntentsRequest",
-      "/prices/create" => "Inttegro::CreatePriceRequest",
+      "/prices/create" => "Inttegro::CatalogPriceParams",
       "/prices/lookup" => "Inttegro::LookupPriceRequest",
       "/prices/page" => "Inttegro::PricePageRequest",
       "/prices/update" => "Inttegro::UpdatePriceRequest",
@@ -267,6 +275,10 @@ module Inttegro
       "/customers/lookup" => "lookupCustomer",
       "/customers/update" => "updateCustomer",
       "/customers/page" => "pageCustomers",
+      "/checkout/lookup" => "lookupCheckoutOrder",
+      "/checkout/pay" => "payCheckoutOrder",
+      "/checkout/confirm_payment" => "confirmCheckoutPayment",
+      "/checkout/request_confirmation" => "requestCheckoutConfirmation",
       "/orders/create" => "createOrder",
       "/orders/lookup" => "lookupOrder",
       "/orders/update" => "updateOrder",

data/lib/inttegro/http_client.rb

@@ -12,6 +12,7 @@ require_relative "models"
 require_relative "generated/operations"
 require_relative "response_object"
 require_relative "transport_response"
+require_relative "telemetry"
 require_relative "types"
 require_relative "version"
 
@@ -34,10 +35,20 @@ module Inttegro
         base_url: T.nilable(String),
         read_timeout: T.nilable(Numeric),
         open_timeout: T.nilable(Numeric),
-        adapter: T.nilable(Types::Adapter)
+        adapter: T.nilable(Types::Adapter),
+        telemetry_enabled: T::Boolean,
+        tracer_provider: T.nilable(OpenTelemetry::Trace::TracerProvider)
       ).void
     end
-    def initialize(api_key:, base_url: DEFAULT_BASE_URL, read_timeout: 30, open_timeout: 10, adapter: nil)
+    def initialize(
+      api_key:,
+      base_url: DEFAULT_BASE_URL,
+      read_timeout: 30,
+      open_timeout: 10,
+      adapter: nil,
+      telemetry_enabled: true,
+      tracer_provider: nil
+    )
       @api_key = T.let(api_key || "", String)
       raise ArgumentError, "api_key is required" if @api_key.strip.empty?
 
@@ -48,6 +59,10 @@ module Inttegro
       @read_timeout = T.let(read_timeout, T.nilable(Numeric))
       @open_timeout = T.let(open_timeout, T.nilable(Numeric))
       @adapter = T.let(adapter, T.nilable(Types::Adapter))
+      @telemetry = T.let(
+        Telemetry.new(Inttegro::VERSION, enabled: telemetry_enabled, tracer_provider: tracer_provider),
+        Telemetry
+      )
     end
 
     sig { params(path: String, headers: Types::Headers, query: T.nilable(Types::Query)).returns(ResponseValue) }
@@ -165,16 +180,17 @@ module Inttegro
           fields: Types::Payload,
           files: Types::Payload,
           headers: Types::Headers,
-          authenticated: T::Boolean
+          authenticated: T::Boolean,
+          operation: T.nilable(String)
         )
         .returns(T.type_parameter(:Model))
     end
-    def post_multipart_model(path, model, fields: {}, files: {}, headers: {}, authenticated: true)
+    def post_multipart_model(path, model, fields: {}, files: {}, headers: {}, authenticated: true, operation: nil)
       unless model <= T::Struct
         raise TypeError, "response model for #{path} must inherit from T::Struct"
       end
 
-      response = perform_multipart(path, fields, files, headers, authenticated, model)
+      response = perform_multipart(path, fields, files, headers, authenticated, model, operation)
       return T.cast(response, T.type_parameter(:Model)) if response.is_a?(model)
 
       raise TypeError, "expected #{model} from #{path}, got #{response.class}"
@@ -218,62 +234,76 @@ module Inttegro
         files: Types::Payload,
         headers: Types::Headers,
         authenticated: T::Boolean,
-        model: T.nilable(T::Class[T::Struct])
+        model: T.nilable(T::Class[T::Struct]),
+        operation: T.nilable(String)
       ).returns(ResponseValue)
     end
-    def perform_multipart(path, fields, files, headers, authenticated, model)
-      uri = build_uri(path, nil)
-      request = Net::HTTP::Post.new(uri)
-      request["Accept"] = "application/json"
-      request["User-Agent"] = USER_AGENT
-      request["Authorization"] = "Bearer #{@api_key}" if authenticated
-      headers = headers.dup
-      if authenticated && idempotent_mutation_path?(path) && !header_present?(headers, "Idempotency-Key")
-        headers["Idempotency-Key"] = generate_idempotency_key
-      end
-      headers.each { |key, value| request[key] = value }
+    def perform_multipart(path, fields, files, headers, authenticated, model, operation = nil)
+      @telemetry.in_span(path, :post, @base_url, Inttegro::VERSION, operation) do |span|
+        uri = build_uri(path, nil)
+        request = Net::HTTP::Post.new(uri)
+        request["Accept"] = "application/json"
+        request["User-Agent"] = USER_AGENT
+        request["Authorization"] = "Bearer #{@api_key}" if authenticated
+        headers = headers.dup
+        if authenticated && idempotent_mutation_path?(path) && !header_present?(headers, "Idempotency-Key")
+          headers["Idempotency-Key"] = generate_idempotency_key
+        end
+        headers.each { |key, value| request[key] = value }
 
-      form = []
-      fields.each do |key, value|
-        next if value.nil?
+        form = []
+        fields.each do |key, value|
+          next if value.nil?
 
-        form << [key.to_s, value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value.to_s]
-      end
-      files.each do |key, path|
-        raise ArgumentError, "file path for #{key} must be a String" unless path.is_a?(String)
+          form << [key.to_s, value.is_a?(Hash) || value.is_a?(Array) ? JSON.generate(value) : value.to_s]
+        end
+        files.each do |key, file_path|
+          raise ArgumentError, "file path for #{key} must be a String" unless file_path.is_a?(String)
 
-        form << [key.to_s, File.open(path)]
+          form << [key.to_s, File.open(file_path)]
+        end
+        request.set_form(form, "multipart/form-data")
+        @telemetry.prepare(span, request)
+
+        raw_response = @adapter ? @adapter.call(uri, request) : build_http(uri).request(request)
+        response = TransportResponse.new(raw_response)
+        @telemetry.response(span, response, decoded: false)
+        result = handle_response(path, response, model)
+        @telemetry.decoded(span)
+        result
       end
-      request.set_form(form, "multipart/form-data")
-
-      raw_response = @adapter ? @adapter.call(uri, request) : build_http(uri).request(request)
-      response = TransportResponse.new(raw_response)
-      handle_response(path, response, model)
     end
 
     sig { params(path: String, body: Types::RequestBody).returns(FileDownload) }
     def post_binary_json(path, body)
-      body = with_request_meta_idempotency(:post, path, coerce_body(body), {})
-      response = raw_request(:post, path, JSON.dump(body), {
-        "Accept" => "application/octet-stream",
-        "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{@api_key}"
-      })
-      return FileDownload.new(response.body, response.headers) if response.code.to_i < 400
-
-      raise_response_error(response)
+      @telemetry.in_span(path, :post, @base_url, Inttegro::VERSION) do |span|
+        payload = with_request_meta_idempotency(:post, path, coerce_body(body), {})
+        response = raw_request(:post, path, JSON.dump(payload), {
+          "Accept" => "application/octet-stream",
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{@api_key}"
+        }, span)
+        @telemetry.response(span, response, decoded: false)
+        return FileDownload.new(response.body, response.headers) if response.code.to_i < 400
+
+        raise_response_error(response)
+      end
     end
 
     sig { params(url: String).returns(FileDownload) }
     def get_binary_public(url)
-      uri = build_uri(url, nil)
-      request = Net::HTTP::Get.new(uri)
-      request["User-Agent"] = USER_AGENT
-      raw_response = @adapter ? @adapter.call(uri, request) : build_http(uri).request(request)
-      response = TransportResponse.new(raw_response)
-      return FileDownload.new(response.body, response.headers) if response.code.to_i < 400
-
-      raise_response_error(response)
+      @telemetry.in_span(url, :get, @base_url, Inttegro::VERSION, "file_links.download") do |span|
+        uri = build_uri(url, nil)
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = USER_AGENT
+        @telemetry.prepare(span, request)
+        raw_response = @adapter ? @adapter.call(uri, request) : build_http(uri).request(request)
+        response = TransportResponse.new(raw_response)
+        @telemetry.response(span, response, decoded: false)
+        return FileDownload.new(response.body, response.headers) if response.code.to_i < 400
+
+        raise_response_error(response)
+      end
     end
 
     sig do
@@ -287,20 +317,26 @@ module Inttegro
       ).returns(ResponseValue)
     end
     def request(method, path, body: nil, headers: {}, query: nil, response_model: nil)
-      uri = build_uri(path, query)
-      body = validate_body(path, coerce_body(body))
-      body = with_request_meta_idempotency(method, path, body, headers)
-      request = build_request(method, uri, body, headers)
-
-      raw_response =
-        if @adapter
-          @adapter.call(uri, request)
-        else
-          http = build_http(uri)
-          http.request(request)
-        end
-      response = TransportResponse.new(raw_response)
-      handle_response(path, response, response_model)
+      @telemetry.in_span(path, method, @base_url, Inttegro::VERSION) do |span|
+        uri = build_uri(path, query)
+        body = validate_body(path, coerce_body(body))
+        body = with_request_meta_idempotency(method, path, body, headers)
+        request = build_request(method, uri, body, headers)
+        @telemetry.prepare(span, request)
+
+        raw_response =
+          if @adapter
+            @adapter.call(uri, request)
+          else
+            http = build_http(uri)
+            http.request(request)
+          end
+        response = TransportResponse.new(raw_response)
+        @telemetry.response(span, response, decoded: false)
+        result = handle_response(path, response, response_model)
+        @telemetry.decoded(span)
+        result
+      end
     rescue Timeout::Error, Errno::ETIMEDOUT => e
       raise TimeoutError.new("Request timed out", e)
     rescue SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET => e
@@ -327,13 +363,15 @@ module Inttegro
         method: T.any(String, Symbol),
         path: String,
         body: T.nilable(String),
-        headers: Types::Headers
+        headers: Types::Headers,
+        span: T.nilable(OpenTelemetry::Trace::Span)
       ).returns(TransportResponse)
     end
-    def raw_request(method, path, body, headers)
+    def raw_request(method, path, body, headers, span = nil)
       uri = build_uri(path, nil)
       request = build_request(method, uri, nil, headers)
       request.body = body if body
+      @telemetry.prepare(span, request)
       raw_response = @adapter ? @adapter.call(uri, request) : build_http(uri).request(request)
       TransportResponse.new(raw_response)
     end

data/lib/inttegro/models.rb

@@ -9,6 +9,58 @@ require_relative "types"
 module Inttegro
   extend T::Sig
 
+  # Amount primitives live under Money so the namespace can grow to include
+  # currency conversion and formatting helpers without treating money as a
+  # single value type.
+  module Money
+    Amount = Inttegro::Amount
+    AmountParams = Inttegro::AmountParams
+    Currency = Inttegro::Currency
+  end
+
+  # Wallet variants used by financial accounts.
+  module Wallets
+    Wallet = Inttegro::FinancialAccountWallet
+    MobileMoney = Inttegro::FinancialAccountWalletMobileMoney
+    UpdatedWallet = Inttegro::UpdatedFinancialAccountWallet
+    WalletParams = Inttegro::FinancialAccountWalletRequestWallet
+    MobileMoneyParams = Inttegro::FinancialAccountWalletRequestWalletMobileMoney
+    WalletType = Inttegro::WalletType
+  end
+
+  # Bank-account variants used by financial accounts. Payment-method bank
+  # snapshots remain in the payment-method domain.
+  module BankAccounts
+    BankAccount = Inttegro::FinancialAccountBank
+    CreatedBankAccount = Inttegro::CreatedFinancialAccountBank
+    UpdatedBankAccount = Inttegro::UpdatedFinancialAccountBank
+    GhanaBankAccount = Inttegro::GhanaBankAccount
+    CreatedGhanaBankAccount = Inttegro::CreatedGhanaBankAccount
+    UpdatedGhanaBankAccount = Inttegro::UpdatedGhanaBankAccount
+    Owner = Inttegro::FinancialAccountOwner
+    CreatedOwner = Inttegro::CreatedFinancialAccountOwner
+    UpdatedOwner = Inttegro::UpdatedFinancialAccountOwner
+    OwnerAddress = Inttegro::FinancialAccountAddress
+    CreatedOwnerAddress = Inttegro::CreatedFinancialAccountAddress
+    UpdatedOwnerAddress = Inttegro::UpdatedFinancialAccountAddress
+    BankAccountParams = Inttegro::FinancialAccountBankRequestBankAccount
+    GhanaBankAccountParams = Inttegro::FinancialAccountBankRequestBankAccountGhanaBankAccount
+    BankAccountType = Inttegro::BankAccountType
+  end
+
+  # Currency identifiers serialize to lowercase wire values while accepting
+  # legacy uppercase response values during deserialization.
+  class Currency
+    class << self
+      extend T::Sig
+
+      sig { params(value: String).returns(Inttegro::Currency) }
+      def deserialize(value)
+        super(value.strip.downcase)
+      end
+    end
+  end
+
   # Backward-compatible acronym spellings for domain objects.
   OtpTransaction = OTPTransaction
   OtpTransmission = OTPTransmission

data/lib/inttegro/resources/orders.rb

@@ -203,7 +203,7 @@ module Inttegro
       #     token: '123456'
       #   )
       #
-      #   if order.payment&.status == Inttegro::OrderPaymentStatus::PAID
+      #   if order.payment&.status == Inttegro::PaymentStatus::PAID
       #     puts 'Payment confirmed successfully!'
       #   end
       #

data/lib/inttegro/resources/prices.rb

@@ -9,11 +9,11 @@ module Inttegro
       end
 
       def create(payload)
-        @http.post_resource("/prices/create", Inttegro::Price, :price, payload)
+        @http.post_resource("/prices/create", Inttegro::CatalogPrice, :price, payload)
       end
 
       def lookup(price_id:)
-        @http.post_resource("/prices/lookup", Inttegro::Price, :price, { price_id: price_id })
+        @http.post_resource("/prices/lookup", Inttegro::CatalogPrice, :price, { price_id: price_id })
       end
 
       def page(payload = {})
@@ -21,19 +21,19 @@ module Inttegro
       end
 
       def update(payload)
-        @http.post_resource("/prices/update", Inttegro::Price, :price, payload)
+        @http.post_resource("/prices/update", Inttegro::CatalogPrice, :price, payload)
       end
 
       def activate(price_id:)
-        @http.post_resource("/prices/activate", Inttegro::Price, :price, { price_id: price_id })
+        @http.post_resource("/prices/activate", Inttegro::CatalogPrice, :price, { price_id: price_id })
       end
 
       def deactivate(price_id:)
-        @http.post_resource("/prices/deactivate", Inttegro::Price, :price, { price_id: price_id })
+        @http.post_resource("/prices/deactivate", Inttegro::CatalogPrice, :price, { price_id: price_id })
       end
 
       def archive(price_id:)
-        @http.post_resource("/prices/archive", Inttegro::Price, :price, { price_id: price_id })
+        @http.post_resource("/prices/archive", Inttegro::CatalogPrice, :price, { price_id: price_id })
       end
     end
   end

data/lib/inttegro/resources/products.rb

@@ -13,7 +13,7 @@ module Inttegro
       end
 
       def add_price(payload)
-        @http.post_resource("/products/add_price", Inttegro::ProductPriceNominal, :price, payload)
+        @http.post_resource("/products/add_price", Inttegro::CatalogPrice, :price, payload)
       end
 
       def set_default_unit_price(payload)

data/lib/inttegro/resources/upload_requests.rb

@@ -52,7 +52,8 @@ module Inttegro
           upload_url,
           Inttegro::UploadFulfillment,
           files: { file: file },
-          authenticated: false
+          authenticated: false,
+          operation: "upload_requests.upload"
         )
       end
 

data/lib/inttegro/telemetry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "opentelemetry-api"
+require "sorbet-runtime"
+require "uri"
+
+require_relative "errors"
+
+module Inttegro
+  # Emits redacted SDK spans to the application's OpenTelemetry provider.
+  # This class never configures an exporter or sends telemetry to Inttegro.
+  class Telemetry
+    extend T::Sig
+
+    SAFE_RESOURCES = %w[
+      apps balance_transactions balances broadcasts checkout chimes customers file_links file_references files
+      financial_accounts keys message_templates orders otp payment_methods payouts ping prices products
+      purchase_intents refunds schedules sessions spec upload_requests
+    ].freeze
+    SAFE_ACTIONS = %w[
+      activate add_price archive broadcast cancel complete confirm_payment confirm_verification connect contents
+      countries create deactivate delete destroy disable disable_fx disable_pull disable_push disactivate disconnect
+      enable enable_fx enable_pull enable_push finalize generate initiate lookup new open page pay publish reconcile
+      reconnect refund render_preview request_confirmation review revoke schedule send send_invoice send_receipt
+      set_default_unit_price set_destinations settings tokenize unarchive unpublish update upload usage verify
+    ].freeze
+
+    sig do
+      params(
+        version: String,
+        enabled: T::Boolean,
+        tracer_provider: T.nilable(OpenTelemetry::Trace::TracerProvider)
+      ).void
+    end
+    def initialize(version, enabled: true, tracer_provider: nil)
+      @enabled = T.let(enabled, T::Boolean)
+      provider = tracer_provider || OpenTelemetry.tracer_provider
+      @tracer = T.let(provider.tracer("inttegro", version), OpenTelemetry::Trace::Tracer)
+    end
+
+    sig do
+      type_parameters(:Result)
+        .params(
+          path_or_url: String,
+          method: T.any(String, Symbol),
+          base_url: String,
+          version: String,
+          operation_override: T.nilable(String),
+          block: T.proc.params(span: T.nilable(OpenTelemetry::Trace::Span)).returns(T.type_parameter(:Result))
+        )
+        .returns(T.type_parameter(:Result))
+    end
+    def in_span(path_or_url, method, base_url, version, operation_override = nil, &block)
+      return yield(nil) unless @enabled
+
+      operation, route, server_address = request_details(path_or_url, base_url, operation_override)
+      attributes = {
+        "inttegro.operation.name" => operation,
+        "inttegro.sdk.language" => "ruby",
+        "inttegro.sdk.version" => version,
+        "http.request.method" => method.to_s.upcase,
+        "server.address" => server_address
+      }
+      attributes["url.template"] = route if route
+      span = @tracer.start_span("inttegro.#{operation}", kind: :client, attributes: attributes)
+
+      begin
+        OpenTelemetry::Trace.with_span(span) { |_active_span, _context| yield(span) }
+      rescue StandardError => e
+        error_type = classify_error(e)
+        span.set_attribute("error.type", error_type)
+        span.status = OpenTelemetry::Trace::Status.error
+        span.add_event("inttegro.request.failed", attributes: { "error.type" => error_type })
+        raise
+      ensure
+        span.finish
+      end
+    end
+
+    sig { params(span: T.nilable(OpenTelemetry::Trace::Span), request: Net::HTTPRequest).void }
+    def prepare(span, request)
+      if @enabled
+        carrier = T.let({}, T::Hash[String, String])
+        OpenTelemetry.propagation.inject(carrier)
+        carrier.each { |key, value| request[key] = value unless request[key] }
+      end
+      return unless span
+
+      span.add_event("inttegro.request.prepared")
+      span.add_event(
+        "inttegro.http.attempt.started",
+        attributes: { "http.request.resend_count" => 0 }
+      )
+    end
+
+    sig do
+      params(
+        span: T.nilable(OpenTelemetry::Trace::Span),
+        response: TransportResponse,
+        decoded: T::Boolean
+      ).void
+    end
+    def response(span, response, decoded:)
+      return unless span
+
+      status = response.code.to_i
+      span.set_attribute("http.response.status_code", status)
+      request_id = response["x-request-id"]
+      span.set_attribute("inttegro.request.id", request_id) if request_id && !request_id.empty?
+      span.add_event(
+        "inttegro.response.received",
+        attributes: {
+          "http.response.status_code" => status,
+          "http.request.resend_count" => 0
+        }
+      )
+      span.add_event("inttegro.response.decoded") if decoded
+    end
+
+    sig { params(span: T.nilable(OpenTelemetry::Trace::Span)).void }
+    def decoded(span)
+      span.add_event("inttegro.response.decoded") if span
+    end
+
+    private
+
+    sig do
+      params(path_or_url: String, base_url: String, override: T.nilable(String))
+        .returns([String, T.nilable(String), String])
+    end
+    def request_details(path_or_url, base_url, override)
+      uri = path_or_url.start_with?("http://", "https://") ? URI.parse(path_or_url) : URI.join("#{base_url}/", path_or_url.sub(%r{\A/}, ""))
+      segments = path_or_url.start_with?("http://", "https://") ? [] : T.must(uri.path).split("/").reject(&:empty?)
+      resource = segments[0]
+      action = segments[1]
+      known_route = !resource.nil? && segments.length <= 2 && SAFE_RESOURCES.include?(resource) &&
+        (action.nil? || SAFE_ACTIONS.include?(action))
+      route = known_route ? uri.path : nil
+      derived_operation = known_route ? "#{resource}.#{action || (resource == 'balances' ? 'lookup' : 'request')}" : "http.request"
+      [override || derived_operation, route, uri.host || "unknown"]
+    end
+
+    sig { params(error: StandardError).returns(String) }
+    def classify_error(error)
+      return "timeout" if error.is_a?(TimeoutError) || error.is_a?(Timeout::Error) || error.is_a?(Errno::ETIMEDOUT)
+      return "network_error" if error.is_a?(NetworkError) || error.is_a?(SocketError) || error.is_a?(SystemCallError)
+      return "http_#{error.status}" if error.is_a?(APIError)
+      return "decode_error" if error.is_a?(JSON::ParserError)
+
+      "unknown_error"
+    end
+  end
+
+  private_constant :Telemetry
+end

data/lib/inttegro/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module Inttegro
-  VERSION = "3.0.1"
+  VERSION = "4.2.1"
 end

data/rbi/inttegro/generated.rbi

@@ -388,25 +388,25 @@ module Inttegro
       sig { params(http: Inttegro::HTTPClient).void }
       def initialize(http); end
 
-      sig { params(price_id: String).returns(Inttegro::Price) }
+      sig { params(price_id: String).returns(Inttegro::CatalogPrice) }
       def activate(price_id:); end
 
-      sig { params(price_id: String).returns(Inttegro::Price) }
+      sig { params(price_id: String).returns(Inttegro::CatalogPrice) }
       def archive(price_id:); end
 
-      sig { params(payload: T.any(Inttegro::CreatePriceRequest, Inttegro::Types::Payload)).returns(Inttegro::Price) }
+      sig { params(payload: T.any(Inttegro::CatalogPriceParams, Inttegro::Types::Payload)).returns(Inttegro::CatalogPrice) }
       def create(payload); end
 
-      sig { params(price_id: String).returns(Inttegro::Price) }
+      sig { params(price_id: String).returns(Inttegro::CatalogPrice) }
       def deactivate(price_id:); end
 
-      sig { params(price_id: String).returns(Inttegro::Price) }
+      sig { params(price_id: String).returns(Inttegro::CatalogPrice) }
       def lookup(price_id:); end
 
       sig { params(payload: T.nilable(T.any(Inttegro::PricePageRequest, Inttegro::Types::Payload))).returns(Inttegro::PricePage) }
       def page(payload = nil); end
 
-      sig { params(payload: T.any(Inttegro::UpdatePriceRequest, Inttegro::Types::Payload)).returns(Inttegro::Price) }
+      sig { params(payload: T.any(Inttegro::UpdatePriceRequest, Inttegro::Types::Payload)).returns(Inttegro::CatalogPrice) }
       def update(payload); end
     end
 
@@ -414,7 +414,7 @@ module Inttegro
       sig { params(http: Inttegro::HTTPClient).void }
       def initialize(http); end
 
-      sig { params(payload: T.any(Inttegro::AddProductPriceRequest, Inttegro::Types::Payload)).returns(Inttegro::ProductPriceNominal) }
+      sig { params(payload: T.any(Inttegro::AddProductPriceRequest, Inttegro::Types::Payload)).returns(Inttegro::CatalogPrice) }
       def add_price(payload); end
 
       sig { params(product_id: String).returns(Inttegro::Product) }