increase 0.3.3 → 1.1.0

data/lib/increase/client.rb

@@ -1,55 +1,299 @@
 # frozen_string_literal: true
 
-require "increase/configuration"
-require "increase/middleware/raise_api_error"
-
-require "faraday"
-require "faraday/follow_redirects" # Supports both Faraday 1.0 and 2.0
-if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new("2.0")
-  # In Faraday 2.0, multipart support is no longer included by default
-  require "faraday/multipart"
-else
-  # In Faraday 1.0, the JSON middleware is not included by default
-  require "increase/middleware/encode_json"
-  require "increase/middleware/parse_json"
-end
-
 module Increase
-  class Client
-    extend Forwardable
+  class Client < Increase::Internal::Transport::BaseClient
+    # Default max number of retries to attempt after a failed retryable request.
+    DEFAULT_MAX_RETRIES = 2
+
+    # Default per-request timeout.
+    DEFAULT_TIMEOUT_IN_SECONDS = 60.0
+
+    # Default initial retry delay in seconds.
+    # Overall delay is calculated using exponential backoff + jitter.
+    DEFAULT_INITIAL_RETRY_DELAY = 0.5
+
+    # Default max retry delay in seconds.
+    DEFAULT_MAX_RETRY_DELAY = 8.0
+
+    # rubocop:disable Style/MutableConstant
+    # @type [Hash{Symbol=>String}]
+    ENVIRONMENTS = {production: "https://api.increase.com", sandbox: "https://sandbox.increase.com"}
+    # rubocop:enable Style/MutableConstant
+
+    # @return [String]
+    attr_reader :api_key
+
+    # @return [Increase::Resources::Accounts]
+    attr_reader :accounts
+
+    # @return [Increase::Resources::AccountNumbers]
+    attr_reader :account_numbers
+
+    # @return [Increase::Resources::Cards]
+    attr_reader :cards
+
+    # @return [Increase::Resources::CardPayments]
+    attr_reader :card_payments
+
+    # @return [Increase::Resources::CardPurchaseSupplements]
+    attr_reader :card_purchase_supplements
+
+    # @return [Increase::Resources::CardDisputes]
+    attr_reader :card_disputes
+
+    # @return [Increase::Resources::PhysicalCards]
+    attr_reader :physical_cards
+
+    # @return [Increase::Resources::DigitalCardProfiles]
+    attr_reader :digital_card_profiles
+
+    # @return [Increase::Resources::PhysicalCardProfiles]
+    attr_reader :physical_card_profiles
+
+    # @return [Increase::Resources::DigitalWalletTokens]
+    attr_reader :digital_wallet_tokens
+
+    # @return [Increase::Resources::Transactions]
+    attr_reader :transactions
+
+    # @return [Increase::Resources::PendingTransactions]
+    attr_reader :pending_transactions
+
+    # @return [Increase::Resources::DeclinedTransactions]
+    attr_reader :declined_transactions
+
+    # @return [Increase::Resources::AccountTransfers]
+    attr_reader :account_transfers
+
+    # @return [Increase::Resources::ACHTransfers]
+    attr_reader :ach_transfers
+
+    # @return [Increase::Resources::ACHPrenotifications]
+    attr_reader :ach_prenotifications
+
+    # @return [Increase::Resources::InboundACHTransfers]
+    attr_reader :inbound_ach_transfers
+
+    # @return [Increase::Resources::WireTransfers]
+    attr_reader :wire_transfers
+
+    # @return [Increase::Resources::InboundWireTransfers]
+    attr_reader :inbound_wire_transfers
+
+    # @return [Increase::Resources::WireDrawdownRequests]
+    attr_reader :wire_drawdown_requests
+
+    # @return [Increase::Resources::InboundWireDrawdownRequests]
+    attr_reader :inbound_wire_drawdown_requests
+
+    # @return [Increase::Resources::CheckTransfers]
+    attr_reader :check_transfers
+
+    # @return [Increase::Resources::InboundCheckDeposits]
+    attr_reader :inbound_check_deposits
+
+    # @return [Increase::Resources::RealTimePaymentsTransfers]
+    attr_reader :real_time_payments_transfers
+
+    # @return [Increase::Resources::InboundRealTimePaymentsTransfers]
+    attr_reader :inbound_real_time_payments_transfers
 
