feat!: remove top level type aliases to relocated classes (#104)

Author: stainless-app[bot]

lib/finch_api.rb

@@ -47,7 +47,7 @@
 require_relative "finch_api/internal/type/base_model"
 require_relative "finch_api/internal/type/base_page"
 require_relative "finch_api/internal/type/request_parameters"
-require_relative "finch_api/aliases"
+require_relative "finch_api/internal"
 require_relative "finch_api/request_options"
 require_relative "finch_api/errors"
 require_relative "finch_api/internal/transport/base_client"

lib/finch_api/aliases.rb

@@ -189,32 +189,4 @@ class InternalServerError < FinchAPI::Errors::APIStatusError
       HTTP_STATUS = (500..)
     end
   end
-
-  Error = FinchAPI::Errors::Error
-
-  ConversionError = FinchAPI::Errors::ConversionError
-
-  APIError = FinchAPI::Errors::APIError
-
-  APIStatusError = FinchAPI::Errors::APIStatusError
-
-  APIConnectionError = FinchAPI::Errors::APIConnectionError
-
-  APITimeoutError = FinchAPI::Errors::APITimeoutError
-
-  BadRequestError = FinchAPI::Errors::BadRequestError
-
-  AuthenticationError = FinchAPI::Errors::AuthenticationError
-
-  PermissionDeniedError = FinchAPI::Errors::PermissionDeniedError
-
-  NotFoundError = FinchAPI::Errors::NotFoundError
-
-  ConflictError = FinchAPI::Errors::ConflictError
-
-  UnprocessableEntityError = FinchAPI::Errors::UnprocessableEntityError
-
-  RateLimitError = FinchAPI::Errors::RateLimitError
-
-  InternalServerError = FinchAPI::Errors::InternalServerError
 end

lib/finch_api/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module FinchAPI
+  # @api private
+  module Internal
+    OMIT = Object.new.freeze
+  end
+end

lib/finch_api/internal.rb

@@ -339,7 +339,7 @@ def initialize(
 
           begin
             status, response, stream = @requester.execute(input)
-          rescue FinchAPI::APIConnectionError => e
+          rescue FinchAPI::Errors::APIConnectionError => e
             status = e
           end
 
@@ -361,7 +361,7 @@ def initialize(
               retry_count: retry_count,
               send_retry_header: send_retry_header
             )
-          in FinchAPI::APIConnectionError if retry_count >= max_retries
+          in FinchAPI::Errors::APIConnectionError if retry_count >= max_retries
             raise status
           in (400..) if retry_count >= max_retries || !self.class.should_retry?(status, headers: response)
             decoded = Kernel.then do
@@ -421,7 +421,7 @@ def initialize(
         # @return [Object]
         def request(req)
           self.class.validate!(req)
-          model = req.fetch(:model) { FinchAPI::Unknown }
+          model = req.fetch(:model) { FinchAPI::Internal::Type::Unknown }
           opts = req[:options].to_h
           FinchAPI::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)

lib/finch_api/internal/transport/base_client.rb

@@ -33,7 +33,9 @@ def ===(other) = other.is_a?(Array) && other.all?(item_type)
         #
         # @return [Boolean]
         def ==(other)
-          other.is_a?(FinchAPI::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
+          # rubocop:disable Layout/LineLength
+          other.is_a?(FinchAPI::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
+          # rubocop:enable Layout/LineLength
         end
 
         # @api private

lib/finch_api/internal/type/array_of.rb

@@ -23,7 +23,7 @@ class << self
           #
           # @return [Hash{Symbol=>Hash{Symbol=>Object}}]
           def known_fields
-            @known_fields ||= (self < FinchAPI::BaseModel ? superclass.known_fields.dup : {})
+            @known_fields ||= (self < FinchAPI::Internal::Type::BaseModel ? superclass.known_fields.dup : {})
           end
 
           # @api private
@@ -67,10 +67,10 @@ def fields
             const = if required && !nilable
               info.fetch(
                 :const,
-                FinchAPI::Internal::Util::OMIT
+                FinchAPI::Internal::OMIT
               )
             else
-              FinchAPI::Internal::Util::OMIT
+              FinchAPI::Internal::OMIT
             end
 
             [name_sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym)
@@ -89,7 +89,7 @@ def fields
 
             define_method(name_sym) do
               target = type_fn.call
-              value = @data.fetch(name_sym) { const == FinchAPI::Internal::Util::OMIT ? nil : const }
+              value = @data.fetch(name_sym) { const == FinchAPI::Internal::OMIT ? nil : const }
               state = {strictness: :strong, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
               if (nilable || !required) && value.nil?
                 nil
@@ -105,7 +105,7 @@ def fields
               # rubocop:disable Layout/LineLength
               message = "Failed to parse #{cls}.#{__method__} from #{value.class} to #{target.inspect}. To get the unparsed API response, use #{cls}[:#{__method__}]."
               # rubocop:enable Layout/LineLength
-              raise FinchAPI::ConversionError.new(message)
+              raise FinchAPI::Errors::ConversionError.new(message)
             end
           end
 
@@ -175,7 +175,7 @@ def optional(name_sym, type_info, spec = {})
           # @param other [Object]
           #
           # @return [Boolean]
-          def ==(other) = other.is_a?(Class) && other <= FinchAPI::BaseModel && other.fields == fields
+          def ==(other) = other.is_a?(Class) && other <= FinchAPI::Internal::Type::BaseModel && other.fields == fields
         end
 
         # @param other [Object]
@@ -186,7 +186,7 @@ def ==(other) = self.class == other.class && @data == other.to_h
         class << self
           # @api private
           #
-          # @param value [FinchAPI::BaseModel, Hash{Object=>Object}, Object]
+          # @param value [FinchAPI::Internal::Type::BaseModel, Hash{Object=>Object}, Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
@@ -196,7 +196,7 @@ class << self
           #
           #   @option state [Integer] :branched
           #
-          # @return [FinchAPI::BaseModel, Object]
+          # @return [FinchAPI::Internal::Type::BaseModel, Object]
           def coerce(value, state:)
             exactness = state.fetch(:exactness)
 
@@ -221,7 +221,7 @@ def coerce(value, state:)
               api_name, nilable, const = field.fetch_values(:api_name, :nilable, :const)
 
               unless val.key?(api_name)
-                if required && mode != :dump && const == FinchAPI::Internal::Util::OMIT
+                if required && mode != :dump && const == FinchAPI::Internal::OMIT
                   exactness[nilable ? :maybe : :no] += 1
                 else
                   exactness[:yes] += 1
@@ -255,7 +255,7 @@ def coerce(value, state:)
 
           # @api private
           #
-          # @param value [FinchAPI::BaseModel, Object]
+          # @param value [FinchAPI::Internal::Type::BaseModel, Object]
           #
           # @return [Hash{Object=>Object}, Object]
           def dump(value)
@@ -284,7 +284,7 @@ def dump(value)
 
             known_fields.each_value do |field|
               mode, api_name, const = field.fetch_values(:mode, :api_name, :const)
-              next if mode == :coerce || acc.key?(api_name) || const == FinchAPI::Internal::Util::OMIT
+              next if mode == :coerce || acc.key?(api_name) || const == FinchAPI::Internal::OMIT
               acc.store(api_name, const)
             end
 
@@ -351,13 +351,13 @@ def to_yaml(*a) = self.class.dump(self).to_yaml(*a)
 
         # Create a new instance of a model.
         #
-        # @param data [Hash{Symbol=>Object}, FinchAPI::BaseModel]
+        # @param data [Hash{Symbol=>Object}, FinchAPI::Internal::Type::BaseModel]
         def initialize(data = {})
           case FinchAPI::Internal::Util.coerce_hash(data)
           in Hash => coerced
             @data = coerced
           else
-            raise ArgumentError.new("Expected a #{Hash} or #{FinchAPI::BaseModel}, got #{data.inspect}")
+            raise ArgumentError.new("Expected a #{Hash} or #{FinchAPI::Internal::Type::BaseModel}, got #{data.inspect}")
           end
         end
 

lib/finch_api/internal/type/base_model.rb

@@ -19,7 +19,7 @@ def self.===(other) = other == true || other == false
         # @param other [Object]
         #
         # @return [Boolean]
-        def self.==(other) = other.is_a?(Class) && other <= FinchAPI::BooleanModel
+        def self.==(other) = other.is_a?(Class) && other <= FinchAPI::Internal::Type::BooleanModel
 
         class << self
           # @api private

lib/finch_api/internal/type/boolean_model.rb

@@ -31,10 +31,10 @@ def coerce(value, state:) = (raise NotImplementedError)
         def dump(value)
           case value
           in Array
-            value.map { FinchAPI::Unknown.dump(_1) }
+            value.map { FinchAPI::Internal::Type::Unknown.dump(_1) }
           in Hash
-            value.transform_values { FinchAPI::Unknown.dump(_1) }
-          in FinchAPI::BaseModel
+            value.transform_values { FinchAPI::Internal::Type::Unknown.dump(_1) }
+          in FinchAPI::Internal::Type::BaseModel
             value.class.dump(value)
           else
             value
@@ -64,7 +64,7 @@ def type_info(spec)
             in Hash
               type_info(spec.slice(:const, :enum, :union).first&.last)
             in true | false
-              -> { FinchAPI::BooleanModel }
+              -> { FinchAPI::Internal::Type::BooleanModel }
             in FinchAPI::Internal::Type::Converter | Class | Symbol
               -> { spec }
             in NilClass | Integer | Float
@@ -209,7 +209,7 @@ def coerce(
           #
           # @return [Object]
           def dump(target, value)
-            target.is_a?(FinchAPI::Internal::Type::Converter) ? target.dump(value) : FinchAPI::Unknown.dump(value)
+            target.is_a?(FinchAPI::Internal::Type::Converter) ? target.dump(value) : FinchAPI::Internal::Type::Unknown.dump(value)
           end
         end
       end

lib/finch_api/internal/type/converter.rb

@@ -62,7 +62,7 @@ def ===(other) = values.include?(other)
         #
         # @return [Boolean]
         def ==(other)
-          other.is_a?(Module) && other.singleton_class <= FinchAPI::Enum && other.values.to_set == values.to_set
+          other.is_a?(Module) && other.singleton_class <= FinchAPI::Internal::Type::Enum && other.values.to_set == values.to_set
         end
 
         # @api private