-    attr_accessor :configuration
-    def_delegators :configuration, :configure
+    # @return [Increase::Resources::CheckDeposits]
+    attr_reader :check_deposits
 
-    def_delegators :configuration, :base_url, :base_url=
-    def_delegators :configuration, :api_key, :api_key=
-    def_delegators :configuration, :raise_api_errors, :raise_api_errors=
+    # @return [Increase::Resources::Lockboxes]
+    attr_reader :lockboxes
 
-    def initialize(config = nil)
-      @configuration = config.is_a?(Configuration) ? config : Configuration.new(config)
+    # @return [Increase::Resources::InboundMailItems]
+    attr_reader :inbound_mail_items
+
+    # @return [Increase::Resources::RoutingNumbers]
+    attr_reader :routing_numbers
+
+    # @return [Increase::Resources::ExternalAccounts]
+    attr_reader :external_accounts
+
+    # @return [Increase::Resources::Entities]
+    attr_reader :entities
+
+    # @return [Increase::Resources::SupplementalDocuments]
+    attr_reader :supplemental_documents
+
+    # @return [Increase::Resources::Programs]
+    attr_reader :programs
+
+    # @return [Increase::Resources::AccountStatements]
+    attr_reader :account_statements
+
+    # @return [Increase::Resources::Files]
+    attr_reader :files
+
+    # @return [Increase::Resources::FileLinks]
+    attr_reader :file_links
+
+    # @return [Increase::Resources::Documents]
+    attr_reader :documents
+
+    # @return [Increase::Resources::Exports]
+    attr_reader :exports
+
+    # @return [Increase::Resources::Events]
+    attr_reader :events
+
+    # @return [Increase::Resources::EventSubscriptions]
+    attr_reader :event_subscriptions
+
+    # @return [Increase::Resources::RealTimeDecisions]
+    attr_reader :real_time_decisions
+
+    # @return [Increase::Resources::BookkeepingAccounts]
+    attr_reader :bookkeeping_accounts
+
+    # @return [Increase::Resources::BookkeepingEntrySets]
+    attr_reader :bookkeeping_entry_sets
+
+    # @return [Increase::Resources::BookkeepingEntries]
+    attr_reader :bookkeeping_entries
+
+    # @return [Increase::Resources::Groups]
+    attr_reader :groups
+
+    # @return [Increase::Resources::OAuthApplications]
+    attr_reader :oauth_applications
+
+    # @return [Increase::Resources::OAuthConnections]
+    attr_reader :oauth_connections
+
+    # @return [Increase::Resources::OAuthTokens]
+    attr_reader :oauth_tokens
+
+    # @return [Increase::Resources::IntrafiAccountEnrollments]
+    attr_reader :intrafi_account_enrollments
+
+    # @return [Increase::Resources::IntrafiBalances]
+    attr_reader :intrafi_balances
+
+    # @return [Increase::Resources::IntrafiExclusions]
+    attr_reader :intrafi_exclusions
+
+    # @return [Increase::Resources::Simulations]
+    attr_reader :simulations
+
+    # @api private
+    #
+    # @return [Hash{String=>String}]
+    private def auth_headers
+      return {} if @api_key.nil?
+
+      {"authorization" => "Bearer #{@api_key}"}
     end
 
-    def connection
-      Faraday.new(
-        url: @configuration.base_url,
-        headers: {
-          Authorization: "Bearer #{@configuration.api_key}",
-          "User-Agent": "Increase Ruby Gem v#{Increase::VERSION} (https://github.com/garyhtou/increase-ruby)"
-        }
-      ) do |f|
-        f.request :json
-        f.request :multipart
-
-        if @configuration.raise_api_errors
-          # This custom middleware for raising Increase API errors must be
-          # located before the JSON response middleware.
-          f.use Increase::Middleware::RaiseApiError
-        end
-
-        f.response :json
-        f.response :follow_redirects
-        f.adapter Faraday.default_adapter
+    # Creates and returns a new client for interacting with the API.
+    #
+    # @param api_key [String, nil] Defaults to `ENV["INCREASE_API_KEY"]`
+    #
+    # @param environment [:production, :sandbox, nil] Specifies the environment to use for the API.
+    #
+    # Each environment maps to a different base URL:
+    #
+    # - `production` corresponds to `https://api.increase.com`
+    # - `sandbox` corresponds to `https://sandbox.increase.com`
+    #
+    # @param base_url [String, nil] Override the default base URL for the API, e.g.,
+    # `"https://api.example.com/v2/"`. Defaults to `ENV["INCREASE_BASE_URL"]`
+    #
+    # @param max_retries [Integer] Max number of retries to attempt after a failed retryable request.
+    #
+    # @param timeout [Float]
+    #
+    # @param initial_retry_delay [Float]
+    #
+    # @param max_retry_delay [Float]
+    #
+    # @param idempotency_header [String]
+    def initialize(
+      api_key: ENV["INCREASE_API_KEY"],
+      environment: nil,
+      base_url: ENV["INCREASE_BASE_URL"],
+      max_retries: self.class::DEFAULT_MAX_RETRIES,
+      timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
+      idempotency_header: "Idempotency-Key"
+    )
+      base_url ||= Increase::Client::ENVIRONMENTS.fetch(environment&.to_sym || :production) do
+        message = "environment must be one of #{Increase::Client::ENVIRONMENTS.keys}, got #{environment}"
+        raise ArgumentError.new(message)
+      end
+
+      if api_key.nil?
+        raise ArgumentError.new("api_key is required, and can be set via environ: \"INCREASE_API_KEY\"")
       end
+
+      @api_key = api_key.to_s
+
+      super(
+        base_url: base_url,
+        timeout: timeout,
+        max_retries: max_retries,
+        initial_retry_delay: initial_retry_delay,
+        max_retry_delay: max_retry_delay,
+        idempotency_header: idempotency_header
+      )
+
+      @accounts = Increase::Resources::Accounts.new(client: self)
+      @account_numbers = Increase::Resources::AccountNumbers.new(client: self)
+      @cards = Increase::Resources::Cards.new(client: self)
+      @card_payments = Increase::Resources::CardPayments.new(client: self)
+      @card_purchase_supplements = Increase::Resources::CardPurchaseSupplements.new(client: self)
+      @card_disputes = Increase::Resources::CardDisputes.new(client: self)
+      @physical_cards = Increase::Resources::PhysicalCards.new(client: self)
+      @digital_card_profiles = Increase::Resources::DigitalCardProfiles.new(client: self)
+      @physical_card_profiles = Increase::Resources::PhysicalCardProfiles.new(client: self)
+      @digital_wallet_tokens = Increase::Resources::DigitalWalletTokens.new(client: self)
+      @transactions = Increase::Resources::Transactions.new(client: self)
+      @pending_transactions = Increase::Resources::PendingTransactions.new(client: self)
+      @declined_transactions = Increase::Resources::DeclinedTransactions.new(client: self)
+      @account_transfers = Increase::Resources::AccountTransfers.new(client: self)
+      @ach_transfers = Increase::Resources::ACHTransfers.new(client: self)
+      @ach_prenotifications = Increase::Resources::ACHPrenotifications.new(client: self)
+      @inbound_ach_transfers = Increase::Resources::InboundACHTransfers.new(client: self)
+      @wire_transfers = Increase::Resources::WireTransfers.new(client: self)
+      @inbound_wire_transfers = Increase::Resources::InboundWireTransfers.new(client: self)
+      @wire_drawdown_requests = Increase::Resources::WireDrawdownRequests.new(client: self)
+      @inbound_wire_drawdown_requests = Increase::Resources::InboundWireDrawdownRequests.new(client: self)
+      @check_transfers = Increase::Resources::CheckTransfers.new(client: self)
+      @inbound_check_deposits = Increase::Resources::InboundCheckDeposits.new(client: self)
+      @real_time_payments_transfers = Increase::Resources::RealTimePaymentsTransfers.new(client: self)
+      @inbound_real_time_payments_transfers =
+        Increase::Resources::InboundRealTimePaymentsTransfers.new(client: self)
+      @check_deposits = Increase::Resources::CheckDeposits.new(client: self)
+      @lockboxes = Increase::Resources::Lockboxes.new(client: self)
+      @inbound_mail_items = Increase::Resources::InboundMailItems.new(client: self)
+      @routing_numbers = Increase::Resources::RoutingNumbers.new(client: self)
+      @external_accounts = Increase::Resources::ExternalAccounts.new(client: self)
+      @entities = Increase::Resources::Entities.new(client: self)
+      @supplemental_documents = Increase::Resources::SupplementalDocuments.new(client: self)
+      @programs = Increase::Resources::Programs.new(client: self)
+      @account_statements = Increase::Resources::AccountStatements.new(client: self)
+      @files = Increase::Resources::Files.new(client: self)
+      @file_links = Increase::Resources::FileLinks.new(client: self)
+      @documents = Increase::Resources::Documents.new(client: self)
+      @exports = Increase::Resources::Exports.new(client: self)
+      @events = Increase::Resources::Events.new(client: self)
+      @event_subscriptions = Increase::Resources::EventSubscriptions.new(client: self)
+      @real_time_decisions = Increase::Resources::RealTimeDecisions.new(client: self)
+      @bookkeeping_accounts = Increase::Resources::BookkeepingAccounts.new(client: self)
+      @bookkeeping_entry_sets = Increase::Resources::BookkeepingEntrySets.new(client: self)
+      @bookkeeping_entries = Increase::Resources::BookkeepingEntries.new(client: self)
+      @groups = Increase::Resources::Groups.new(client: self)
+      @oauth_applications = Increase::Resources::OAuthApplications.new(client: self)
+      @oauth_connections = Increase::Resources::OAuthConnections.new(client: self)
+      @oauth_tokens = Increase::Resources::OAuthTokens.new(client: self)
+      @intrafi_account_enrollments = Increase::Resources::IntrafiAccountEnrollments.new(client: self)
+      @intrafi_balances = Increase::Resources::IntrafiBalances.new(client: self)
+      @intrafi_exclusions = Increase::Resources::IntrafiExclusions.new(client: self)
+      @simulations = Increase::Resources::Simulations.new(client: self)
     end
   end
 end

data/lib/increase/errors.rb

@@ -1,99 +1,281 @@
 # frozen_string_literal: true
 
 module Increase
-  class Error < StandardError; end
+  module Errors
+    class Error < StandardError
+      # @!attribute cause
+      #
+      #   @return [StandardError, nil]
+    end
+
+    class ConversionError < Increase::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 < Increase::Errors::Error
+      # @return [URI::Generic]
+      attr_accessor :url
+
+      # @return [Integer, nil]
+      attr_accessor :status
 
-  class ApiError < Error
-    attr_reader :response
+      # @return [Object, nil]
+      attr_accessor :body
 
-    attr_reader :detail
-    attr_reader :status
-    attr_reader :title
-    attr_reader :type
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer, nil]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(url:, status: nil, body: nil, request: nil, response: nil, message: nil)
+        @url = url
+        @status = status
+        @body = body
+        @request = request
+        @response = response
+        super(message)
+      end
+    end
 
-    def initialize(message, response: nil, detail: nil, status: nil, title: nil, type: nil)
-      @response = response
+    class APIConnectionError < Increase::Errors::APIError
+      # @!attribute status
+      #
+      #   @return [nil]
 
-      @detail = detail || response.body["detail"]
-      @status = status || response.body["status"]
-      @title = title || response.body["title"]
-      @type = type || response.body["type"]
+      # @!attribute body
+      #
+      #   @return [nil]
 
-      super(message)
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [nil]
+      # @param body [nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(
+        url:,
+        status: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+        super
+      end
     end
 
-    class << self
-      def from_response(response)
-        type = response.body["type"]
-        klass = ERROR_TYPES[type]
+    class APITimeoutError < Increase::Errors::APIConnectionError
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [nil]
+      # @param body [nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(
+        url:,
+        status: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+        super
+      end
+    end
 
-        # Fallback in case of really bad 5xx error
-        klass ||= InternalServerError if (500..599).cover?(response.status)
+    class APIStatusError < Increase::Errors::APIError
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      #
+      # @return [self]
+      def self.for(url:, status:, body:, request:, response:, message: nil)
+        key = Increase::Internal::Util.dig(body, :type)
+        kwargs = {
+          url: url,
+          status: status,
+          body: body,
+          request: request,
+          response: response,
+          message: message
+        }
 
-        # Handle case of an unknown error
-        klass ||= ApiError
+        case [status, key]
+        in [400, Increase::Errors::InvalidParametersError::TYPE]
+          Increase::Errors::InvalidParametersError.new(**kwargs)
+        in [400, Increase::Errors::MalformedRequestError::TYPE]
+          Increase::Errors::MalformedRequestError.new(**kwargs)
+        in [401, Increase::Errors::InvalidAPIKeyError::TYPE]
+          Increase::Errors::InvalidAPIKeyError.new(**kwargs)
+        in [403, Increase::Errors::EnvironmentMismatchError::TYPE]
+          Increase::Errors::EnvironmentMismatchError.new(**kwargs)
+        in [403, Increase::Errors::InsufficientPermissionsError::TYPE]
+          Increase::Errors::InsufficientPermissionsError.new(**kwargs)
+        in [403, Increase::Errors::PrivateFeatureError::TYPE]
+          Increase::Errors::PrivateFeatureError.new(**kwargs)
+        in [404, Increase::Errors::APIMethodNotFoundError::TYPE]
+          Increase::Errors::APIMethodNotFoundError.new(**kwargs)
+        in [404, Increase::Errors::ObjectNotFoundError::TYPE]
+          Increase::Errors::ObjectNotFoundError.new(**kwargs)
+        in [409, Increase::Errors::IdempotencyKeyAlreadyUsedError::TYPE]
+          Increase::Errors::IdempotencyKeyAlreadyUsedError.new(**kwargs)
+        in [409, Increase::Errors::InvalidOperationError::TYPE]
+          Increase::Errors::InvalidOperationError.new(**kwargs)
+        in [429, Increase::Errors::RateLimitedError::TYPE]
+          Increase::Errors::RateLimitedError.new(**kwargs)
+        in [(500..), Increase::Errors::InternalServerError::TYPE]
+          Increase::Errors::InternalServerError.new(**kwargs)
+        in [400, _]
+          Increase::Errors::BadRequestError.new(**kwargs)
+        in [401, _]
+          Increase::Errors::AuthenticationError.new(**kwargs)
+        in [403, _]
+          Increase::Errors::PermissionDeniedError.new(**kwargs)
+        in [404, _]
+          Increase::Errors::NotFoundError.new(**kwargs)
+        in [409, _]
+          Increase::Errors::ConflictError.new(**kwargs)
+        in [422, _]
+          Increase::Errors::UnprocessableEntityError.new(**kwargs)
+        in [429, _]
+          Increase::Errors::RateLimitError.new(**kwargs)
+        else
+          Increase::Errors::APIStatusError.new(**kwargs)
+        end
+      end
 
-        code = [response.body["status"] || response.status, type].compact.join(": ") || "Error"
-        message = [response.body["title"], response.body["detail"]].compact.join(" ") || "Increase API Error"
+      # @!parse
+      #   # @return [Integer]
+      #   attr_accessor :status
 
-        klass.new("[#{code}] #{message}", response: response)
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param status [Integer]
+      # @param body [Object, nil]
+      # @param request [nil]
+      # @param response [nil]
+      # @param message [String, nil]
+      def initialize(url:, status:, body:, request:, response:, message: nil)
+        message ||= {url: url.to_s, status: status, body: body}
+        super(
+          url: url,
+          status: status,
+          body: body,
+          request: request,
+          response: response,
+          message: message&.to_s
+        )
       end
     end
-  end
 
-  class ApiMethodNotFoundError < ApiError; end
+    class BadRequestError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
 
-  class EnvironmentMismatchError < ApiError; end
+    class PermissionDeniedError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
 
-  class IdempotencyConflictError < ApiError; end
+    class NotFoundError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
 
-  class IdempotencyUnprocessableError < ApiError; end
+    class ConflictError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
 
-  class InsufficientPermissionsError < ApiError; end
+    class UnprocessableEntityError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
 
-  class InternalServerError < ApiError; end
+    class RateLimitError < Increase::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InvalidParametersError < Increase::Errors::BadRequestError
+      TYPE = "invalid_parameters_error"
+    end
 
-  class InvalidApiKeyError < ApiError; end
+    class MalformedRequestError < Increase::Errors::BadRequestError
+      TYPE = "malformed_request_error"
+    end
 
-  class InvalidOperationError < ApiError; end
+    class InvalidAPIKeyError < Increase::Errors::AuthenticationError
+      TYPE = "invalid_api_key_error"
+    end
 
-  class InvalidParametersError < ApiError; end
+    class EnvironmentMismatchError < Increase::Errors::PermissionDeniedError
+      TYPE = "environment_mismatch_error"
+    end
 
-  class MalformedRequestError < ApiError; end
+    class InsufficientPermissionsError < Increase::Errors::PermissionDeniedError
+      TYPE = "insufficient_permissions_error"
+    end
 
-  class ObjectNotFoundError < ApiError; end
+    class PrivateFeatureError < Increase::Errors::PermissionDeniedError
+      TYPE = "private_feature_error"
+    end
 
-  class PrivateFeatureError < ApiError; end
+    class APIMethodNotFoundError < Increase::Errors::NotFoundError
+      TYPE = "api_method_not_found_error"
+    end
 
-  class RateLimitedError < ApiError; end
+    class ObjectNotFoundError < Increase::Errors::NotFoundError
+      TYPE = "object_not_found_error"
+    end
 
-  ERROR_TYPES = {
-    "api_method_not_found_error" => ApiMethodNotFoundError,
-    "environment_mismatch_error" => EnvironmentMismatchError,
-    "idempotency_conflict_error" => IdempotencyConflictError,
-    "idempotency_unprocessable_error" => IdempotencyUnprocessableError,
-    "insufficient_permissions_error" => InsufficientPermissionsError,
-    "internal_server_error" => InternalServerError,
-    "invalid_api_key_error" => InvalidApiKeyError,
-    "invalid_operation_error" => InvalidOperationError,
-    "invalid_parameters_error" => InvalidParametersError,
-    "malformed_request_error" => MalformedRequestError,
-    "object_not_found_error" => ObjectNotFoundError,
-    "private_feature_error" => PrivateFeatureError,
-    "rate_limited_error" => RateLimitedError
-  }
+    class IdempotencyKeyAlreadyUsedError < Increase::Errors::ConflictError
+      TYPE = "idempotency_key_already_used_error"
+    end
 
-  # WebhookSignatureVerificationError is raised when a received webhook's
-  # signature is invalid.
-  class WebhookSignatureVerificationError < Error
-    attr_reader :signature_header
-    attr_reader :payload
+    class InvalidOperationError < Increase::Errors::ConflictError
+      TYPE = "invalid_operation_error"
+    end
 
-    def initialize(message = "Increase webhook signature verification failed", signature_header: nil, payload: nil)
-      @signature_header = signature_header
-      @payload = payload
+    class RateLimitedError < Increase::Errors::RateLimitError
+      TYPE = "rate_limited_error"
+    end
 
-      super(message)
+    class InternalServerError < Increase::Errors::APIStatusError
+      TYPE = "internal_server_error"
     end
   end
 end