diff --git a/lib/tapioca/dsl/compiler.rb b/lib/tapioca/dsl/compiler.rb
index 33447f58f..b30a51446 100644
--- a/lib/tapioca/dsl/compiler.rb
+++ b/lib/tapioca/dsl/compiler.rb
@@ -111,27 +111,29 @@ def add_error(error)
       private
 
       # Get the types of each parameter from a method signature
-      #: ((Method | UnboundMethod) method_def, untyped signature) -> Array[String]
+      #: ((Method | UnboundMethod) method_def, untyped signature) -> Array[RBI::Type]
       def parameters_types_from_signature(method_def, signature)
-        params = [] #: Array[String]
+        params = [] #: Array[RBI::Type]
 
-        return method_def.parameters.map { "T.untyped" } unless signature
+        return method_def.parameters.map { RBI::Type.untyped } unless signature
 
         # parameters types
-        signature.arg_types.each { |arg_type| params << arg_type[1].to_s }
+        signature.arg_types.each { |arg_type| params << RBI::Type.parse_string(sanitize_signature_types(arg_type[1].to_s)) }
 
         # keyword parameters types
-        signature.kwarg_types.each { |_, kwarg_type| params << kwarg_type.to_s }
+        signature.kwarg_types.each do |_, kwarg_type|
+          params << RBI::Type.parse_string(sanitize_signature_types(kwarg_type.to_s))
+        end
 
         # rest parameter type
-        params << signature.rest_type.to_s if signature.has_rest
+        params << RBI::Type.parse_string(sanitize_signature_types(signature.rest_type.to_s)) if signature.has_rest
 
         # keyrest parameter type
-        params << signature.keyrest_type.to_s if signature.has_keyrest
+        params << RBI::Type.parse_string(sanitize_signature_types(signature.keyrest_type.to_s)) if signature.has_keyrest
 
         # special case `.void` in a proc
         unless signature.block_name.nil?
-          params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
+          params << RBI::Type.parse_string(sanitize_signature_types(signature.block_type.to_s))
         end
 
         params
@@ -183,11 +185,14 @@ def compile_method_parameters_to_rbi(method_def)
         end
       end
 
-      #: ((Method | UnboundMethod) method_def) -> String
+      #: ((Method | UnboundMethod) method_def) -> RBI::Type
       def compile_method_return_type_to_rbi(method_def)
         signature = signature_of(method_def)
-        return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
-        sanitize_signature_types(return_type)
+        if signature.nil?
+          RBI::Type.untyped
+        else
+          RBI::Type.parse_string(sanitize_signature_types(name_of_type(signature.return_type)))
+        end
       end
     end
   end
diff --git a/lib/tapioca/dsl/compilers/aasm.rb b/lib/tapioca/dsl/compilers/aasm.rb
index 829d58abf..b0b2cf16e 100644
--- a/lib/tapioca/dsl/compilers/aasm.rb
+++ b/lib/tapioca/dsl/compilers/aasm.rb
@@ -85,17 +85,17 @@ def decorate
                 name = state.name
                 name = "#{namespace}_#{name}" if namespace
 
-                model.create_constant("STATE_#{name.upcase}", value: "T.let(T.unsafe(nil), Symbol)")
-                model.create_method("#{name}?", return_type: "T::Boolean")
+                model.create_constant("STATE_#{name.upcase}", value: "T.let(T.unsafe(nil), ::Symbol)")
+                model.create_method("#{name}?", return_type: RBI::Type.boolean)
               end
 
               # Create all of the methods for each event
-              parameters = [create_rest_param("opts", type: "T.untyped")]
+              parameters = [create_rest_param("opts", type: RBI::Type.untyped)]
               state_machine.events.each do |event|
                 model.create_method(event.name.to_s, parameters: parameters)
                 model.create_method("#{event.name}!", parameters: parameters)
                 model.create_method("#{event.name}_without_validation!", parameters: parameters)
-                model.create_method("may_#{event.name}?", return_type: "T::Boolean")
+                model.create_method("may_#{event.name}?", return_type: RBI::Type.boolean)
 
                 # For events, if there's a namespace the default methods are created in addition to
                 # namespaced ones.
@@ -105,7 +105,7 @@ def decorate
 
                 model.create_method(name.to_s, parameters: parameters)
                 model.create_method("#{name}!", parameters: parameters)
-                model.create_method("may_#{name}?", return_type: "T::Boolean")
+                model.create_method("may_#{name}?", return_type: RBI::Type.boolean)
 
                 # There's no namespaced method created for `_without_validation`, so skip
                 # defining a method for:
@@ -118,10 +118,13 @@ def decorate
             model.create_method(
               "aasm",
               parameters: [
-                create_rest_param("args", type: "T.untyped"),
-                create_block_param("block", type: "T.nilable(T.proc.bind(PrivateAASMMachine).void)"),
+                create_rest_param("args", type: RBI::Type.untyped),
+                create_block_param(
+                  "block",
+                  type: RBI::Type.proc.bind(RBI::Type.simple("PrivateAASMMachine")).void.nilable,
+                ),
               ],
-              return_type: "PrivateAASMMachine",
+              return_type: RBI::Type.simple("PrivateAASMMachine"),
               class_method: true,
             )
 
@@ -132,9 +135,12 @@ def decorate
               machine.create_method(
                 "event",
                 parameters: [
-                  create_param("name", type: "T.untyped"),
-                  create_opt_param("options", default: "nil", type: "T.untyped"),
-                  create_block_param("block", type: "T.proc.bind(PrivateAASMEvent).void"),
+                  create_param("name", type: RBI::Type.untyped),
+                  create_opt_param("options", default: "nil", type: RBI::Type.untyped),
+                  create_block_param(
+                    "block",
+                    type: RBI::Type.proc.bind("PrivateAASMEvent").void,
+                  ),
                 ],
               )
 
@@ -144,8 +150,19 @@ def decorate
                 machine.create_method(
                   method,
                   parameters: [
-                    create_rest_param("callbacks", type: "T.any(String, Symbol, T::Class[T.anything], Proc)"),
-                    create_block_param("block", type: "T.nilable(T.proc.bind(#{constant_name}).void)"),
+                    create_rest_param(
+                      "callbacks",
+                      type: RBI::Type.any(
+                        RBI::Type.simple("String"),
+                        RBI::Type.simple("Symbol"),
+                        RBI::Type.t_class(RBI::Type.anything),
+                        RBI::Type.proc,
+                      ),
+                    ),
+                    create_block_param(
+                      "block",
+                      type: RBI::Type.proc.bind(constant_name).void.nilable,
+                    ),
                   ],
                 )
               end
@@ -158,10 +175,10 @@ def decorate
                   event.create_method(
                     method,
                     parameters: [
-                      create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
+                      create_opt_param("symbol", type: RBI::Type.simple("::Symbol").nilable, default: "nil"),
                       create_block_param(
                         "block",
-                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                        type: RBI::Type.proc.bind(constant_name).params(opts: RBI::Type.untyped).void.nilable,
                       ),
                     ],
                   )
@@ -170,23 +187,23 @@ def decorate
                 event.create_method(
                   "transitions",
                   parameters: [
-                    create_opt_param("definitions", default: "nil", type: "T.untyped"),
-                    create_block_param("block", type: "T.nilable(T.proc.bind(PrivateAASMTransition).void)"),
+                    create_opt_param("definitions", default: "nil", type: RBI::Type.untyped),
+                    create_block_param("block", type: RBI::Type.proc.bind("PrivateAASMTransition").void.nilable),
                   ],
                 )
               end
 
               machine.create_class("PrivateAASMTransition", superclass_name: "AASM::Core::Transition") do |transition|
                 TRANSITION_CALLBACKS.each do |method|
-                  return_type = "T.untyped"
-                  return_type = "T::Boolean" if method == "guard"
+                  return_type = RBI::Type.untyped
+                  return_type = RBI::Type.boolean if method == "guard"
 
                   transition.create_method(
                     method,
                     parameters: [
                       create_block_param(
                         "block",
-                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                        type: RBI::Type.proc.bind(constant_name).params(opts: RBI::Type.untyped).void.nilable,
                       ),
                     ],
                     return_type: return_type,
diff --git a/lib/tapioca/dsl/compilers/action_controller_helpers.rb b/lib/tapioca/dsl/compilers/action_controller_helpers.rb
index 74f27876a..bed70c647 100644
--- a/lib/tapioca/dsl/compilers/action_controller_helpers.rb
+++ b/lib/tapioca/dsl/compilers/action_controller_helpers.rb
@@ -74,7 +74,7 @@ def decorate
 
           # Define the helpers method
           root.create_path(constant) do |controller|
-            controller.create_method("helpers", return_type: helper_proxy_name)
+            controller.create_method("helpers", return_type: RBI::Type.simple(helper_proxy_name))
 
             # Create helper method module
             controller.create_module(helper_methods_name) do |helper_methods|
@@ -140,11 +140,11 @@ def create_unknown_proxy_method(helper_methods, method_name)
           helper_methods.create_method(
             method_name.to_s,
             parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_kw_rest_param("kwargs", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
+              create_rest_param("args", type: RBI::Type.untyped),
+              create_kw_rest_param("kwargs", type: RBI::Type.untyped),
+              create_block_param("blk", type: RBI::Type.untyped),
             ],
-            return_type: "T.untyped",
+            return_type: RBI::Type.untyped,
           )
         end
 
diff --git a/lib/tapioca/dsl/compilers/action_mailer.rb b/lib/tapioca/dsl/compilers/action_mailer.rb
index 325d574e1..b1aac3ae4 100644
--- a/lib/tapioca/dsl/compilers/action_mailer.rb
+++ b/lib/tapioca/dsl/compilers/action_mailer.rb
@@ -41,7 +41,7 @@ def decorate
               mailer.create_method(
                 mailer_method,
                 parameters: parameters,
-                return_type: "::ActionMailer::MessageDelivery",
+                return_type: RBI::Type.simple("::ActionMailer::MessageDelivery"),
                 class_method: true,
               )
             end
diff --git a/lib/tapioca/dsl/compilers/action_text.rb b/lib/tapioca/dsl/compilers/action_text.rb
index ba7ae9def..fd76c670a 100644
--- a/lib/tapioca/dsl/compilers/action_text.rb
+++ b/lib/tapioca/dsl/compilers/action_text.rb
@@ -51,20 +51,21 @@ def decorate
           root.create_path(constant) do |scope|
             self.class.action_text_associations(constant).each do |name|
               reflection = constant.reflections.fetch(name)
-              type = reflection.options.fetch(:class_name)
+              type = RBI::Type.simple(reflection.options.fetch(:class_name))
               name = reflection.name.to_s.sub("rich_text_", "")
+
               scope.create_method(
                 name,
                 return_type: type,
               )
               scope.create_method(
                 "#{name}?",
-                return_type: "T::Boolean",
+                return_type: RBI::Type.boolean,
               )
               scope.create_method(
                 "#{name}=",
-                parameters: [create_param("value", type: "T.nilable(T.any(#{type}, String))")],
-                return_type: "T.untyped",
+                parameters: [create_param("value", type: RBI::Type.any(type, RBI::Type.simple("::String")).nilable)],
+                return_type: RBI::Type.untyped,
               )
             end
           end
diff --git a/lib/tapioca/dsl/compilers/active_job.rb b/lib/tapioca/dsl/compilers/active_job.rb
index 4cd030479..d1bfe6fba 100644
--- a/lib/tapioca/dsl/compilers/active_job.rb
+++ b/lib/tapioca/dsl/compilers/active_job.rb
@@ -54,7 +54,10 @@ def decorate
             job.create_method(
               "perform_later",
               parameters: perform_later_parameters(parameters, constant_name),
-              return_type: "T.any(#{constant_name}, FalseClass)",
+              return_type: RBI::Type.any(
+                RBI::Type.simple(T.must(qualified_name_of(constant))),
+                RBI::Type.simple("::FalseClass"),
+              ),
               class_method: true,
             )
 
@@ -75,7 +78,7 @@ def perform_later_parameters(parameters, constant_name)
             parameters.reject! { |typed_param| RBI::BlockParam === typed_param.param }
             parameters + [create_block_param(
               "block",
-              type: "T.nilable(T.proc.params(job: #{constant_name}).void)",
+              type: RBI::Type.proc.params(job: RBI::Type.simple(constant_name)).void.nilable,
             )]
           else
             parameters
diff --git a/lib/tapioca/dsl/compilers/active_model_attributes.rb b/lib/tapioca/dsl/compilers/active_model_attributes.rb
index 116e63fd9..440b542d9 100644
--- a/lib/tapioca/dsl/compilers/active_model_attributes.rb
+++ b/lib/tapioca/dsl/compilers/active_model_attributes.rb
@@ -69,7 +69,7 @@ def gather_constants
 
         HANDLED_METHOD_TARGETS = ["attribute", "attribute="] #: Array[String]
 
-        #: -> Array[[::String, ::String]]
+        #: -> Array[[::String, ::RBI::Type]]
         def attribute_methods_for_constant
           patterns = if constant.respond_to?(:attribute_method_patterns)
             # https://github.com/rails/rails/pull/44367
@@ -102,31 +102,31 @@ def handle_method_pattern?(pattern)
           HANDLED_METHOD_TARGETS.include?(target.to_s)
         end
 
-        #: (untyped attribute_type_value) -> ::String
+        #: (untyped attribute_type_value) -> ::RBI::Type
         def type_for(attribute_type_value)
           case attribute_type_value
           when ActiveModel::Type::Boolean
-            as_nilable_type("T::Boolean")
+            RBI::Type.boolean.nilable
           when ActiveModel::Type::Date
-            as_nilable_type("::Date")
+            RBI::Type.simple("::Date").nilable
           when ActiveModel::Type::DateTime, ActiveModel::Type::Time
-            as_nilable_type("::Time")
+            RBI::Type.simple("::Time").nilable
           when ActiveModel::Type::Decimal
-            as_nilable_type("::BigDecimal")
+            RBI::Type.simple("::BigDecimal").nilable
           when ActiveModel::Type::Float
-            as_nilable_type("::Float")
+            RBI::Type.simple("::Float").nilable
           when ActiveModel::Type::Integer
-            as_nilable_type("::Integer")
+            RBI::Type.simple("::Integer").nilable
           when ActiveModel::Type::String
-            as_nilable_type("::String")
+            RBI::Type.simple("::String").nilable
           else
-            type = Helpers::ActiveModelTypeHelper.type_for(attribute_type_value)
-            type = as_nilable_type(type) if Helpers::ActiveModelTypeHelper.assume_nilable?(attribute_type_value)
+            type = RBI::Type.parse_string(Helpers::ActiveModelTypeHelper.type_for(attribute_type_value))
+            type = type.nilable if Helpers::ActiveModelTypeHelper.assume_nilable?(attribute_type_value)
             type
           end
         end
 
-        #: (RBI::Scope klass, String method, String type) -> void
+        #: (RBI::Scope klass, String method, RBI::Type type) -> void
         def generate_method(klass, method, type)
           if method.end_with?("=")
             parameter = create_param("value", type: type)
diff --git a/lib/tapioca/dsl/compilers/active_model_secure_password.rb b/lib/tapioca/dsl/compilers/active_model_secure_password.rb
index 244ee8599..55f0031d9 100644
--- a/lib/tapioca/dsl/compilers/active_model_secure_password.rb
+++ b/lib/tapioca/dsl/compilers/active_model_secure_password.rb
@@ -77,8 +77,8 @@ def decorate
               if method == :authenticate || method.start_with?("authenticate_")
                 klass.create_method(
                   method.to_s,
-                  parameters: [create_param("unencrypted_password", type: "T.untyped")],
-                  return_type: "T.any(#{constant}, FalseClass)",
+                  parameters: [create_param("unencrypted_password", type: RBI::Type.untyped)],
+                  return_type: RBI::Type.any(RBI::Type.simple(T.must(qualified_name_of(constant))), RBI::Type.boolean),
                 )
               else
                 create_method_from_def(klass, constant.instance_method(method))
diff --git a/lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb b/lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb
index 48578617e..379940ffa 100644
--- a/lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb
+++ b/lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb
@@ -63,11 +63,11 @@ def decorate
             # Create RBI definitions for all the attributes that use confirmation validation
             confirmation_validators.each do |validator|
               validator.attributes.each do |attr_name|
-                klass.create_method("#{attr_name}_confirmation", return_type: "T.untyped")
+                klass.create_method("#{attr_name}_confirmation", return_type: RBI::Type.untyped)
                 klass.create_method(
                   "#{attr_name}_confirmation=",
-                  parameters: [create_param("#{attr_name}_confirmation", type: "T.untyped")],
-                  return_type: "T.untyped",
+                  parameters: [create_param("#{attr_name}_confirmation", type: RBI::Type.untyped)],
+                  return_type: RBI::Type.untyped,
                 )
               end
             end
diff --git a/lib/tapioca/dsl/compilers/active_record_associations.rb b/lib/tapioca/dsl/compilers/active_record_associations.rb
index e50a3bc85..bb5561f1f 100644
--- a/lib/tapioca/dsl/compilers/active_record_associations.rb
+++ b/lib/tapioca/dsl/compilers/active_record_associations.rb
@@ -149,8 +149,8 @@ def populate_nested_attribute_writers(mod)
           constant.nested_attributes_options.keys.each do |association_name|
             mod.create_method(
               "#{association_name}_attributes=",
-              parameters: [create_param("attributes", type: "T.untyped")],
-              return_type: "T.untyped",
+              parameters: [create_param("attributes", type: RBI::Type.untyped)],
+              return_type: RBI::Type.untyped,
             )
           end
         end
@@ -177,7 +177,7 @@ def populate_associations(mod)
         #: (RBI::Scope klass, (String | Symbol) association_name, ReflectionType reflection) -> void
         def populate_single_assoc_getter_setter(klass, association_name, reflection)
           association_class = type_for(reflection)
-          association_type = as_nilable_type(association_class)
+          association_type = association_class.nilable
           association_methods_module = constant.generated_association_methods
 
           klass.create_method(
@@ -187,7 +187,7 @@ def populate_single_assoc_getter_setter(klass, association_name, reflection)
           klass.create_method(
             "#{association_name}=",
             parameters: [create_param("value", type: association_type)],
-            return_type: "void",
+            return_type: RBI::Type.void,
           )
           klass.create_method(
             "reload_#{association_name}",
@@ -195,42 +195,42 @@ def populate_single_assoc_getter_setter(klass, association_name, reflection)
           )
           klass.create_method(
             "reset_#{association_name}",
-            return_type: "void",
+            return_type: RBI::Type.void,
           )
           if association_methods_module.method_defined?("#{association_name}_changed?")
             klass.create_method(
               "#{association_name}_changed?",
-              return_type: "T::Boolean",
+              return_type: RBI::Type.boolean,
             )
           end
           if association_methods_module.method_defined?("#{association_name}_previously_changed?")
             klass.create_method(
               "#{association_name}_previously_changed?",
-              return_type: "T::Boolean",
+              return_type: RBI::Type.boolean,
             )
           end
           unless reflection.polymorphic?
             klass.create_method(
               "build_#{association_name}",
               parameters: [
-                create_rest_param("args", type: "T.untyped"),
-                create_block_param("blk", type: "T.untyped"),
+                create_rest_param("args", type: RBI::Type.untyped),
+                create_block_param("blk", type: RBI::Type.untyped),
               ],
               return_type: association_class,
             )
             klass.create_method(
               "create_#{association_name}",
               parameters: [
-                create_rest_param("args", type: "T.untyped"),
-                create_block_param("blk", type: "T.untyped"),
+                create_rest_param("args", type: RBI::Type.untyped),
+                create_block_param("blk", type: RBI::Type.untyped),
               ],
               return_type: association_class,
             )
             klass.create_method(
               "create_#{association_name}!",
               parameters: [
-                create_rest_param("args", type: "T.untyped"),
-                create_block_param("blk", type: "T.untyped"),
+                create_rest_param("args", type: RBI::Type.untyped),
+                create_block_param("blk", type: RBI::Type.untyped),
               ],
               return_type: association_class,
             )
@@ -249,27 +249,27 @@ def populate_collection_assoc_getter_setter(klass, association_name, reflection)
           )
           klass.create_method(
             "#{association_name}=",
-            parameters: [create_param("value", type: "T::Enumerable[#{association_class}]")],
-            return_type: "void",
+            parameters: [create_param("value", type: RBI::Type.generic("T::Enumerable", association_class))],
+            return_type: RBI::Type.void,
           )
           klass.create_method(
             "#{association_name.to_s.singularize}_ids",
-            return_type: "T::Array[T.untyped]",
+            return_type: RBI::Type.generic("T::Array", RBI::Type.untyped),
           )
           klass.create_method(
             "#{association_name.to_s.singularize}_ids=",
-            parameters: [create_param("ids", type: "T::Array[T.untyped]")],
-            return_type: "T::Array[T.untyped]",
+            parameters: [create_param("ids", type: RBI::Type.generic("T::Array", RBI::Type.untyped))],
+            return_type: RBI::Type.generic("T::Array", RBI::Type.untyped),
           )
         end
 
-        #: (ReflectionType reflection) -> String
+        #: (ReflectionType reflection) -> RBI::Type
         def type_for(reflection)
           validate_reflection!(reflection)
 
-          return "T.untyped" if !constant.table_exists? || polymorphic_association?(reflection)
+          return RBI::Type.untyped if !constant.table_exists? || polymorphic_association?(reflection)
 
-          T.must(qualified_name_of(reflection.klass))
+          RBI::Type.simple(T.must(qualified_name_of(reflection.klass)))
         end
 
         #: (ReflectionType reflection) -> void
@@ -350,7 +350,7 @@ def association_comments(reflection)
           end
         end
 
-        #: (ReflectionType reflection) -> String
+        #: (ReflectionType reflection) -> RBI::Type
         def relation_type_for(reflection)
           validate_reflection!(reflection)
 
@@ -359,14 +359,17 @@ def relation_type_for(reflection)
 
           if relations_enabled
             if polymorphic_association
-              "ActiveRecord::Associations::CollectionProxy"
+              RBI::Type.simple("::ActiveRecord::Associations::CollectionProxy")
             else
-              "#{qualified_name_of(reflection.klass)}::#{AssociationsCollectionProxyClassName}"
+              RBI::Type.simple("#{qualified_name_of(reflection.klass)}::#{AssociationsCollectionProxyClassName}")
             end
           elsif polymorphic_association
-            "ActiveRecord::Associations::CollectionProxy[T.untyped]"
+            RBI::Type.generic("::ActiveRecord::Associations::CollectionProxy", RBI::Type.untyped)
           else
-            "::ActiveRecord::Associations::CollectionProxy[#{qualified_name_of(reflection.klass)}]"
+            RBI::Type.generic(
+              "::ActiveRecord::Associations::CollectionProxy",
+              RBI::Type.simple(T.must(qualified_name_of(reflection.klass))),
+            )
           end
         end
 
diff --git a/lib/tapioca/dsl/compilers/active_record_columns.rb b/lib/tapioca/dsl/compilers/active_record_columns.rb
index 4ca072f73..af15c5fdb 100644
--- a/lib/tapioca/dsl/compilers/active_record_columns.rb
+++ b/lib/tapioca/dsl/compilers/active_record_columns.rb
@@ -190,10 +190,10 @@ def column_type_option
         #|   RBI::Scope klass,
         #|   String name,
         #|   Array[String]? methods_to_add,
-        #|   ?return_type: String,
+        #|   ?return_type: RBI::Type,
         #|   ?parameters: Array[RBI::TypedParam]
         #| ) -> void
-        def add_method(klass, name, methods_to_add, return_type: "void", parameters: [])
+        def add_method(klass, name, methods_to_add, return_type: RBI::Type.void, parameters: [])
           klass.create_method(
             name,
             parameters: parameters,
@@ -232,7 +232,7 @@ def add_methods_for_attribute(klass, attribute_name, column_name = attribute_nam
             klass,
             "#{attribute_name}?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
           )
 
           # Added by ActiveRecord::AttributeMethods::Dirty
@@ -241,44 +241,44 @@ def add_methods_for_attribute(klass, attribute_name, column_name = attribute_nam
             klass,
             "#{attribute_name}_before_last_save",
             methods_to_add,
-            return_type: as_nilable_type(getter_type),
+            return_type: getter_type.nilable,
           )
           add_method(
             klass,
             "#{attribute_name}_change_to_be_saved",
             methods_to_add,
-            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+            return_type: RBI::Type.tuple(getter_type, getter_type).nilable,
           )
           add_method(
             klass,
             "#{attribute_name}_in_database",
             methods_to_add,
-            return_type: as_nilable_type(getter_type),
+            return_type: getter_type.nilable,
           )
           add_method(
             klass,
             "saved_change_to_#{attribute_name}",
             methods_to_add,
-            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+            return_type: RBI::Type.tuple(getter_type, getter_type).nilable,
           )
           add_method(
             klass,
             "saved_change_to_#{attribute_name}?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
             parameters: [
-              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
             ],
           )
           add_method(
             klass,
             "will_save_change_to_#{attribute_name}?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
             parameters: [
-              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
             ],
           )
 
@@ -288,16 +288,16 @@ def add_methods_for_attribute(klass, attribute_name, column_name = attribute_nam
             klass,
             "#{attribute_name}_change",
             methods_to_add,
-            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+            return_type: RBI::Type.tuple(getter_type, getter_type).nilable,
           )
           add_method(
             klass,
             "#{attribute_name}_changed?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
             parameters: [
-              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
             ],
           )
           add_method(
@@ -309,29 +309,29 @@ def add_methods_for_attribute(klass, attribute_name, column_name = attribute_nam
             klass,
             "#{attribute_name}_was",
             methods_to_add,
-            return_type: as_nilable_type(getter_type),
+            return_type: getter_type.nilable,
           )
           add_method(
             klass,
             "#{attribute_name}_previous_change",
             methods_to_add,
-            return_type: "T.nilable([#{getter_type}, #{getter_type}])",
+            return_type: RBI::Type.tuple(getter_type, getter_type).nilable,
           )
           add_method(
             klass,
             "#{attribute_name}_previously_changed?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
             parameters: [
-              create_kw_opt_param("from", type: "T.untyped", default: "T.unsafe(nil)"),
-              create_kw_opt_param("to", type: "T.untyped", default: "T.unsafe(nil)"),
+              create_kw_opt_param("from", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
+              create_kw_opt_param("to", type: RBI::Type.untyped, default: "T.unsafe(nil)"),
             ],
           )
           add_method(
             klass,
             "#{attribute_name}_previously_was",
             methods_to_add,
-            return_type: as_nilable_type(getter_type),
+            return_type: getter_type.nilable,
           )
           add_method(
             klass,
@@ -345,13 +345,13 @@ def add_methods_for_attribute(klass, attribute_name, column_name = attribute_nam
             klass,
             "#{attribute_name}_before_type_cast",
             methods_to_add,
-            return_type: "T.untyped",
+            return_type: RBI::Type.untyped,
           )
           add_method(
             klass,
             "#{attribute_name}_came_from_user?",
             methods_to_add,
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
           )
         end
       end
diff --git a/lib/tapioca/dsl/compilers/active_record_delegated_types.rb b/lib/tapioca/dsl/compilers/active_record_delegated_types.rb
index 30de629e8..010acba13 100644
--- a/lib/tapioca/dsl/compilers/active_record_delegated_types.rb
+++ b/lib/tapioca/dsl/compilers/active_record_delegated_types.rb
@@ -101,19 +101,23 @@ def populate_role_accessors(mod, role, types)
           mod.create_method(
             "#{role}_name",
             parameters: [],
-            return_type: "ActiveSupport::StringInquirer",
+            return_type: RBI::Type.simple("ActiveSupport::StringInquirer"),
           )
 
           mod.create_method(
             "#{role}_class",
             parameters: [],
-            return_type: "T::Class[T.anything]",
+            return_type: RBI::Type.t_class(RBI::Type.anything),
           )
 
           mod.create_method(
             "build_#{role}",
-            parameters: [create_rest_param("args", type: "T.untyped")],
-            return_type: types.size == 1 ? types.first : "T.any(#{types.join(", ")})",
+            parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+            return_type: if types.size == 1
+              RBI::Type.simple(types.first)
+            else
+              RBI::Type.any(*types.map { |type| RBI::Type.simple(type) })
+            end,
           )
         end
 
@@ -136,19 +140,19 @@ def populate_type_helper(mod, role, type, options)
           mod.create_method(
             query,
             parameters: [],
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
           )
 
           mod.create_method(
             singular,
             parameters: [],
-            return_type: "T.nilable(#{type})",
+            return_type: RBI::Type.simple(type).nilable,
           )
 
           mod.create_method(
             "#{singular}_#{primary_key}",
             parameters: [],
-            return_type: as_nilable_type(getter_type),
+            return_type: getter_type.nilable,
           )
         end
       end
diff --git a/lib/tapioca/dsl/compilers/active_record_enum.rb b/lib/tapioca/dsl/compilers/active_record_enum.rb
index 60bf2813b..d3e20b3be 100644
--- a/lib/tapioca/dsl/compilers/active_record_enum.rb
+++ b/lib/tapioca/dsl/compilers/active_record_enum.rb
@@ -82,16 +82,20 @@ def gather_constants
 
         private
 
-        #: (Hash[untyped, untyped] enum_map) -> String
+        #: (Hash[untyped, untyped] enum_map) -> RBI::Type
         def type_for_enum(enum_map)
-          value_type = enum_map.values.map { |v| v.class.name }.uniq
-          value_type = if value_type.length == 1
-            value_type.first
+          value_type = enum_map.values.map { |v| RBI::Type.simple(T.must(qualified_name_of(v.class))) }
+          value_type = if value_type.size > 1
+            RBI::Type.any(*value_type)
           else
-            "T.any(#{value_type.join(", ")})"
+            value_type.first
           end
 
-          "T::Hash[T.any(String, Symbol), #{value_type}]"
+          RBI::Type.generic(
+            "T::Hash",
+            RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+            value_type,
+          )
         end
 
         #: (RBI::Scope klass) -> void
@@ -100,7 +104,7 @@ def generate_instance_methods(klass)
 
           methods.each do |method|
             method = method.to_s
-            return_type = method.end_with?("?") ? "T::Boolean" : "void"
+            return_type = method.end_with?("?") ? RBI::Type.boolean : RBI::Type.void
 
             klass.create_method(method, return_type: return_type)
           end
diff --git a/lib/tapioca/dsl/compilers/active_record_fixtures.rb b/lib/tapioca/dsl/compilers/active_record_fixtures.rb
index fbb8e01e8..7c10b031c 100644
--- a/lib/tapioca/dsl/compilers/active_record_fixtures.rb
+++ b/lib/tapioca/dsl/compilers/active_record_fixtures.rb
@@ -35,18 +35,9 @@ module Compilers
       # ~~~
       #: [ConstantType = singleton(ActiveSupport::TestCase)]
       class ActiveRecordFixtures < Compiler
-        MISSING = Object.new
-
         # @override
         #: -> void
         def decorate
-          method_names = if fixture_loader.respond_to?(:fixture_sets)
-            method_names_from_lazy_fixture_loader
-          else
-            method_names_from_eager_fixture_loader
-          end
-
-          method_names.select! { |name| fixture_class_mapping_from_fixture_files[name] != MISSING }
           return if method_names.empty?
 
           root.create_path(constant) do |mod|
@@ -88,6 +79,29 @@ def fixture_loader
           end #: Class[ActiveRecord::TestFixtures]?
         end
 
+        #: -> Array[String]
+        def method_names
+          @method_names ||= begin
+            method_names = if fixture_loader.respond_to?(:fixture_sets)
+              method_names_from_lazy_fixture_loader
+            else
+              method_names_from_eager_fixture_loader
+            end
+
+            method_names.select! { |method_name| should_include_method_name?(method_name) }
+
+            method_names
+          end #: Array[String]?
+        end
+
+        #: (String method_name) -> top
+        def should_include_method_name?(method_name)
+          # For the method name to be included, it must either be:
+          # - missing from the fixture class mapping, which means we will find it a different way, or
+          # - the mapping must not be nil, which means we found it in the fixture files without errors
+          !fixture_class_mapping_from_fixture_files.key?(method_name) || fixture_class_mapping_from_fixture_files[method_name]
+        end
+
         #: -> Array[String]
         def method_names_from_lazy_fixture_loader
           T.unsafe(fixture_loader).fixture_sets.keys
@@ -111,34 +125,34 @@ def create_fixture_method(mod, name)
             node.add_rest_param("other_fixtures")
 
             node.add_sig do |sig|
-              sig.add_param("fixture_name", "NilClass")
-              sig.add_param("other_fixtures", "NilClass")
-              sig.return_type = "T::Array[#{return_type}]"
+              sig.add_param("fixture_name", RBI::Type.simple("::NilClass"))
+              sig.add_param("other_fixtures", RBI::Type.simple("::NilClass"))
+              sig.return_type = RBI::Type.generic("T::Array", return_type)
             end
 
             node.add_sig do |sig|
-              sig.add_param("fixture_name", "T.any(String, Symbol)")
-              sig.add_param("other_fixtures", "NilClass")
+              sig.add_param("fixture_name", RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")))
+              sig.add_param("other_fixtures", RBI::Type.simple("::NilClass"))
               sig.return_type = return_type
             end
 
             node.add_sig do |sig|
-              sig.add_param("fixture_name", "T.any(String, Symbol)")
-              sig.add_param("other_fixtures", "T.any(String, Symbol)")
-              sig.return_type = "T::Array[#{return_type}]"
+              sig.add_param("fixture_name", RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")))
+              sig.add_param("other_fixtures", RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")))
+              sig.return_type = RBI::Type.generic("T::Array", return_type)
             end
           end
         end
 
-        #: (String fixture_name) -> String
+        #: (String fixture_name) -> RBI::Type
         def return_type_for_fixture(fixture_name)
           fixture_class_mapping_from_fixture_files[fixture_name] ||
             fixture_class_from_fixture_set(fixture_name) ||
             fixture_class_from_active_record_base_class_mapping[fixture_name] ||
-            "T.untyped"
+            RBI::Type.untyped
         end
 
-        #: (String fixture_name) -> String?
+        #: (String fixture_name) -> RBI::Type?
         def fixture_class_from_fixture_set(fixture_name)
           # only rails 7.1+ support fixture sets so this is conditional
           return unless fixture_loader.respond_to?(:fixture_sets)
@@ -149,10 +163,10 @@ def fixture_class_from_fixture_set(fixture_name)
           model_name = ActiveRecord::FixtureSet.default_fixture_model_name(model_name_from_fixture_set)
           return unless Object.const_defined?(model_name)
 
-          model_name
+          RBI::Type.simple(model_name)
         end
 
-        #: -> Hash[String, String]
+        #: -> Hash[String, RBI::Type]
         def fixture_class_from_active_record_base_class_mapping
           @fixture_class_mapping ||=
             ActiveRecord::Base.descendants.each_with_object({}) do |model_class, mapping|
@@ -161,13 +175,13 @@ def fixture_class_from_active_record_base_class_mapping
               fixture_name = class_name.underscore.gsub("/", "_")
               fixture_name = fixture_name.pluralize if ActiveRecord::Base.pluralize_table_names
 
-              mapping[fixture_name] = class_name
+              mapping[fixture_name] = RBI::Type.simple(class_name)
 
               mapping
-            end #: Hash[String, String]?
+            end #: Hash[String, RBI::Type]?
         end
 
-        #: -> Hash[String, String]
+        #: -> Hash[String, RBI::Type]
         def fixture_class_mapping_from_fixture_files
           @fixture_file_class_mapping ||= begin
             fixture_paths = if T.unsafe(fixture_loader).respond_to?(:fixture_paths)
@@ -184,15 +198,15 @@ def fixture_class_mapping_from_fixture_files
                   fixture_name = file.delete_prefix(path.to_s).delete_prefix("/").delete_suffix(".yml")
                   next unless fh.model_class
 
-                  mapping[fixture_name] = fh.model_class
+                  mapping[fixture_name] = RBI::Type.simple(fh.model_class)
                 rescue ActiveRecord::Fixture::FormatError
                   # For fixtures that are not associated to any models and just contain raw data or fixtures that
                   # contain invalid formatting, we want to skip them and avoid crashing
-                  mapping[fixture_name] = MISSING
+                  mapping[fixture_name] = nil
                 end
               end
             end
-          end #: Hash[String, String]?
+          end #: Hash[String, RBI::Type?]?
         end
       end
     end
diff --git a/lib/tapioca/dsl/compilers/active_record_relations.rb b/lib/tapioca/dsl/compilers/active_record_relations.rb
index b5674fbd9..d67103709 100644
--- a/lib/tapioca/dsl/compilers/active_record_relations.rb
+++ b/lib/tapioca/dsl/compilers/active_record_relations.rb
@@ -156,19 +156,19 @@ class ActiveRecordRelations < Compiler
 
         # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
         ID_TYPES = [
-          "String",
-          "Symbol",
-          "::ActiveSupport::Multibyte::Chars",
-          "T::Boolean",
-          "BigDecimal",
-          "Numeric",
-          "::ActiveRecord::Type::Binary::Data",
-          "::ActiveRecord::Type::Time::Value",
-          "Date",
-          "Time",
-          "::ActiveSupport::Duration",
-          "T::Class[T.anything]",
-        ].to_set.freeze #: Set[String]
+          RBI::Type.simple("::String"),
+          RBI::Type.simple("::Symbol"),
+          RBI::Type.simple("::ActiveSupport::Multibyte::Chars"),
+          RBI::Type.boolean,
+          RBI::Type.simple("::BigDecimal"),
+          RBI::Type.simple("::Numeric"),
+          RBI::Type.simple("::ActiveRecord::Type::Binary::Data"),
+          RBI::Type.simple("::ActiveRecord::Type::Time::Value"),
+          RBI::Type.simple("::Date"),
+          RBI::Type.simple("::Time")  ,
+          RBI::Type.simple("::ActiveSupport::Duration"),
+          RBI::Type.t_class(RBI::Type.anything),
+        ].to_set.freeze #: Set[RBI::Type]
 
         # @override
         #: -> void
@@ -215,16 +215,16 @@ def gather_constants
         end #: Array[Symbol]
         BATCHES_METHODS = ActiveRecord::Batches.instance_methods(false) #: Array[Symbol]
         BATCHES_METHODS_PARAMETERS = {
-          start: ["T.untyped", "nil"],
-          finish: ["T.untyped", "nil"],
-          load: ["T.untyped", "false"],
-          batch_size: ["Integer", "1000"],
-          of: ["Integer", "1000"],
-          error_on_ignore: ["T.untyped", "nil"],
-          order: ["T.any(Symbol, T::Array[Symbol])", ":asc"],
-          cursor: ["T.untyped", "primary_key"],
-          use_ranges: ["T.untyped", "nil"],
-        } #: Hash[Symbol, [String, String]]
+          start: [RBI::Type.untyped, "nil"],
+          finish: [RBI::Type.untyped, "nil"],
+          load: [RBI::Type.untyped, "false"],
+          batch_size: [RBI::Type.simple("::Integer"), "1000"],
+          of: [RBI::Type.simple("::Integer"), "1000"],
+          error_on_ignore: [RBI::Type.untyped, "nil"],
+          order: [RBI::Type.any(RBI::Type.simple("::Symbol"), RBI::Type.generic("T::Array", RBI::Type.simple("::Symbol"))), ":asc"],
+          cursor: [RBI::Type.untyped, "primary_key"],
+          use_ranges: [RBI::Type.untyped, "nil"],
+        } #: Hash[Symbol, [RBI::Type, String]]
         CALCULATION_METHODS = ActiveRecord::Calculations.instance_methods(false) #: Array[Symbol]
         RELATION_METHODS = ActiveRecord::Relation.instance_methods(false) #: Array[Symbol]
         TO_ARRAY_METHODS = [:to_ary, :to_a] #: Array[Symbol]
@@ -270,7 +270,7 @@ def create_classes_and_includes
 
           # Type the `to_ary` method as returning `NilClass` so that flatten stops recursing
           # See https://github.com/sorbet/sorbet/pull/4706 for details
-          model.create_method("to_ary", return_type: "NilClass", visibility: RBI::Private.new)
+          model.create_method("to_ary", return_type: RBI::Type.simple("NilClass"), visibility: RBI::Private.new)
 
           create_relation_class
           create_association_relation_class
@@ -285,10 +285,10 @@ def create_relation_class
           model.create_class(RelationClassName, superclass_name: superclass) do |klass|
             klass.create_include(CommonRelationMethodsModuleName)
             klass.create_include(RelationMethodsModuleName)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
 
             TO_ARRAY_METHODS.each do |method_name|
-              klass.create_method(method_name.to_s, return_type: "T::Array[#{constant_name}]")
+              klass.create_method(method_name.to_s, return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)))
             end
           end
 
@@ -304,10 +304,10 @@ def create_association_relation_class
           model.create_class(AssociationRelationClassName, superclass_name: superclass) do |klass|
             klass.create_include(CommonRelationMethodsModuleName)
             klass.create_include(AssociationRelationMethodsModuleName)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
 
             TO_ARRAY_METHODS.each do |method_name|
-              klass.create_method(method_name.to_s, return_type: "T::Array[#{constant_name}]")
+              klass.create_method(method_name.to_s, return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)))
             end
           end
 
@@ -319,7 +319,7 @@ def create_association_relation_class
         def create_relation_group_chain_class
           model.create_class(RelationGroupChainClassName, superclass_name: RelationClassName) do |klass|
             create_group_chain_methods(klass)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
           end
         end
 
@@ -330,7 +330,7 @@ def create_association_relation_group_chain_class
             superclass_name: AssociationRelationClassName,
           ) do |klass|
             create_group_chain_methods(klass)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
           end
         end
 
@@ -346,15 +346,15 @@ def create_group_chain_methods(klass)
           klass.create_method(
             "having",
             parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
+              create_rest_param("args", type: RBI::Type.untyped),
+              create_block_param("blk", type: RBI::Type.untyped),
             ],
-            return_type: "T.self_type",
+            return_type: RBI::Type.self_type,
           )
 
           klass.create_method(
             "size",
-            return_type: "T::Hash[T.untyped, Integer]",
+            return_type: RBI::Type.generic("T::Hash", RBI::Type.untyped, RBI::Type.simple("::Integer")),
           )
 
           CALCULATION_METHODS.each do |method_name|
@@ -363,36 +363,43 @@ def create_group_chain_methods(klass)
               klass.create_method(
                 method_name.to_s,
                 parameters: [
-                  create_param("column_name", type: "T.any(String, Symbol)"),
+                  create_param("column_name", type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol"))),
                 ],
-                return_type: "T::Hash[T.untyped, " \
-                  "#{method_name == :average ? "T.any(Integer, Float, BigDecimal)" : "T.untyped"}]",
+                return_type: RBI::Type.generic(
+                  "T::Hash",
+                  RBI::Type.untyped,
+                  if method_name == :average
+                    RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal"))
+                  else
+                    RBI::Type.untyped
+                  end
+                )
               )
             when :calculate
               klass.create_method(
                 "calculate",
                 parameters: [
-                  create_param("operation", type: "Symbol"),
-                  create_param("column_name", type: "T.any(String, Symbol)"),
+                  create_param("operation", type: RBI::Type.simple("::Symbol")),
+                  create_param("column_name", type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol"))),
                 ],
-                return_type: "T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]",
+                return_type: RBI::Type.generic("T::Hash", RBI::Type.untyped, RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal"))),
               )
             when :count
               klass.create_method(
                 "count",
                 parameters: [
-                  create_opt_param("column_name", type: "T.untyped", default: "nil"),
+                  create_opt_param("column_name", type: RBI::Type.untyped, default: "nil"),
                 ],
-                return_type: "T::Hash[T.untyped, Integer]",
+                return_type: RBI::Type.generic("T::Hash", RBI::Type.untyped, RBI::Type.simple("::Integer")),
               )
             when :sum
               klass.create_method(
                 "sum",
                 parameters: [
-                  create_opt_param("column_name", type: "T.nilable(T.any(String, Symbol))", default: "nil"),
-                  create_block_param("block", type: "T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))"),
+                  create_opt_param("column_name", type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")).nilable, default: "nil"),
+                  create_block_param("block", type: RBI::Type.proc.params(record: RBI::Type.untyped).returns(RBI::Type.untyped).nilable),
                 ],
-                return_type: "T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]",
+                return_type: RBI::Type.generic("T::Hash", RBI::Type.untyped, RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal"))),
               )
             end
           end
@@ -401,20 +408,20 @@ def create_group_chain_methods(klass)
         #: -> void
         def create_relation_where_chain_class
           model.create_class(RelationWhereChainClassName) do |klass|
-            create_where_chain_methods(klass, RelationClassName)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            create_where_chain_methods(klass, RBI::Type.simple(RelationClassName))
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
           end
         end
 
         #: -> void
         def create_association_relation_where_chain_class
           model.create_class(AssociationRelationWhereChainClassName) do |klass|
-            create_where_chain_methods(klass, AssociationRelationClassName)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            create_where_chain_methods(klass, RBI::Type.simple(AssociationRelationClassName))
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
           end
         end
 
-        #: (RBI::Scope klass, String return_type) -> void
+        #: (RBI::Scope klass, RBI::Type return_type) -> void
         def create_where_chain_methods(klass, return_type)
           WHERE_CHAIN_QUERY_METHODS.each do |method_name|
             case method_name
@@ -422,8 +429,8 @@ def create_where_chain_methods(klass, return_type)
               klass.create_method(
                 method_name.to_s,
                 parameters: [
-                  create_param("opts", type: "T.untyped"),
-                  create_rest_param("rest", type: "T.untyped"),
+                  create_param("opts", type: RBI::Type.untyped),
+                  create_rest_param("rest", type: RBI::Type.untyped),
                 ],
                 return_type: return_type,
               )
@@ -431,7 +438,7 @@ def create_where_chain_methods(klass, return_type)
               klass.create_method(
                 method_name.to_s,
                 parameters: [
-                  create_rest_param("args", type: "T.untyped"),
+                  create_rest_param("args", type: RBI::Type.untyped),
                 ],
                 return_type: return_type,
               )
@@ -447,10 +454,10 @@ def create_collection_proxy_class
           model.create_class(AssociationsCollectionProxyClassName, superclass_name: superclass) do |klass|
             klass.create_include(CommonRelationMethodsModuleName)
             klass.create_include(AssociationRelationMethodsModuleName)
-            klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
+            klass.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.simple(constant_name))
 
             TO_ARRAY_METHODS.each do |method_name|
-              klass.create_method(method_name.to_s, return_type: "T::Array[#{constant_name}]")
+              klass.create_method(method_name.to_s, return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)))
             end
             create_collection_proxy_methods(klass)
           end
@@ -468,8 +475,13 @@ def create_collection_proxy_methods(klass)
           #   - or, any mix of the above, thus `T::Enumerable[T.any(Model, T::Enumerable[Model])]`
           # which altogether gives us:
           #   `T.any(Model, T::Enumerable[T.any(Model, T::Enumerable[Model])])`
-          model_collection =
-            "T.any(#{constant_name}, T::Enumerable[T.any(#{constant_name}, T::Enumerable[#{constant_name}])])"
+          model_collection = RBI::Type.any(
+            RBI::Type.simple(constant_name),
+            RBI::Type.generic("T::Enumerable", RBI::Type.any(
+              RBI::Type.simple(constant_name),
+              RBI::Type.generic("T::Enumerable", RBI::Type.simple(constant_name)),
+            )),
+          )
 
           # For these cases, it is valid to pass the above kind of things, but also:
           # - a model identifier, which can be:
@@ -479,9 +491,17 @@ def create_collection_proxy_methods(klass)
           #   - a collection of identifiers, thus `T::Enumerable[T.any(Integer, String)]`
           # which, coupled with the above case, gives us:
           #   `T.any(Model, Integer, String, T::Enumerable[T.any(Model, Integer, String, T::Enumerable[Model])])`
-          model_or_id_collection =
-            "T.any(#{constant_name}, Integer, String" \
-              ", T::Enumerable[T.any(#{constant_name}, Integer, String, T::Enumerable[#{constant_name}])])"
+          model_or_id_collection = RBI::Type.any(
+            RBI::Type.simple(constant_name),
+            RBI::Type.simple("Integer"),
+            RBI::Type.simple("String"),
+            RBI::Type.generic("T::Enumerable", RBI::Type.any(
+              RBI::Type.simple(constant_name),
+              RBI::Type.simple("Integer"),
+              RBI::Type.simple("String"),
+              RBI::Type.generic("T::Enumerable", RBI::Type.simple(constant_name)),
+            )),
+          )
 
           COLLECTION_PROXY_METHODS.each do |method_name|
             case method_name
@@ -491,12 +511,12 @@ def create_collection_proxy_methods(klass)
                 parameters: [
                   create_rest_param("records", type: model_collection),
                 ],
-                return_type: AssociationsCollectionProxyClassName,
+                return_type: RBI::Type.simple(AssociationsCollectionProxyClassName),
               )
             when :clear
               klass.create_method(
                 method_name.to_s,
-                return_type: AssociationsCollectionProxyClassName,
+                return_type: RBI::Type.simple(AssociationsCollectionProxyClassName),
               )
             when :delete, :destroy
               klass.create_method(
@@ -504,12 +524,12 @@ def create_collection_proxy_methods(klass)
                 parameters: [
                   create_rest_param("records", type: model_or_id_collection),
                 ],
-                return_type: "T::Array[#{constant_name}]",
+                return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)),
               )
             when :load_target
               klass.create_method(
                 method_name.to_s,
-                return_type: "T::Array[#{constant_name}]",
+                return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)),
               )
             when :replace
               klass.create_method(
@@ -517,19 +537,19 @@ def create_collection_proxy_methods(klass)
                 parameters: [
                   create_param("other_array", type: model_collection),
                 ],
-                return_type: "T::Array[#{constant_name}]",
+                return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)),
               )
             when :reset_scope
               # skip
             when :scope
               klass.create_method(
                 method_name.to_s,
-                return_type: AssociationRelationClassName,
+                return_type: RBI::Type.simple(AssociationRelationClassName),
               )
             when :target
               klass.create_method(
                 method_name.to_s,
-                return_type: "T::Array[#{constant_name}]",
+                return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)),
               )
             end
           end
@@ -548,20 +568,20 @@ def create_relation_methods
               create_relation_method(
                 "group",
                 parameters: [
-                  create_rest_param("args", type: "T.untyped"),
-                  create_block_param("blk", type: "T.untyped"),
+                  create_rest_param("args", type: RBI::Type.untyped),
+                  create_block_param("blk", type: RBI::Type.untyped),
                 ],
-                relation_return_type: RelationGroupChainClassName,
-                association_return_type: AssociationRelationGroupChainClassName,
+                relation_return_type: RBI::Type.simple(RelationGroupChainClassName),
+                association_return_type: RBI::Type.simple(AssociationRelationGroupChainClassName),
               )
             when :distinct
               create_relation_method(
                 method_name.to_s,
-                parameters: [create_opt_param("value", type: "T::Boolean", default: "true")],
+                parameters: [create_opt_param("value", type: RBI::Type.boolean, default: "true")],
               )
             when :extract_associated
-              parameters = [create_param("association", type: "Symbol")]
-              return_type = "T::Array[T.untyped]"
+              parameters = [create_param("association", type: RBI::Type.simple("::Symbol"))]
+              return_type = RBI::Type.generic("T::Array", RBI::Type.untyped)
               relation_methods_module.create_method(
                 method_name.to_s,
                 parameters: parameters,
@@ -579,12 +599,16 @@ def create_relation_methods
                   method.add_block_param("blk")
 
                   method.add_sig do |sig|
-                    sig.add_param("args", "T.untyped")
-                    sig.return_type = mod == relation_methods_module ? RelationClassName : AssociationRelationClassName
+                    sig.add_param("args", RBI::Type.untyped)
+                    sig.return_type = if mod == relation_methods_module
+                      RBI::Type.simple(RelationClassName)
+                    else
+                      RBI::Type.simple(AssociationRelationClassName)
+                    end
                   end
                   method.add_sig do |sig|
-                    sig.add_param("blk", "T.proc.params(record: #{constant_name}).returns(BasicObject)")
-                    sig.return_type = "T::Array[#{constant_name}]"
+                    sig.add_param("blk", RBI::Type.proc.params(record: RBI::Type.simple(constant_name)).returns(RBI::Type.simple("::BasicObject")))
+                    sig.return_type = RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
                   end
                 end
               end
@@ -592,8 +616,8 @@ def create_relation_methods
               create_relation_method(
                 method_name,
                 parameters: [
-                  create_rest_param("args", type: "T.untyped"),
-                  create_block_param("blk", type: "T.untyped"),
+                  create_rest_param("args", type: RBI::Type.untyped),
+                  create_block_param("blk", type: RBI::Type.untyped),
                 ],
               )
             end
@@ -611,7 +635,7 @@ def create_association_relation_methods
         def create_common_methods
           create_common_method(
             "destroy_all",
-            return_type: "T::Array[#{constant_name}]",
+            return_type: RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)),
           )
 
           FINDER_METHODS.each do |method_name|
@@ -620,17 +644,17 @@ def create_common_methods
               create_common_method(
                 "exists?",
                 parameters: [
-                  create_opt_param("conditions", type: "T.untyped", default: ":none"),
+                  create_opt_param("conditions", type: RBI::Type.untyped, default: ":none"),
                 ],
-                return_type: "T::Boolean",
+                return_type: RBI::Type.boolean,
               )
             when :include?, :member?
               create_common_method(
                 method_name,
                 parameters: [
-                  create_param("record", type: "T.untyped"),
+                  create_param("record", type: RBI::Type.untyped),
                 ],
-                return_type: "T::Boolean",
+                return_type: RBI::Type.boolean,
               )
             when :find
               id_types = ID_TYPES
@@ -638,17 +662,17 @@ def create_common_methods
               if constant.table_exists?
                 primary_key_type = constant.type_for_attribute(constant.primary_key)
                 type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(primary_key_type)
-                type = RBIHelper.as_non_nilable_type(type)
+                type = RBI::Type.parse_string(type).non_nilable
 
-                id_types = ID_TYPES.union([type]) if type != "T.untyped"
+                id_types = ID_TYPES.union([type]) if type != RBI::Type.untyped
               end
 
-              id_types = "T.any(#{id_types.to_a.join(", ")})"
+              id_types = RBI::Type.any(*id_types)
               if constant.try(:composite_primary_key?)
-                id_types = "T::Array[#{id_types}]"
+                id_types = RBI::Type.generic("T::Array", id_types)
               end
 
-              array_type = "T::Array[#{id_types}]"
+              array_type = RBI::Type.generic("T::Array", id_types)
 
               common_relation_methods_module.create_method("find") do |method|
                 method.add_opt_param("args", "nil")
@@ -656,72 +680,69 @@ def create_common_methods
 
                 method.add_sig do |sig|
                   sig.add_param("args", id_types)
-                  sig.return_type = constant_name
+                  sig.return_type = RBI::Type.simple(constant_name)
                 end
 
                 method.add_sig do |sig|
                   sig.add_param("args", array_type)
-                  sig.return_type = "T::Enumerable[#{constant_name}]"
+                  sig.return_type = RBI::Type.generic("T::Enumerable", RBI::Type.simple(constant_name))
                 end
 
                 method.add_sig do |sig|
-                  sig.add_param("args", "NilClass")
-                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
-                  sig.return_type = as_nilable_type(constant_name)
+                  sig.add_param("args", RBI::Type.simple("NilClass"))
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void)
+                  sig.return_type = RBI::Type.simple(constant_name).nilable
                 end
               end
             when :find_by
               create_common_method(
                 "find_by",
                 parameters: [
-                  create_rest_param("args", type: "T.untyped"),
+                  create_rest_param("args", type: RBI::Type.untyped),
                 ],
-                return_type: as_nilable_type(constant_name),
+                return_type: RBI::Type.simple(constant_name).nilable,
               )
             when :find_by!
               create_common_method(
                 "find_by!",
                 parameters: [
-                  create_rest_param("args", type: "T.untyped"),
+                  create_rest_param("args", type: RBI::Type.untyped),
                 ],
-                return_type: constant_name,
+                return_type: RBI::Type.simple(constant_name),
               )
             when :find_sole_by
               create_common_method(
                 "find_sole_by",
                 parameters: [
-                  create_param("arg", type: "T.untyped"),
-                  create_rest_param("args", type: "T.untyped"),
+                  create_param("arg", type: RBI::Type.untyped),
+                  create_rest_param("args", type: RBI::Type.untyped),
                 ],
-                return_type: constant_name,
+                return_type: RBI::Type.simple(constant_name),
               )
             when :sole
               create_common_method(
                 "sole",
                 parameters: [],
-                return_type: constant_name,
+                return_type: RBI::Type.simple(constant_name),
               )
             when :first, :last, :take
               common_relation_methods_module.create_method(method_name.to_s) do |method|
                 method.add_opt_param("limit", "nil")
 
                 method.add_sig do |sig|
-                  sig.return_type = as_nilable_type(constant_name)
+                  sig.return_type = RBI::Type.simple(constant_name).nilable
                 end
 
                 method.add_sig do |sig|
-                  sig.add_param("limit", "Integer")
-                  sig.return_type = "T::Array[#{constant_name}]"
+                  sig.add_param("limit", RBI::Type.simple("::Integer"))
+                  sig.return_type = RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
                 end
               end
             when :raise_record_not_found_exception!
               # skip
             else
-              return_type = if bang_method?(method_name)
-                constant_name
-              else
-                as_nilable_type(constant_name)
-              end
+              return_type = RBI::Type.simple(constant_name)
+              return_type = return_type.nilable unless bang_method?(method_name)
 
               create_common_method(
                 method_name,
@@ -736,19 +757,19 @@ def create_common_methods
               create_common_method(
                 "find_signed",
                 parameters: [
-                  create_param("signed_id", type: "T.untyped"),
-                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                  create_param("signed_id", type: RBI::Type.untyped),
+                  create_kw_opt_param("purpose", type: RBI::Type.untyped, default: "nil"),
                 ],
-                return_type: as_nilable_type(constant_name),
+                return_type: RBI::Type.simple(constant_name).nilable,
               )
             when :find_signed!
               create_common_method(
                 "find_signed!",
                 parameters: [
-                  create_param("signed_id", type: "T.untyped"),
-                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                  create_param("signed_id", type: RBI::Type.untyped),
+                  create_kw_opt_param("purpose", type: RBI::Type.untyped, default: "nil"),
                 ],
-                return_type: constant_name,
+                return_type: RBI::Type.simple(constant_name),
               )
             end
           end
@@ -759,18 +780,28 @@ def create_common_methods
               create_common_method(
                 method_name,
                 parameters: [
-                  create_param("column_name", type: "T.any(String, Symbol)"),
+                  create_param(
+                    "column_name",
+                    type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+                  ),
                 ],
-                return_type: method_name == :average ? "T.any(Integer, Float, BigDecimal)" : "T.untyped",
+                return_type: if method_name == :average
+                  RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal"))
+                else
+                  RBI::Type.untyped
+                end,
               )
             when :calculate
               create_common_method(
                 "calculate",
                 parameters: [
-                  create_param("operation", type: "Symbol"),
-                  create_param("column_name", type: "T.any(String, Symbol)"),
+                  create_param("operation", type: RBI::Type.simple("::Symbol")),
+                  create_param(
+                    "column_name",
+                    type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+                  ),
                 ],
-                return_type: "T.any(Integer, Float, BigDecimal)",
+                return_type: RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal")),
               )
             when :count
               common_relation_methods_module.create_method(method_name.to_s) do |method|
@@ -778,14 +809,14 @@ def create_common_methods
                 method.add_block_param("block")
 
                 method.add_sig do |sig|
-                  sig.add_param("column_name", "T.nilable(T.any(String, Symbol))")
-                  sig.return_type = "Integer"
+                  sig.add_param("column_name", RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")).nilable)
+                  sig.return_type = RBI::Type.simple("::Integer")
                 end
 
                 method.add_sig do |sig|
-                  sig.add_param("column_name", "NilClass")
-                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
-                  sig.return_type = "Integer"
+                  sig.add_param("column_name", RBI::Type.simple("NilClass"))
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void)
+                  sig.return_type = RBI::Type.simple("::Integer")
                 end
               end
             when :ids
@@ -797,18 +828,18 @@ def create_common_methods
                 primary_key = constant.primary_key
                 getter_type, _setter_type = column_type_helper.type_for(primary_key)
                 type = getter_type
-                create_common_method("ids", return_type: "T::Array[#{type}]")
+                create_common_method("ids", return_type: RBI::Type.generic("T::Array", type))
               else
-                create_common_method("ids", return_type: "Array")
+                create_common_method("ids", return_type: RBI::Type.simple("Array"))
               end
 
             when :pick, :pluck
               create_common_method(
                 method_name,
                 parameters: [
-                  create_rest_param("column_names", type: "T.untyped"),
+                  create_rest_param("column_names", type: RBI::Type.untyped),
                 ],
-                return_type: "T.untyped",
+                return_type: RBI::Type.untyped,
               )
             when :sum
               common_relation_methods_module.create_method(method_name.to_s) do |method|
@@ -816,14 +847,14 @@ def create_common_methods
                 method.add_block_param("block")
 
                 method.add_sig do |sig|
-                  sig.add_param("initial_value_or_column", "T.untyped")
-                  sig.return_type = "T.any(Integer, Float, BigDecimal)"
+                  sig.add_param("initial_value_or_column", RBI::Type.untyped)
+                  sig.return_type = RBI::Type.any(RBI::Type.simple("::Integer"), RBI::Type.simple("::Float"), RBI::Type.simple("::BigDecimal"))
                 end
 
                 method.add_sig(type_params: ["U"]) do |sig|
-                  sig.add_param("initial_value_or_column", "T.nilable(T.type_parameter(:U))")
-                  sig.add_param("block", "T.proc.params(object: #{constant_name}).returns(T.type_parameter(:U))")
-                  sig.return_type = "T.type_parameter(:U)"
+                  sig.add_param("initial_value_or_column", RBI::Type.type_parameter(:U).nilable)
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).returns(RBI::Type.type_parameter(:U)))
+                  sig.return_type = RBI::Type.type_parameter(:U)
                 end
               end
             end
@@ -846,7 +877,7 @@ def create_common_methods
                 parameters.each do |name, (_style, type, _default)|
                   sig.add_param(name, type)
                 end
-                sig.add_param("block", "T.proc.params(object: #{block_param}).void")
+                sig.add_param("block", RBI::Type.proc.params(object: block_param).void)
                 sig.return_type = "void"
               end
 
@@ -862,13 +893,13 @@ def create_common_methods
           RELATION_METHODS.each do |method_name|
             case method_name
             when :any?, :many?, :none?, :one? # enumerable query methods
-              block_type = "T.nilable(T.proc.params(record: #{constant_name}).returns(T.untyped))"
+              block_type = RBI::Type.proc.params(record: RBI::Type.simple(constant_name)).returns(RBI::Type.untyped).nilable
               create_common_method(
                 method_name,
                 parameters: [
                   create_block_param("block", type: block_type),
                 ],
-                return_type: "T::Boolean",
+                return_type: RBI::Type.boolean,
               )
             when :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :create_or_find_by, :create_or_find_by! # find or create methods
               common_relation_methods_module.create_method(method_name.to_s) do |method|
@@ -878,15 +909,15 @@ def create_common_methods
                 # `T.untyped` matches `T::Array[T.untyped]` so the array signature
                 # must be defined first for Sorbet to pick it, if valid.
                 method.add_sig do |sig|
-                  sig.add_param("attributes", "T::Array[T.untyped]")
-                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                  sig.return_type = "T::Array[#{constant_name}]"
+                  sig.add_param("attributes", RBI::Type.generic("T::Array", RBI::Type.untyped))
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
+                  sig.return_type = RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
                 end
 
                 method.add_sig do |sig|
-                  sig.add_param("attributes", "T.untyped")
-                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                  sig.return_type = constant_name
+                  sig.add_param("attributes", RBI::Type.untyped)
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
+                  sig.return_type = RBI::Type.simple(constant_name)
                 end
               end
             when :new, :create, :create!, :build # builder methods
@@ -895,21 +926,21 @@ def create_common_methods
                 method.add_block_param("block")
 
                 method.add_sig do |sig|
-                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
                   sig.return_type = constant_name
                 end
 
                 # `T.untyped` matches `T::Array[T.untyped]` so the array signature
                 # must be defined first for Sorbet to pick it, if valid.
                 method.add_sig do |sig|
-                  sig.add_param("attributes", "T::Array[T.untyped]")
-                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
-                  sig.return_type = "T::Array[#{constant_name}]"
+                  sig.add_param("attributes", RBI::Type.generic("T::Array", RBI::Type.untyped))
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
+                  sig.return_type = RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
                 end
 
                 method.add_sig do |sig|
-                  sig.add_param("attributes", "T.untyped")
-                  sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+                  sig.add_param("attributes", RBI::Type.untyped)
+                  sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
                   sig.return_type = constant_name
                 end
               end
@@ -930,24 +961,48 @@ def create_common_methods
                 parameters: [
                   create_rest_param(
                     "records",
-                    type: "T.any(#{constant_name}, Integer, String" \
-                      ", T::Enumerable[T.any(#{constant_name}, Integer, String, T::Enumerable[#{constant_name}])])",
+                    type: RBI::Type.any(
+                      RBI::Type.simple(constant_name),
+                      RBI::Type.simple("::Integer"),
+                      RBI::Type.simple("::String"),
+                      RBI::Type.generic(
+                        "T::Enumerable",
+                        RBI::Type.any(
+                          RBI::Type.simple(constant_name),
+                          RBI::Type.simple("::Integer"),
+                          RBI::Type.simple("::String"),
+                          RBI::Type.generic("T::Enumerable", RBI::Type.simple(constant_name))
+                        )
+                      )
+                    )
                   ),
                 ],
-                return_type: method_name == :delete ? "Integer" : "T::Array[#{constant_name}]",
+                return_type: if method_name == :delete
+                  RBI::Type.simple("::Integer")
+                else
+                  RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
+                end,
               )
             when :delete_all, :destroy_all
               common_relation_methods_module.create_method(
                 method_name.to_s,
-                return_type: method_name == :delete_all ? "Integer" : "T::Array[#{constant_name}]",
+                return_type: if method_name == :delete_all
+                  RBI::Type.simple("::Integer")
+                else
+                  RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
+                end,
               )
             when :delete_by, :destroy_by
               common_relation_methods_module.create_method(
                 method_name.to_s,
                 parameters: [
-                  create_param("args", type: "T.untyped"),
+                  create_param("args", type: RBI::Type.untyped),
                 ],
-                return_type: method_name == :delete_by ? "Integer" : "T::Array[#{constant_name}]",
+                return_type: if method_name == :delete_by
+                  RBI::Type.simple("::Integer")
+                else
+                  RBI::Type.generic("T::Array", RBI::Type.simple(constant_name))
+                end,
               )
             end
           end
@@ -961,22 +1016,22 @@ def create_common_methods
             method.add_block_param("block")
 
             method.add_sig do |sig|
-              sig.add_param("attributes", "T.untyped")
-              sig.add_param("block", "T.nilable(T.proc.params(object: #{constant_name}).void)")
+              sig.add_param("attributes", RBI::Type.untyped)
+              sig.add_param("block", RBI::Type.proc.params(object: RBI::Type.simple(constant_name)).void.nilable)
               sig.return_type = constant_name
             end
           end
         end
 
-        #: (Symbol) -> [String, String, Hash[String, [Symbol, String, String?]]]?
+        #: (Symbol) -> [RBI::Type, RBI::Type, Hash[String, [Symbol, RBI::Type, String?]]]?
         def batch_method_configs(method_name)
           block_param, return_type = case method_name
           when :find_each
-            [constant_name, "T::Enumerator[#{constant_name}]"]
+            [RBI::Type.simple(constant_name), RBI::Type.generic("T::Enumerator", RBI::Type.simple(constant_name))]
           when :find_in_batches
-            ["T::Array[#{constant_name}]", "T::Enumerator[T::Array[#{constant_name}]]"]
+            [RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)), RBI::Type.generic("T::Enumerator", RBI::Type.generic("T::Array", RBI::Type.simple(constant_name)))]
           when :in_batches
-            [RelationClassName, "::ActiveRecord::Batches::BatchEnumerator"]
+            [RBI::Type.simple(RelationClassName), RBI::Type.simple("::ActiveRecord::Batches::BatchEnumerator")]
           else
             return
           end
@@ -993,12 +1048,12 @@ def batch_method_configs(method_name)
           [block_param, return_type, parameters]
         end
 
-        #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?return_type: String?) -> void
+        #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?return_type: RBI::Type?) -> void
         def create_common_method(name, parameters: [], return_type: nil)
           common_relation_methods_module.create_method(
             name.to_s,
             parameters: parameters,
-            return_type: return_type || "void",
+            return_type: return_type,
           )
         end
 
@@ -1008,12 +1063,12 @@ def create_where_relation_method
             method.add_rest_param("args")
 
             method.add_sig do |sig|
-              sig.return_type = RelationWhereChainClassName
+              sig.return_type = RBI::Type.simple(RelationWhereChainClassName)
             end
 
             method.add_sig do |sig|
-              sig.add_param("args", "T.untyped")
-              sig.return_type = RelationClassName
+              sig.add_param("args", RBI::Type.untyped)
+              sig.return_type = RBI::Type.simple(RelationClassName)
             end
           end
 
@@ -1021,12 +1076,12 @@ def create_where_relation_method
             method.add_rest_param("args")
 
             method.add_sig do |sig|
-              sig.return_type = AssociationRelationWhereChainClassName
+              sig.return_type = RBI::Type.simple(AssociationRelationWhereChainClassName)
             end
 
             method.add_sig do |sig|
-              sig.add_param("args", "T.untyped")
-              sig.return_type = AssociationRelationClassName
+              sig.add_param("args", RBI::Type.untyped)
+              sig.return_type = RBI::Type.simple(AssociationRelationClassName)
             end
           end
         end
@@ -1034,14 +1089,14 @@ def create_where_relation_method
         #: (
         #|   (Symbol | String) name,
         #|   ?parameters: Array[RBI::TypedParam],
-        #|   ?relation_return_type: String,
-        #|   ?association_return_type: String
+        #|   ?relation_return_type: RBI::Type,
+        #|   ?association_return_type: RBI::Type
         #| ) -> void
         def create_relation_method(
           name,
           parameters: [],
-          relation_return_type: RelationClassName,
-          association_return_type: AssociationRelationClassName
+          relation_return_type: RBI::Type.simple(RelationClassName),
+          association_return_type: RBI::Type.simple(AssociationRelationClassName)
         )
           relation_methods_module.create_method(
             name.to_s,
@@ -1065,8 +1120,8 @@ def create_unscoped_relation_method
             end
 
             method.add_sig(type_params: ["U"]) do |sig|
-              sig.add_param("block", "T.proc.returns(T.type_parameter(:U))")
-              sig.return_type = "T.type_parameter(:U)"
+              sig.add_param("block", RBI::Type.proc.returns(RBI::Type.type_parameter(:U)))
+              sig.return_type = RBI::Type.type_parameter(:U)
             end
           end
 
@@ -1078,8 +1133,8 @@ def create_unscoped_relation_method
             end
 
             method.add_sig(type_params: ["U"]) do |sig|
-              sig.add_param("block", "T.proc.returns(T.type_parameter(:U))")
-              sig.return_type = "T.type_parameter(:U)"
+              sig.add_param("block", RBI::Type.proc.returns(RBI::Type.type_parameter(:U)))
+              sig.return_type = RBI::Type.type_parameter(:U)
             end
           end
         end
diff --git a/lib/tapioca/dsl/compilers/active_record_scope.rb b/lib/tapioca/dsl/compilers/active_record_scope.rb
index e5d01b375..477429713 100644
--- a/lib/tapioca/dsl/compilers/active_record_scope.rb
+++ b/lib/tapioca/dsl/compilers/active_record_scope.rb
@@ -59,7 +59,7 @@ def decorate
               generate_scope_method(
                 relation_methods_module,
                 scope_method.to_s,
-                relations_enabled ? RelationClassName : "T.untyped",
+                relations_enabled ? RBI::Type.simple(RelationClassName) : RBI::Type.untyped,
               )
 
               next unless relations_enabled
@@ -67,7 +67,7 @@ def decorate
               generate_scope_method(
                 assoc_relation_methods_mod,
                 scope_method.to_s,
-                AssociationRelationClassName,
+                RBI::Type.simple(AssociationRelationClassName),
               )
             end
 
@@ -104,13 +104,13 @@ def scope_method_names
           scope_methods.uniq
         end
 
-        #: (RBI::Scope mod, String scope_method, String return_type) -> void
+        #: (RBI::Scope mod, String scope_method, RBI::Type return_type) -> void
         def generate_scope_method(mod, scope_method, return_type)
           mod.create_method(
             scope_method,
             parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
+              create_rest_param("args", type: RBI::Type.untyped),
+              create_block_param("blk", type: RBI::Type.untyped),
             ],
             return_type: return_type,
           )
diff --git a/lib/tapioca/dsl/compilers/active_record_secure_token.rb b/lib/tapioca/dsl/compilers/active_record_secure_token.rb
index ea494d133..85e6aa77e 100644
--- a/lib/tapioca/dsl/compilers/active_record_secure_token.rb
+++ b/lib/tapioca/dsl/compilers/active_record_secure_token.rb
@@ -46,7 +46,7 @@ def decorate
               constant.__tapioca_secure_tokens.each do |attribute|
                 mod.create_method(
                   "regenerate_#{attribute}",
-                  return_type: "T::Boolean",
+                  return_type: RBI::Type.boolean,
                 )
               end
             end
diff --git a/lib/tapioca/dsl/compilers/active_record_store.rb b/lib/tapioca/dsl/compilers/active_record_store.rb
index 6faeec6f9..410607391 100644
--- a/lib/tapioca/dsl/compilers/active_record_store.rb
+++ b/lib/tapioca/dsl/compilers/active_record_store.rb
@@ -112,16 +112,16 @@ def decorate
                 keys.flatten.map { |key| "#{accessor_prefix}#{key}#{accessor_suffix}" }.each do |accessor_key|
                   mod.create_method(
                     "#{accessor_key}=",
-                    parameters: [create_param("value", type: "T.untyped")],
-                    return_type: "T.untyped",
+                    parameters: [create_param("value", type: RBI::Type.untyped)],
+                    return_type: RBI::Type.untyped,
                   )
-                  mod.create_method(accessor_key, return_type: "T.untyped")
-                  mod.create_method("#{accessor_key}_changed?", return_type: "T::Boolean")
-                  mod.create_method("#{accessor_key}_change", return_type: "T.untyped")
-                  mod.create_method("#{accessor_key}_was", return_type: "T.untyped")
-                  mod.create_method("saved_change_to_#{accessor_key}?", return_type: "T::Boolean")
-                  mod.create_method("saved_change_to_#{accessor_key}", return_type: "T.untyped")
-                  mod.create_method("#{accessor_key}_before_last_save", return_type: "T.untyped")
+                  mod.create_method(accessor_key, return_type: RBI::Type.untyped)
+                  mod.create_method("#{accessor_key}_changed?", return_type: RBI::Type.boolean)
+                  mod.create_method("#{accessor_key}_change", return_type: RBI::Type.untyped)
+                  mod.create_method("#{accessor_key}_was", return_type: RBI::Type.untyped)
+                  mod.create_method("saved_change_to_#{accessor_key}?", return_type: RBI::Type.boolean)
+                  mod.create_method("saved_change_to_#{accessor_key}", return_type: RBI::Type.untyped)
+                  mod.create_method("#{accessor_key}_before_last_save", return_type: RBI::Type.untyped)
                 end
               end
             end
diff --git a/lib/tapioca/dsl/compilers/active_record_typed_store.rb b/lib/tapioca/dsl/compilers/active_record_typed_store.rb
index b374f8bbc..093f6afa2 100644
--- a/lib/tapioca/dsl/compilers/active_record_typed_store.rb
+++ b/lib/tapioca/dsl/compilers/active_record_typed_store.rb
@@ -118,27 +118,27 @@ def gather_constants
         private
 
         TYPES = {
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          any: "T.untyped",
-        }.freeze #: Hash[Symbol, String]
+          boolean: RBI::Type.boolean,
+          integer: RBI::Type.simple("::Integer"),
+          string: RBI::Type.simple("::String"),
+          float: RBI::Type.simple("::Float"),
+          date: RBI::Type.simple("::Date"),
+          time: RBI::Type.simple("::Time"),
+          datetime: RBI::Type.simple("::DateTime"),
+          decimal: RBI::Type.simple("::BigDecimal"),
+          any: RBI::Type.untyped,
+        }.freeze #: Hash[Symbol, RBI::Type]
 
-        #: (ActiveRecord::TypedStore::Field field) -> String
+        #: (ActiveRecord::TypedStore::Field field) -> RBI::Type
         def type_for(field)
-          type = TYPES.fetch(field.type_sym, "T.untyped")
+          type = TYPES.fetch(field.type_sym, RBI::Type.untyped)
 
           type = if field.array
             # `null: false` applies to the array itself, not the elements, which are always nilable.
             # https://github.com/byroot/activerecord-typedstore/blob/2f3fb98/spec/support/models.rb#L46C34-L46C45
             # https://github.com/byroot/activerecord-typedstore/blob/2f3fb98/spec/active_record/typed_store_spec.rb#L854-L857
             nilable_element_type = as_nilable_type(type)
-            "T::Array[#{nilable_element_type}]"
+            RBI::Type.generic("T::Array", nilable_element_type)
           else
             type
           end
@@ -148,7 +148,7 @@ def type_for(field)
           type
         end
 
-        #: (RBI::Scope klass, String name, String type) -> void
+        #: (RBI::Scope klass, String name, RBI::Type type) -> void
         def generate_methods(klass, name, type)
           klass.create_method(
             "#{name}=",
@@ -156,13 +156,13 @@ def generate_methods(klass, name, type)
             return_type: type,
           )
           klass.create_method(name, return_type: type)
-          klass.create_method("#{name}?", return_type: "T::Boolean")
+          klass.create_method("#{name}?", return_type: RBI::Type.boolean)
           klass.create_method("#{name}_was", return_type: type)
-          klass.create_method("#{name}_changed?", return_type: "T::Boolean")
+          klass.create_method("#{name}_changed?", return_type: RBI::Type.boolean)
           klass.create_method("#{name}_before_last_save", return_type: type)
-          klass.create_method("saved_change_to_#{name}?", return_type: "T::Boolean")
-          klass.create_method("#{name}_change", return_type: "T.nilable([#{type}, #{type}])")
-          klass.create_method("saved_change_to_#{name}", return_type: "T.nilable([#{type}, #{type}])")
+          klass.create_method("saved_change_to_#{name}?", return_type: RBI::Type.boolean)
+          klass.create_method("#{name}_change", return_type: RBI::Type.tuple(type, type).nilable)
+          klass.create_method("saved_change_to_#{name}", return_type: RBI::Type.tuple(type, type).nilable)
         end
       end
     end
diff --git a/lib/tapioca/dsl/compilers/active_resource.rb b/lib/tapioca/dsl/compilers/active_resource.rb
index 7373efdf1..82f514178 100644
--- a/lib/tapioca/dsl/compilers/active_resource.rb
+++ b/lib/tapioca/dsl/compilers/active_resource.rb
@@ -79,21 +79,21 @@ def gather_constants
         private
 
         TYPES = {
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          binary: "String",
-          text: "String",
-        }.freeze #: Hash[Symbol, String]
+          boolean: RBI::Type.boolean,
+          integer: RBI::Type.simple("::Integer"),
+          string: RBI::Type.simple("::String"),
+          float: RBI::Type.simple("::Float"),
+          date: RBI::Type.simple("::Date"),
+          time: RBI::Type.simple("::Time"),
+          datetime: RBI::Type.simple("::DateTime"),
+          decimal: RBI::Type.simple("::BigDecimal"),
+          binary: RBI::Type.simple("::String"),
+          text: RBI::Type.simple("::String"),
+        }.freeze #: Hash[Symbol, RBI::Type]
 
-        #: (Symbol attr_type) -> String
+        #: (Symbol attr_type) -> RBI::Type
         def type_for(attr_type)
-          TYPES.fetch(attr_type, "T.untyped")
+          TYPES.fetch(attr_type, RBI::Type.untyped)
         end
 
         #: (RBI::Scope klass, String attribute, String type) -> void
@@ -101,7 +101,7 @@ def create_schema_methods(klass, attribute, type)
           return_type = type_for(type.to_sym)
 
           klass.create_method(attribute, return_type: return_type)
-          klass.create_method("#{attribute}?", return_type: "T::Boolean")
+          klass.create_method("#{attribute}?", return_type: RBI::Type.boolean)
           klass.create_method(
             "#{attribute}=",
             parameters: [
diff --git a/lib/tapioca/dsl/compilers/active_storage.rb b/lib/tapioca/dsl/compilers/active_storage.rb
index 53a68c674..b2718af3e 100644
--- a/lib/tapioca/dsl/compilers/active_storage.rb
+++ b/lib/tapioca/dsl/compilers/active_storage.rb
@@ -55,8 +55,8 @@ def decorate
               )
               scope.create_method(
                 "#{name}=",
-                parameters: [create_param("attachable", type: "T.untyped")],
-                return_type: "T.untyped",
+                parameters: [create_param("attachable", type: RBI::Type.untyped)],
+                return_type: RBI::Type.untyped,
               )
             end
           end
@@ -74,15 +74,15 @@ def gather_constants
 
         private
 
-        #: (ActiveRecord::Reflection::MacroReflection reflection) -> String
+        #: (ActiveRecord::Reflection::MacroReflection reflection) -> RBI::Type
         def type_of(reflection)
           case reflection
           when ::ActiveStorage::Reflection::HasOneAttachedReflection
-            "ActiveStorage::Attached::One"
+            RBI::Type.simple("::ActiveStorage::Attached::One")
           when ::ActiveStorage::Reflection::HasManyAttachedReflection
-            "ActiveStorage::Attached::Many"
+            RBI::Type.simple("::ActiveStorage::Attached::Many")
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
         end
       end
diff --git a/lib/tapioca/dsl/compilers/active_support_environment_inquirer.rb b/lib/tapioca/dsl/compilers/active_support_environment_inquirer.rb
index af9dd216b..416073e97 100644
--- a/lib/tapioca/dsl/compilers/active_support_environment_inquirer.rb
+++ b/lib/tapioca/dsl/compilers/active_support_environment_inquirer.rb
@@ -40,7 +40,7 @@ def decorate
 
           root.create_path(::ActiveSupport::EnvironmentInquirer) do |mod|
             envs.each do |env|
-              mod.create_method("#{env}?", return_type: "T::Boolean")
+              mod.create_method("#{env}?", return_type: RBI::Type.boolean)
             end
           end
         end
diff --git a/lib/tapioca/dsl/compilers/active_support_time_ext.rb b/lib/tapioca/dsl/compilers/active_support_time_ext.rb
index 7f8ed63b0..c7c524b82 100644
--- a/lib/tapioca/dsl/compilers/active_support_time_ext.rb
+++ b/lib/tapioca/dsl/compilers/active_support_time_ext.rb
@@ -43,9 +43,9 @@ def decorate
 
           root.create_path(constant) do |mod|
             return_type = if ::Time.zone
-              "::ActiveSupport::TimeWithZone"
+              RBI::Type.simple("::ActiveSupport::TimeWithZone")
             else
-              "::Time"
+              RBI::Type.simple("::Time")
             end
 
             mod.create_method("current", return_type: return_type, class_method: true)
diff --git a/lib/tapioca/dsl/compilers/config.rb b/lib/tapioca/dsl/compilers/config.rb
index 3bd78bc1d..92eecd943 100644
--- a/lib/tapioca/dsl/compilers/config.rb
+++ b/lib/tapioca/dsl/compilers/config.rb
@@ -71,20 +71,20 @@ def decorate
             # enumerates the entries, we don't make any assumptions about their
             # types.
             mod.create_extend("T::Generic")
-            mod.create_type_variable("Elem", type: "type_member", fixed: "T.untyped")
+            mod.create_type_variable("Elem", type: "type_member", fixed: RBI::Type.untyped)
 
             method_names.each do |method_name|
               # Create getter method
               mod.create_method(
                 method_name.to_s,
-                return_type: "T.untyped",
+                return_type: RBI::Type.untyped,
               )
 
               # Create setter method
               mod.create_method(
                 "#{method_name}=",
-                parameters: [create_param("value", type: "T.untyped")],
-                return_type: "T.untyped",
+                parameters: [create_param("value", type: RBI::Type.untyped)],
+                return_type: RBI::Type.untyped,
               )
             end
           end
diff --git a/lib/tapioca/dsl/compilers/frozen_record.rb b/lib/tapioca/dsl/compilers/frozen_record.rb
index a055a2066..f595f0ea3 100644
--- a/lib/tapioca/dsl/compilers/frozen_record.rb
+++ b/lib/tapioca/dsl/compilers/frozen_record.rb
@@ -71,8 +71,8 @@ def decorate
 
             record.create_module(module_name) do |mod|
               attributes.each do |attribute|
-                mod.create_method("#{attribute}?", return_type: "T::Boolean")
-                mod.create_method(attribute.to_s, return_type: "T.untyped")
+                mod.create_method("#{attribute}?", return_type: RBI::Type.boolean)
+                mod.create_method(attribute.to_s, return_type: RBI::Type.untyped)
               end
             end
 
@@ -113,10 +113,10 @@ def generate_scope_method(scope_method, mod)
           mod.create_method(
             scope_method,
             parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
+              create_rest_param("args", type: RBI::Type.untyped),
+              create_block_param("blk", type: RBI::Type.untyped),
             ],
-            return_type: "T.untyped",
+            return_type: RBI::Type.untyped,
           )
         end
       end
diff --git a/lib/tapioca/dsl/compilers/graphql_mutation.rb b/lib/tapioca/dsl/compilers/graphql_mutation.rb
index a33a1eed9..0c63d37fa 100644
--- a/lib/tapioca/dsl/compilers/graphql_mutation.rb
+++ b/lib/tapioca/dsl/compilers/graphql_mutation.rb
@@ -57,13 +57,13 @@ def decorate
           end
 
           root.create_path(constant) do |mutation|
-            mutation.create_method("resolve", parameters: params, return_type: "T.untyped")
+            mutation.create_method("resolve", parameters: params, return_type: RBI::Type.untyped)
           end
         end
 
-        #: (GraphQL::Schema::Argument? argument, singleton(GraphQL::Schema::Mutation) constant) -> String
+        #: (GraphQL::Schema::Argument? argument, singleton(GraphQL::Schema::Mutation) constant) -> RBI::Type
         def argument_type(argument, constant)
-          return "T.untyped" unless argument
+          return RBI::Type.untyped unless argument
 
           Helpers::GraphqlTypeHelper.type_for_argument(argument, constant)
         end
diff --git a/lib/tapioca/dsl/compilers/identity_cache.rb b/lib/tapioca/dsl/compilers/identity_cache.rb
index 029cf7e41..cf64a41ce 100644
--- a/lib/tapioca/dsl/compilers/identity_cache.rb
+++ b/lib/tapioca/dsl/compilers/identity_cache.rb
@@ -57,8 +57,6 @@ module Compilers
       # ~~~
       #: [ConstantType = singleton(::ActiveRecord::Base)]
       class IdentityCache < Compiler
-        COLLECTION_TYPE = ->(type) { "T::Array[::#{type}]" } #: ^((T::Module[top] | String) type) -> String
-
         # @override
         #: -> void
         def decorate
@@ -101,16 +99,17 @@ def gather_constants
 
         private
 
-        #: (untyped field, returns_collection: bool) -> String
+        #: (untyped field, returns_collection: bool) -> RBI::Type
         def type_for_field(field, returns_collection:)
-          cache_type = field.reflection.compute_class(field.reflection.class_name)
+          cache_type_class = field.reflection.compute_class(field.reflection.class_name)
+          cache_type = RBI::Type.simple(qualified_name_of(cache_type_class))
           if returns_collection
-            COLLECTION_TYPE.call(cache_type)
+            collection_type(cache_type)
           else
-            as_nilable_type(T.must(qualified_name_of(cache_type)))
+            cache_type.nilable
           end
         rescue ArgumentError
-          "T.untyped"
+          RBI::Type.untyped
         end
 
         #: (untyped field, RBI::Scope klass, returns_collection: bool) -> void
@@ -120,9 +119,12 @@ def create_fetch_field_methods(field, klass, returns_collection:)
           klass.create_method(name, return_type: type)
 
           if field.respond_to?(:cached_ids_name)
-            klass.create_method(field.cached_ids_name, return_type: "T::Array[T.untyped]")
+            klass.create_method(
+              field.cached_ids_name,
+              return_type: RBI::Type.generic("T::Array", RBI::Type.untyped),
+            )
           elsif field.respond_to?(:cached_id_name)
-            klass.create_method(field.cached_id_name, return_type: "T.untyped")
+            klass.create_method(field.cached_id_name, return_type: RBI::Type.untyped)
           end
         end
 
@@ -141,13 +143,13 @@ def create_fetch_by_methods(field, klass)
         def create_index_fetch_by_methods(field, klass)
           fields_name = field.key_fields.join("_and_")
           name = "fetch_by_#{fields_name}"
+          type = RBI::Type.simple(T.must(qualified_name_of(constant)))
           parameters = field.key_fields.map do |arg|
-            create_param(arg.to_s, type: "T.untyped")
+            create_param(arg.to_s, type: RBI::Type.untyped)
           end
-          parameters << create_kw_opt_param("includes", default: "nil", type: "T.untyped")
+          parameters << create_kw_opt_param("includes", default: "nil", type: RBI::Type.untyped)
 
           if field.unique
-            type = T.must(qualified_name_of(constant))
 
             klass.create_method(
               "#{name}!",
@@ -160,14 +162,14 @@ def create_index_fetch_by_methods(field, klass)
               name,
               class_method: true,
               parameters: parameters,
-              return_type: as_nilable_type(type),
+              return_type: type.nilable,
             )
           else
             klass.create_method(
               name,
               class_method: true,
               parameters: parameters,
-              return_type: COLLECTION_TYPE.call(constant),
+              return_type: collection_type(type),
             )
           end
 
@@ -175,10 +177,10 @@ def create_index_fetch_by_methods(field, klass)
             "fetch_multi_by_#{fields_name}",
             class_method: true,
             parameters: [
-              create_param("index_values", type: "T::Enumerable[T.untyped]"),
-              create_kw_opt_param("includes", default: "nil", type: "T.untyped"),
+              create_param("index_values", type: RBI::Type.generic("T::Enumerable", RBI::Type.untyped)),
+              create_kw_opt_param("includes", default: "nil", type: RBI::Type.untyped),
             ],
-            return_type: COLLECTION_TYPE.call(constant),
+            return_type: collection_type(type),
           )
         end
 
@@ -188,27 +190,32 @@ def create_aliased_fetch_by_methods(field, klass)
             constant,
             column_type_option: Helpers::ActiveRecordColumnTypeHelper::ColumnTypeOption::Nilable,
           ).type_for(field.alias_name.to_s)
-          multi_type = type.delete_prefix("T.nilable(").delete_suffix(")").delete_prefix("::")
+          multi_type = type.non_nilable
           suffix = field.send(:fetch_method_suffix)
 
           parameters = field.key_fields.map do |arg|
-            create_param(arg.to_s, type: "T.untyped")
+            create_param(arg.to_s, type: RBI::Type.untyped)
           end
 
           klass.create_method(
             "fetch_#{suffix}",
             class_method: true,
             parameters: parameters,
-            return_type: field.unique ? type : COLLECTION_TYPE.call(type),
+            return_type: field.unique ? type : collection_type(type),
           )
 
           klass.create_method(
             "fetch_multi_#{suffix}",
             class_method: true,
-            parameters: [create_param("keys", type: "T::Enumerable[T.untyped]")],
-            return_type: COLLECTION_TYPE.call(multi_type),
+            parameters: [create_param("keys", type: RBI::Type.generic("T::Enumerable", RBI::Type.untyped))],
+            return_type: collection_type(multi_type),
           )
         end
+
+        #: (RBI::Type type) -> RBI::Type
+        def collection_type(type)
+          RBI::Type.generic("T::Array", type)
+        end
       end
     end
   end
diff --git a/lib/tapioca/dsl/compilers/json_api_client_resource.rb b/lib/tapioca/dsl/compilers/json_api_client_resource.rb
index 46036b41e..c990df196 100644
--- a/lib/tapioca/dsl/compilers/json_api_client_resource.rb
+++ b/lib/tapioca/dsl/compilers/json_api_client_resource.rb
@@ -133,10 +133,10 @@ def generate_methods_for_property(mod, property)
           mod.create_method("#{name}=", parameters: [create_param(name, type: type)], return_type: type)
         end
 
-        #: (::JsonApiClient::Schema::Property property) -> String
+        #: (::JsonApiClient::Schema::Property property) -> RBI::Type
         def type_for(property)
           type = ::JsonApiClient::Schema::TypeFactory.type_for(property.type)
-          return "T.untyped" if type.nil?
+          return RBI::Type.untyped if type.nil?
 
           sorbet_type = if type.respond_to?(:sorbet_type)
             line, file = type.method(:sorbet_type).source_location
@@ -147,23 +147,23 @@ def type_for(property)
               Defined on line #{line} of #{file}
             MESSAGE
 
-            type.sorbet_type
+            RBI::Type.parse_string(type.sorbet_type)
           elsif type.respond_to?(:__tapioca_type)
-            type.__tapioca_type
+            RBI::Type.parse_string(type.__tapioca_type)
           elsif type == ::JsonApiClient::Schema::Types::Integer
-            "::Integer"
+            RBI::Type.simple("::Integer")
           elsif type == ::JsonApiClient::Schema::Types::String
-            "::String"
+            RBI::Type.simple("::String")
           elsif type == ::JsonApiClient::Schema::Types::Float
-            "::Float"
+            RBI::Type.simple("::Float")
           elsif type == ::JsonApiClient::Schema::Types::Time
-            "::Time"
+            RBI::Type.simple("::Time")
           elsif type == ::JsonApiClient::Schema::Types::Decimal
-            "::BigDecimal"
+            RBI::Type.simple("::BigDecimal")
           elsif type == ::JsonApiClient::Schema::Types::Boolean
-            "T::Boolean"
+            RBI::Type.boolean
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
 
           if property.default.nil?
@@ -181,11 +181,11 @@ def generate_methods_for_association(mod, association)
           name, type = case association
           when ::JsonApiClient::Associations::BelongsTo::Association
             # id must be a string: # https://jsonapi.org/format/#document-resource-object-identification
-            [association.param.to_s, "T.nilable(::String)"]
+            [association.param.to_s, RBI::Type.simple("::String").nilable]
           when ::JsonApiClient::Associations::HasOne::Association
-            [association.attr_name.to_s, "T.nilable(#{klass})"]
+            [association.attr_name.to_s, RBI::Type.simple(T.must(qualified_name_of(klass))).nilable]
           when ::JsonApiClient::Associations::HasMany::Association
-            [association.attr_name.to_s, "T.nilable(T::Array[#{klass}])"]
+            [association.attr_name.to_s, RBI::Type.generic("T::Array", RBI::Type.simple(T.must(qualified_name_of(klass)))).nilable]
           else
             return # Unsupported association type
           end
diff --git a/lib/tapioca/dsl/compilers/kredis.rb b/lib/tapioca/dsl/compilers/kredis.rb
index cbc930018..11b3a6bef 100644
--- a/lib/tapioca/dsl/compilers/kredis.rb
+++ b/lib/tapioca/dsl/compilers/kredis.rb
@@ -103,18 +103,18 @@ def generate_methods(mod, method, data)
             create_enum_class(mod, klass_name, data.fetch(:values))
             return_type = klass_name
           when "Kredis::Types::Flag"
-            mod.create_method("#{method}?", return_type: "T::Boolean")
+            mod.create_method("#{method}?", return_type: RBI::Type.boolean)
           end
 
-          mod.create_method(method, return_type: return_type)
+          mod.create_method(method, return_type: RBI::Type.simple(return_type))
         end
 
         #: (RBI::Scope mod, String klass_name, Array[untyped] values) -> void
         def create_enum_class(mod, klass_name, values)
           klass = mod.create_class(klass_name, superclass_name: "Kredis::Types::Enum")
           values.each do |value|
-            klass.create_method("#{value}!", return_type: "void")
-            klass.create_method("#{value}?", return_type: "T::Boolean")
+            klass.create_method("#{value}!", return_type: RBI::Type.void)
+            klass.create_method("#{value}?", return_type: RBI::Type.boolean)
           end
         end
       end
diff --git a/lib/tapioca/dsl/compilers/protobuf.rb b/lib/tapioca/dsl/compilers/protobuf.rb
index 16edfb5a8..4fb74d053 100644
--- a/lib/tapioca/dsl/compilers/protobuf.rb
+++ b/lib/tapioca/dsl/compilers/protobuf.rb
@@ -68,8 +68,8 @@ module Compilers
       class Protobuf < Compiler
         class Field < T::Struct
           prop :name, String
-          prop :type, String
-          prop :init_type, String
+          prop :type, RBI::Type
+          prop :init_type, RBI::Type
           prop :default, String
         end
 
@@ -105,19 +105,19 @@ def decorate
 
                 klass.create_method(
                   "lookup",
-                  parameters: [create_param("number", type: "Integer")],
-                  return_type: "T.nilable(Symbol)",
+                  parameters: [create_param("number", type: RBI::Type.simple("::Integer"))],
+                  return_type: RBI::Type.simple("::Symbol").nilable,
                   class_method: true,
                 )
                 klass.create_method(
                   "resolve",
-                  parameters: [create_param("symbol", type: "Symbol")],
-                  return_type: "T.nilable(Integer)",
+                  parameters: [create_param("symbol", type: RBI::Type.simple("::Symbol"))],
+                  return_type: RBI::Type.simple("::Integer").nilable,
                   class_method: true,
                 )
                 klass.create_method(
                   "descriptor",
-                  return_type: "Google::Protobuf::EnumDescriptor",
+                  return_type: RBI::Type.simple("::Google::Protobuf::EnumDescriptor"),
                   class_method: true,
                 )
               when Google::Protobuf::Descriptor
@@ -133,13 +133,13 @@ def decorate
                 end
 
                 if fields.all? { |field| FIELD_RE.match?(field.name) }
-                  klass.create_method("initialize", parameters: parameters, return_type: "void")
+                  klass.create_method("initialize", parameters: parameters, return_type: RBI::Type.void)
                 else
                   # One of the fields has an incorrect name for a named parameter so creating the default initialize for
                   # it would create a RBI with a syntax error.
                   # The workaround is to create an initialize that takes a **kwargs instead.
-                  kwargs_parameter = create_kw_rest_param("fields", type: "T.untyped")
-                  klass.create_method("initialize", parameters: [kwargs_parameter], return_type: "void")
+                  kwargs_parameter = create_kw_rest_param("fields", type: RBI::Type.untyped)
+                  klass.create_method("initialize", parameters: [kwargs_parameter], return_type: RBI::Type.void)
                 end
               else
                 add_error(<<~MSG.strip)
@@ -196,7 +196,7 @@ def create_type_members(klass, *names)
           end
         end
 
-        #: (Google::Protobuf::FieldDescriptor descriptor) -> String
+        #: (Google::Protobuf::FieldDescriptor descriptor) -> RBI::Type
         def type_of(descriptor)
           case descriptor.type
           when :enum
@@ -206,19 +206,24 @@ def type_of(descriptor)
             # > value is known, or a number if it is unknown. Since proto3 uses
             # > open enum semantics, any number may be assigned to an enum
             # > field, even if it was not defined in the enum.
-            "T.any(Symbol, Integer)"
+            RBI::Type.any(RBI::Type.simple("::Symbol"), RBI::Type.simple("::Integer"))
           when :message
-            descriptor.subtype.msgclass.name || "T.untyped"
+            name = qualified_name_of(descriptor.subtype.msgclass)
+            if name
+              RBI::Type.simple(name)
+            else
+              RBI::Type.untyped
+            end
           when :int32, :int64, :uint32, :uint64
-            "Integer"
+            RBI::Type.simple("::Integer")
           when :double, :float
-            "Float"
+            RBI::Type.simple("::Float")
           when :bool
-            "T::Boolean"
+            RBI::Type.boolean
           when :string, :bytes
-            "String"
+            RBI::Type.simple("::String")
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
         end
 
@@ -250,17 +255,17 @@ def field_of(descriptor)
 
               key_type = type_of(key)
               value_type = type_of(value)
-              type = "Google::Protobuf::Map[#{key_type}, #{value_type}]"
+              type = RBI::Type.generic("Google::Protobuf::Map", key_type, value_type)
 
               Field.new(
                 name: descriptor.name,
                 type: type,
-                init_type: "T.nilable(T.any(#{type}, T::Hash[#{key_type}, #{value_type}]))",
+                init_type: RBI::Type.any(type, RBI::Type.generic("Hash", key_type, value_type)).nilable,
                 default: "T.unsafe(nil)",
               )
             else
               elem_type = type_of(descriptor)
-              type = "Google::Protobuf::RepeatedField[#{elem_type}]"
+              type = RBI::Type.generic("Google::Protobuf::RepeatedField", elem_type)
 
               Field.new(
                 name: descriptor.name,
@@ -269,13 +274,13 @@ def field_of(descriptor)
                 # https://github.com/protocolbuffers/protobuf/blob/fc0eda1fd4eff075f1fb2e9249fa4209f0227e33/ruby/lib/google/protobuf/ffi/repeated_field.rb#L361-L366
                 # However the C implementation of the initializer specifically checks for Arrays:
                 # https://github.com/protocolbuffers/protobuf/blob/fc0eda1fd4eff075f1fb2e9249fa4209f0227e33/ruby/ext/google/protobuf_c/message.c#L568-L573
-                init_type: "T.nilable(T::Array[#{elem_type}])",
+                init_type: RBI::Type.any(type, RBI::Type.generic("Array", elem_type)).nilable,
                 default: "T.unsafe(nil)",
               )
             end
           else
             type = type_of(descriptor)
-            nilable_type = as_nilable_type(type)
+            nilable_type = type.nilable
             type = nilable_type if nilable_descriptor?(descriptor)
 
             Field.new(
@@ -299,18 +304,18 @@ def create_descriptor_method(klass, desc)
           klass.create_method(
             "#{field.name}=",
             parameters: [create_param("value", type: field.type)],
-            return_type: "void",
+            return_type: RBI::Type.void,
           )
 
           klass.create_method(
             "clear_#{field.name}",
-            return_type: "void",
+            return_type: RBI::Type.void,
           )
 
           if has_presence?(desc)
             klass.create_method(
               "has_#{field.name}?",
-              return_type: "Object",
+              return_type: RBI::Type.simple("::Object"),
             )
           end
 
@@ -321,7 +326,7 @@ def create_descriptor_method(klass, desc)
         def create_oneof_method(klass, desc)
           klass.create_method(
             desc.name,
-            return_type: "T.nilable(Symbol)",
+            return_type: RBI::Type.simple("::Symbol").nilable,
           )
         end
       end
diff --git a/lib/tapioca/dsl/compilers/rails_generators.rb b/lib/tapioca/dsl/compilers/rails_generators.rb
index ef4310c47..a20565042 100644
--- a/lib/tapioca/dsl/compilers/rails_generators.rb
+++ b/lib/tapioca/dsl/compilers/rails_generators.rb
@@ -88,22 +88,22 @@ def base_class_of_constant
           T.cast(ancestor, T.class_of(::Rails::Generators::Base))
         end
 
-        #: ((Thor::Argument | Thor::Option) arg) -> String
+        #: ((Thor::Argument | Thor::Option) arg) -> RBI::Type
         def type_for(arg)
           type =
             case arg.type
-            when :array then "T::Array[::String]"
-            when :boolean then "T::Boolean"
-            when :hash then "T::Hash[::String, ::String]"
-            when :numeric then "::Numeric"
-            when :string then "::String"
-            else "T.untyped"
+            when :array then RBI::Type.generic("T::Array", RBI::Type.simple("::String"))
+            when :boolean then RBI::Type.boolean
+            when :hash then RBI::Type.generic("T::Hash", RBI::Type.simple("::String"), RBI::Type.simple("::String"))
+            when :numeric then RBI::Type.simple("::Numeric")
+            when :string then RBI::Type.simple("::String")
+            else RBI::Type.untyped
             end
 
           if arg.required || arg.default
             type
           else
-            as_nilable_type(type)
+            type.nilable
           end
         end
       end
diff --git a/lib/tapioca/dsl/compilers/sidekiq_worker.rb b/lib/tapioca/dsl/compilers/sidekiq_worker.rb
index 762512f1d..23f72b96f 100644
--- a/lib/tapioca/dsl/compilers/sidekiq_worker.rb
+++ b/lib/tapioca/dsl/compilers/sidekiq_worker.rb
@@ -57,18 +57,19 @@ def decorate
             # accept a datetime, time, or numeric but we're typing them differently so they
             # semantically make sense.
             at_return_type = if defined?(ActiveSupport::TimeWithZone)
-              "T.any(DateTime, Time, ActiveSupport::TimeWithZone)"
+              RBI::Type.any(RBI::Type.simple("::DateTime"), RBI::Type.simple("::Time"), RBI::Type.simple("::ActiveSupport::TimeWithZone"))
             else
-              "T.any(DateTime, Time)"
+              RBI::Type.any(RBI::Type.simple("::DateTime"), RBI::Type.simple("::Time"))
             end
             at_params = [
               create_param("interval", type: at_return_type),
               *async_params,
             ]
+
             in_return_type = if defined?(ActiveSupport::Duration)
-              "T.any(Numeric, ActiveSupport::Duration)"
+              RBI::Type.any(RBI::Type.simple("::Numeric"), RBI::Type.simple("::ActiveSupport::Duration"))
             else
-              "Numeric"
+              RBI::Type.simple("::Numeric")
             end
             in_params = [
               create_param("interval", type: in_return_type),
@@ -94,7 +95,12 @@ def gather_constants
         #: (RBI::Scope worker, String method_name, Array[RBI::TypedParam] parameters) -> void
         def generate_perform_method(worker, method_name, parameters)
           if constant.method(method_name.to_sym).owner == Sidekiq::Worker::ClassMethods
-            worker.create_method(method_name, parameters: parameters, return_type: "String", class_method: true)
+            worker.create_method(
+              method_name,
+              parameters: parameters,
+              return_type: RBI::Type.simple("::String"),
+              class_method: true,
+            )
           end
         end
       end
diff --git a/lib/tapioca/dsl/compilers/smart_properties.rb b/lib/tapioca/dsl/compilers/smart_properties.rb
index 263c8b359..d36f5d420 100644
--- a/lib/tapioca/dsl/compilers/smart_properties.rb
+++ b/lib/tapioca/dsl/compilers/smart_properties.rb
@@ -58,12 +58,12 @@ module Compilers
       #   end
       # end
       # ~~~
-      #: [ConstantType = singleton(::SmartProperties)]
+      #: [ConstantType = singleton(::SmartProperties) & ::SmartProperties::ClassMethods]
       class SmartProperties < Compiler
         # @override
         #: -> void
         def decorate
-          properties = T.unsafe(constant).properties #: ::SmartProperties::PropertyCollection
+          properties = constant.properties #: ::SmartProperties::PropertyCollection
           return if properties.keys.empty?
 
           root.create_path(constant) do |k|
@@ -101,7 +101,11 @@ def generate_methods_for_property(mod, property)
             name = property.name.to_s
             method_name = "#{name}="
 
-            mod.create_method(method_name, parameters: [create_param(name, type: type)], return_type: type)
+            mod.create_method(
+              method_name,
+              parameters: [create_param(name, type: type)],
+              return_type: type,
+            )
           end
 
           mod.create_method(property.reader.to_s, return_type: type)
@@ -112,7 +116,7 @@ def generate_methods_for_property(mod, property)
           [false, true],
         ].freeze #: Array[[bool, bool]]
 
-        #: (::SmartProperties::Property property) -> String
+        #: (::SmartProperties::Property property) -> RBI::Type
         def type_for(property)
           converter, accepter, required = property.to_h.fetch_values(
             :converter,
@@ -120,25 +124,27 @@ def type_for(property)
             :required,
           )
 
-          return "T.untyped" if converter
+          return RBI::Type.untyped if converter
 
           type = if accepter.nil? || accepter.respond_to?(:to_proc)
-            "T.untyped"
+            RBI::Type.untyped
           elsif accepter == Array
-            "T::Array[T.untyped]"
+            RBI::Type.generic("T::Array", RBI::Type.untyped)
           elsif BOOLEANS.include?(accepter)
-            "T::Boolean"
+            RBI::Type.boolean
           elsif Array(accepter).all? { |a| a.is_a?(Module) }
-            accepters = Array(accepter)
-            types = accepters.map { |mod| T.must(qualified_name_of(mod)) }.join(", ")
-            types = "T.any(#{types})" if accepters.size > 1
-            types
+            accepters = Array(accepter).map { |mod| RBI::Type.simple(T.must(qualified_name_of(mod))) }
+            if accepters.size == 1
+              accepters.first
+            else
+              RBI::Type.any(*accepters)
+            end
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
 
           might_be_optional = Proc === required || !required
-          type = as_nilable_type(type) if might_be_optional
+          type = type.nilable if might_be_optional
 
           type
         end
diff --git a/lib/tapioca/dsl/compilers/state_machines.rb b/lib/tapioca/dsl/compilers/state_machines.rb
index e24aaf074..63eede428 100644
--- a/lib/tapioca/dsl/compilers/state_machines.rb
+++ b/lib/tapioca/dsl/compilers/state_machines.rb
@@ -162,14 +162,14 @@ def gather_constants
 
         private
 
-        #: (::StateMachines::Machine machine) -> String
+        #: (::StateMachines::Machine machine) -> RBI::Type
         def state_type_for(machine)
-          value_types = machine.states.map { |state| state.value.class.name }.uniq
+          value_types = machine.states.map { |state| RBI::Type.simple(T.must(qualified_name_of(state.value.class))) }
 
-          if value_types.size == 1
-            value_types.first
+          if value_types.size > 1
+            RBI::Type.any(*value_types)
           else
-            "T.any(#{value_types.join(", ")})"
+            value_types.first
           end
         end
 
@@ -177,7 +177,7 @@ def state_type_for(machine)
         def define_activerecord_methods(instance_module)
           instance_module.create_method(
             "changed_for_autosave?",
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
           )
         end
 
@@ -186,7 +186,7 @@ def define_state_methods(instance_module, machine)
           machine.states.each do |state|
             instance_module.create_method(
               "#{state.qualified_name}?",
-              return_type: "T::Boolean",
+              return_type: RBI::Type.boolean,
             )
           end
         end
@@ -196,27 +196,27 @@ def define_event_methods(instance_module, machine)
           machine.events.each do |event|
             instance_module.create_method(
               "can_#{event.qualified_name}?",
-              return_type: "T::Boolean",
+              return_type: RBI::Type.boolean,
             )
             instance_module.create_method(
               "#{event.qualified_name}_transition",
-              parameters: [create_rest_param("args", type: "T.untyped")],
-              return_type: "T.nilable(::StateMachines::Transition)",
+              parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+              return_type: RBI::Type.simple("::StateMachines::Transition").nilable,
             )
             instance_module.create_method(
               event.qualified_name.to_s,
-              parameters: [create_rest_param("args", type: "T.untyped")],
-              return_type: "T::Boolean",
+              parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+              return_type: RBI::Type.boolean,
             )
             instance_module.create_method(
               "#{event.qualified_name}!",
-              parameters: [create_rest_param("args", type: "T.untyped")],
-              return_type: "T::Boolean",
+              parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+              return_type: RBI::Type.boolean,
             )
           end
         end
 
-        #: (RBI::Module instance_module, ::StateMachines::Machine machine, String state_type) -> void
+        #: (RBI::Module instance_module, ::StateMachines::Machine machine, RBI::Type state_type) -> void
         def define_state_accessor(instance_module, machine, state_type)
           attribute = machine.attribute.to_s
           instance_module.create_method(
@@ -234,8 +234,11 @@ def define_state_accessor(instance_module, machine, state_type)
         def define_state_predicate(instance_module, machine)
           instance_module.create_method(
             "#{machine.name}?",
-            parameters: [create_param("state", type: "T.any(String, Symbol)")],
-            return_type: "T::Boolean",
+            parameters: [create_param(
+              "state",
+              type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+            )],
+            return_type: RBI::Type.boolean,
           )
         end
 
@@ -248,40 +251,46 @@ def define_event_helpers(instance_module, machine)
 
           instance_module.create_method(
             events_attribute,
-            parameters: [create_rest_param("args", type: "T.untyped")],
-            return_type: "T::Array[T.any(String, Symbol)]",
+            parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+            return_type: RBI::Type.generic(
+              "T::Array",
+              RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+            ),
           )
           instance_module.create_method(
             transitions_attribute,
-            parameters: [create_rest_param("args", type: "T.untyped")],
-            return_type: "T::Array[::StateMachines::Transition]",
+            parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+            return_type: RBI::Type.generic("T::Array", RBI::Type.simple("::StateMachines::Transition")),
           )
           instance_module.create_method(
             "fire_#{event_attribute}",
             parameters: [
-              create_param("event", type: "T.any(String, Symbol)"),
-              create_rest_param("args", type: "T.untyped"),
+              create_param("event", type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol"))),
+              create_rest_param("args", type: RBI::Type.untyped),
             ],
-            return_type: "T::Boolean",
+            return_type: RBI::Type.boolean,
           )
           if machine.action
             instance_module.create_method(
               event_attribute,
-              return_type: "T.nilable(Symbol)",
+              return_type: RBI::Type.simple("::Symbol").nilable,
             )
             instance_module.create_method(
               "#{event_attribute}=",
-              parameters: [create_param("value", type: "T.any(String, Symbol)")],
-              return_type: "T.any(String, Symbol)",
+              parameters: [create_param(
+                "value",
+                type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+              )],
+              return_type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
             )
             instance_module.create_method(
               event_transition_attribute,
-              return_type: "T.nilable(::StateMachines::Transition)",
+              return_type: RBI::Type.simple("::StateMachines::Transition").nilable,
             )
             instance_module.create_method(
               "#{event_transition_attribute}=",
-              parameters: [create_param("value", type: "::StateMachines::Transition")],
-              return_type: "::StateMachines::Transition",
+              parameters: [create_param("value", type: RBI::Type.simple("::StateMachines::Transition"))],
+              return_type: RBI::Type.simple("::StateMachines::Transition"),
             )
           end
         end
@@ -292,8 +301,8 @@ def define_path_helpers(instance_module, machine)
 
           instance_module.create_method(
             paths_attribute,
-            parameters: [create_rest_param("args", type: "T.untyped")],
-            return_type: "T::Array[::StateMachines::Transition]",
+            parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+            return_type: RBI::Type.generic("T::Array", RBI::Type.simple("::StateMachines::Transition")),
           )
         end
 
@@ -304,21 +313,27 @@ def define_name_helpers(instance_module, class_module, machine)
 
           class_module.create_method(
             "human_#{name_attribute}",
-            parameters: [create_param("state", type: "T.any(String, Symbol)")],
-            return_type: "String",
+            parameters: [create_param(
+              "state",
+              type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+            )],
+            return_type: RBI::Type.simple("::String"),
           )
           class_module.create_method(
             "human_#{event_name_attribute}",
-            parameters: [create_param("event", type: "T.any(String, Symbol)")],
-            return_type: "String",
+            parameters: [create_param(
+              "event",
+              type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+            )],
+            return_type: RBI::Type.simple("::String"),
           )
           instance_module.create_method(
             name_attribute,
-            return_type: "T.any(String, Symbol)",
+            return_type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
           )
           instance_module.create_method(
             "human_#{name_attribute}",
-            return_type: "String",
+            return_type: RBI::Type.simple("::String"),
           )
         end
 
@@ -332,8 +347,11 @@ def define_scopes(class_module, machine)
             .each do |method|
               class_module.create_method(
                 method.to_s,
-                parameters: [create_rest_param("states", type: "T.any(String, Symbol)")],
-                return_type: "T.untyped",
+                parameters: [create_rest_param(
+                  "states",
+                  type: RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol")),
+                )],
+                return_type: RBI::Type.untyped,
               )
             end
         end
diff --git a/lib/tapioca/dsl/compilers/url_helpers.rb b/lib/tapioca/dsl/compilers/url_helpers.rb
index c9216cb35..2ccde73f4 100644
--- a/lib/tapioca/dsl/compilers/url_helpers.rb
+++ b/lib/tapioca/dsl/compilers/url_helpers.rb
@@ -171,8 +171,8 @@ def generate_module_for(root, constant)
             constant.instance_methods(false).each do |method|
               mod.create_method(
                 method.to_s,
-                parameters: [create_rest_param("args", type: "T.untyped")],
-                return_type: "String",
+                parameters: [create_rest_param("args", type: RBI::Type.untyped)],
+                return_type: RBI::Type.simple("::String"),
               )
             end
           end
diff --git a/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb b/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
index b32c57335..6b9ec7d3e 100644
--- a/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
+++ b/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
@@ -58,7 +58,7 @@ def initialize(constant, column_type_option: ColumnTypeOption::Persisted)
           @column_type_option = column_type_option
         end
 
-        #: (String attribute_name, ?String column_name) -> [String, String]
+        #: (String attribute_name, ?String column_name) -> [RBI::Type, RBI::Type]
         def type_for(attribute_name, column_name = attribute_name)
           return id_type if attribute_name == "id"
 
@@ -67,7 +67,7 @@ def type_for(attribute_name, column_name = attribute_name)
 
         private
 
-        #: -> [String, String]
+        #: -> [RBI::Type, RBI::Type]
         def id_type
           if @constant.respond_to?(:composite_primary_key?) && T.unsafe(@constant).composite_primary_key?
             primary_key_columns = @constant.primary_key
@@ -81,15 +81,15 @@ def id_type
               setters << setter
             end
 
-            ["[#{getters.join(", ")}]", "[#{setters.join(", ")}]"]
+            [RBI::Type.tuple(*getters), RBI::Type.tuple(*setters)]
           else
             column_type_for(@constant.primary_key)
           end
         end
 
-        #: (String? column_name) -> [String, String]
+        #: (String? column_name) -> [RBI::Type, RBI::Type]
         def column_type_for(column_name)
-          return ["T.untyped", "T.untyped"] if @column_type_option.untyped?
+          return [RBI::Type.untyped, RBI::Type.untyped] if @column_type_option.untyped?
 
           column = @constant.columns_hash[column_name]
           column_type = @constant.attribute_types[column_name]
@@ -105,47 +105,47 @@ def column_type_for(column_name)
           if @column_type_option.persisted? && !column&.null
             [getter_type, setter_type]
           else
-            getter_type = as_nilable_type(getter_type) unless not_nilable_serialized_column?(column_type)
-            [getter_type, as_nilable_type(setter_type)]
+            getter_type = getter_type.nilable unless not_nilable_serialized_column?(column_type)
+            [getter_type, setter_type.nilable]
           end
         end
 
-        #: (untyped column_type, column_nullability: bool) -> String
+        #: (untyped column_type, column_nullability: bool) -> RBI::Type
         def type_for_activerecord_value(column_type, column_nullability:)
           case column_type
           when ->(type) { defined?(MoneyColumn) && MoneyColumn::ActiveRecordType === type }
-            "::Money"
+            RBI::Type.simple("::Money")
           when ActiveRecord::Type::Integer
-            "::Integer"
+            RBI::Type.simple("::Integer")
           when ->(type) {
                  defined?(ActiveRecord::Encryption) && ActiveRecord::Encryption::EncryptedAttributeType === type
                }
             # Reflect to see if `ActiveModel::Type::Value` is being used first.
-            getter_type = Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(column_type)
+            getter_type = RBI::Type.parse_string(Tapioca::Dsl::Helpers::ActiveModelTypeHelper.type_for(column_type))
 
             # Fallback to String as `ActiveRecord::Encryption::EncryptedAttributeType` inherits from
             # `ActiveRecord::Type::Text` which inherits from `ActiveModel::Type::String`.
-            return "::String" if getter_type == "T.untyped"
+            return RBI::Type.simple("::String") if getter_type == RBI::Type.untyped
 
             as_non_nilable_if_persisted_and_not_nullable(getter_type, column_nullability:)
           when ActiveRecord::Type::String
-            "::String"
+            RBI::Type.simple("::String")
           when ActiveRecord::Type::Date
-            "::Date"
+            RBI::Type.simple("::Date")
           when ActiveRecord::Type::Decimal
-            "::BigDecimal"
+            RBI::Type.simple("::BigDecimal")
           when ActiveRecord::Type::Float
-            "::Float"
+            RBI::Type.simple("::Float")
           when ActiveRecord::Type::Boolean
-            "T::Boolean"
+            RBI::Type.boolean
           when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-            "::Time"
+            RBI::Type.simple("::Time")
           when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-            "::ActiveSupport::TimeWithZone"
+            RBI::Type.simple("::ActiveSupport::TimeWithZone")
           when ActiveRecord::Enum::EnumType
-            "::String"
+            RBI::Type.simple("::String")
           when ActiveRecord::Type::Binary
-            "::String"
+            RBI::Type.simple("::String")
           when ActiveRecord::Type::Serialized
             serialized_column_type(column_type)
           when ->(type) {
@@ -159,61 +159,61 @@ def type_for_activerecord_value(column_type, column_nullability:)
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid === type
                }
-            "::String"
+            RBI::Type.simple("::String")
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Cidr === type
                }
-            "::IPAddr"
+            RBI::Type.simple("::IPAddr")
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore === type
                }
-            "T::Hash[::String, ::String]"
+            RBI::Type.generic("T::Hash", RBI::Type.simple("::String"), RBI::Type.simple("::String"))
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Interval) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Interval === type
                }
-            "::ActiveSupport::Duration"
+            RBI::Type.simple("::ActiveSupport::Duration")
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array === type
                }
-            "T::Array[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
+            RBI::Type.generic("T::Array", type_for_activerecord_value(column_type.subtype, column_nullability:))
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bit) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bit === type
                }
-            "::String"
+            RBI::Type.simple("::String")
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::BitVarying) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::BitVarying === type
                }
-            "::String"
+            RBI::Type.simple("::String")
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range === type
                }
-            "T::Range[#{type_for_activerecord_value(column_type.subtype, column_nullability:)}]"
+            RBI::Type.generic("T::Range", type_for_activerecord_value(column_type.subtype, column_nullability:))
           when ->(type) {
                  defined?(ActiveRecord::Locking::LockingType) &&
                    ActiveRecord::Locking::LockingType === type
                }
-            as_non_nilable_if_persisted_and_not_nullable("::Integer", column_nullability:)
+            as_non_nilable_if_persisted_and_not_nullable(RBI::Type.simple("::Integer"), column_nullability:)
           when ->(type) {
                  defined?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum) &&
                    ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Enum === type
                }
-            "::String"
+            RBI::Type.simple("::String")
           else
             as_non_nilable_if_persisted_and_not_nullable(
-              ActiveModelTypeHelper.type_for(column_type),
+              RBI::Type.parse_string(ActiveModelTypeHelper.type_for(column_type)),
               column_nullability: column_nullability,
             )
           end
         end
 
-        #: (String base_type, column_nullability: bool) -> String
+        #: (RBI::Type base_type, column_nullability: bool) -> RBI::Type
         def as_non_nilable_if_persisted_and_not_nullable(base_type, column_nullability:)
           # It's possible that when ActiveModel::Type::Value is used, the signature being reflected on in
           # ActiveModelTypeHelper.type_for(type_value) may say the type can be nilable. However, if the type is
@@ -223,31 +223,31 @@ def as_non_nilable_if_persisted_and_not_nullable(base_type, column_nullability:)
           base_type
         end
 
-        #: (ActiveRecord::Enum::EnumType column_type) -> String
+        #: (ActiveRecord::Enum::EnumType column_type) -> RBI::Type
         def enum_setter_type(column_type)
           # In Rails < 7 this method is private. When support for that is dropped we can call the method directly
           case column_type.send(:subtype)
           when ActiveRecord::Type::Integer
-            "T.any(::String, ::Symbol, ::Integer)"
+            RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol"), RBI::Type.simple("::Integer"))
           else
-            "T.any(::String, ::Symbol)"
+            RBI::Type.any(RBI::Type.simple("::String"), RBI::Type.simple("::Symbol"))
           end
         end
 
-        #: (ActiveRecord::Type::Serialized column_type) -> String
+        #: (ActiveRecord::Type::Serialized column_type) -> RBI::Type
         def serialized_column_type(column_type)
           case column_type.coder
           when ActiveRecord::Coders::YAMLColumn
             case column_type.coder.object_class
             when Array.singleton_class
-              "T::Array[T.untyped]"
+              RBI::Type.generic("T::Array", RBI::Type.untyped)
             when Hash.singleton_class
-              "T::Hash[T.untyped, T.untyped]"
+              RBI::Type.generic("T::Hash", RBI::Type.untyped, RBI::Type.untyped)
             else
-              "T.untyped"
+              RBI::Type.untyped
             end
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
         end
 
diff --git a/lib/tapioca/dsl/helpers/graphql_type_helper.rb b/lib/tapioca/dsl/helpers/graphql_type_helper.rb
index 4a4e6ba9a..8137eecc1 100644
--- a/lib/tapioca/dsl/helpers/graphql_type_helper.rb
+++ b/lib/tapioca/dsl/helpers/graphql_type_helper.rb
@@ -10,7 +10,7 @@ module GraphqlTypeHelper
         #: (
         #|   GraphQL::Schema::Argument argument,
         #|   (singleton(GraphQL::Schema::Mutation) | singleton(GraphQL::Schema::InputObject)) constant
-        #| ) -> String
+        #| ) -> RBI::Type
         def type_for_argument(argument, constant)
           type = if argument.loads
             loads_type = ::GraphQL::Schema::Wrapper.new(argument.loads)
@@ -47,25 +47,25 @@ def type_for_argument(argument, constant)
         #|   ) type,
         #|   ?ignore_nilable_wrapper: bool,
         #|   ?prepare_method: Method?
-        #| ) -> String
+        #| ) -> RBI::Type
         def type_for(type, ignore_nilable_wrapper: false, prepare_method: nil)
           unwrapped_type = type.unwrap
 
           parsed_type = case unwrapped_type
           when GraphQL::Types::Boolean.singleton_class
-            "T::Boolean"
+            RBI::Type.boolean
           when GraphQL::Types::Float.singleton_class
-            type_for_constant(Float)
+            RBI::Type.simple("::Float")
           when GraphQL::Types::ID.singleton_class, GraphQL::Types::String.singleton_class
             type_for_constant(String)
           when GraphQL::Types::Int.singleton_class, GraphQL::Types::BigInt.singleton_class
             type_for_constant(Integer)
           when GraphQL::Types::ISO8601Date.singleton_class
-            type_for_constant(Date)
+            RBI::Type.simple("::Date")
           when GraphQL::Types::ISO8601DateTime.singleton_class
-            type_for_constant(Time)
+            RBI::Type.simple("::Time")
           when GraphQL::Types::JSON.singleton_class
-            "T::Hash[::String, T.untyped]"
+            RBI::Type.generic("T::Hash", RBI::Type.simple("::String"), RBI::Type.untyped)
           when GraphQL::Schema::Enum.singleton_class
             enum_values = T.cast(unwrapped_type.enum_values, T::Array[GraphQL::Schema::EnumValue])
             value_types = enum_values.map { |v| type_for_constant(v.value.class) }.uniq
@@ -73,36 +73,41 @@ def type_for(type, ignore_nilable_wrapper: false, prepare_method: nil)
             if value_types.size == 1
               T.must(value_types.first)
             else
-              "T.any(#{value_types.join(", ")})"
+              RBI::Type.any(*value_types)
             end
           when GraphQL::Schema::Scalar.singleton_class
             method = Runtime::Reflection.method_of(unwrapped_type, :coerce_input)
             signature = Runtime::Reflection.signature_of(method)
             return_type = signature&.return_type
 
-            valid_return_type?(return_type) ? return_type.to_s : "T.untyped"
+            valid_return_type?(return_type) ? RBI::Type.parse_string(return_type.to_s) : RBI::Type.untyped
           when GraphQL::Schema::InputObject.singleton_class
             type_for_constant(unwrapped_type)
           when Module
-            Runtime::Reflection.qualified_name_of(unwrapped_type) || "T.untyped"
+            name = Runtime::Reflection.qualified_name_of(unwrapped_type)
+            if name
+              RBI::Type.simple(name)
+            else
+              RBI::Type.untyped
+            end
           else
-            "T.untyped"
+            RBI::Type.untyped
           end
 
           if prepare_method
             prepare_signature = Runtime::Reflection.signature_of(prepare_method)
             prepare_return_type = prepare_signature&.return_type
             if valid_return_type?(prepare_return_type)
-              parsed_type = prepare_return_type&.to_s
+              parsed_type = RBI::Type.parse_string(prepare_return_type.to_s)
             end
           end
 
           if type.list?
-            parsed_type = "T::Array[#{parsed_type}]"
+            parsed_type = RBI::Type.generic("T::Array", parsed_type)
           end
 
           unless type.non_null? || ignore_nilable_wrapper
-            parsed_type = RBIHelper.as_nilable_type(parsed_type)
+            parsed_type = parsed_type.nilable
           end
 
           parsed_type
@@ -110,17 +115,25 @@ def type_for(type, ignore_nilable_wrapper: false, prepare_method: nil)
 
         private
 
-        #: (T::Module[top] constant) -> String
+        #: (T::Module[top] constant) -> RBI::Type
         def type_for_constant(constant)
           if constant.instance_methods.include?(:prepare)
             prepare_method = constant.instance_method(:prepare)
 
             prepare_signature = Runtime::Reflection.signature_of(prepare_method)
+            prepare_return_type = prepare_signature&.return_type
 
-            return prepare_signature.return_type&.to_s if valid_return_type?(prepare_signature&.return_type)
+            if valid_return_type?(prepare_return_type)
+              return RBI::Type.parse_string(prepare_return_type.to_s)
+            end
           end
 
-          Runtime::Reflection.qualified_name_of(constant) || "T.untyped"
+          name = Runtime::Reflection.qualified_name_of(constant)
+          if name
+            RBI::Type.simple(name)
+          else
+            RBI::Type.untyped
+          end
         end
 
         #: (GraphQL::Schema::Argument argument) -> bool
diff --git a/lib/tapioca/helpers/rbi_helper.rb b/lib/tapioca/helpers/rbi_helper.rb
index 273e422bd..a4cfd2485 100644
--- a/lib/tapioca/helpers/rbi_helper.rb
+++ b/lib/tapioca/helpers/rbi_helper.rb
@@ -8,7 +8,7 @@ module RBIHelper
     extend self
 
     class << self
-      #: (String type, Symbol variance, String? fixed, String? upper, String? lower) -> String
+      #: (String type, Symbol variance, RBI::Type? fixed, RBI::Type? upper, RBI::Type? lower) -> String
       def serialize_type_variable(type, variance, fixed, upper, lower)
         variance = nil if variance == :invariant
 
@@ -27,44 +27,44 @@ def serialize_type_variable(type, variance, fixed, upper, lower)
       end
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type) -> RBI::TypedParam
     def create_param(name, type:)
       create_typed_param(RBI::ReqParam.new(name), type)
     end
 
-    #: (String name, type: String, default: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type, default: String) -> RBI::TypedParam
     def create_opt_param(name, type:, default:)
       create_typed_param(RBI::OptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type) -> RBI::TypedParam
     def create_rest_param(name, type:)
       create_typed_param(RBI::RestParam.new(name), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type) -> RBI::TypedParam
     def create_kw_param(name, type:)
       create_typed_param(RBI::KwParam.new(name), type)
     end
 
-    #: (String name, type: String, default: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type, default: String) -> RBI::TypedParam
     def create_kw_opt_param(name, type:, default:)
       create_typed_param(RBI::KwOptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type) -> RBI::TypedParam
     def create_kw_rest_param(name, type:)
       create_typed_param(RBI::KwRestParam.new(name), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String name, type: RBI::Type) -> RBI::TypedParam
     def create_block_param(name, type:)
       create_typed_param(RBI::BlockParam.new(name), type)
     end
 
-    #: (RBI::Param param, String type) -> RBI::TypedParam
+    #: (RBI::Param param, RBI::Type type) -> RBI::TypedParam
     def create_typed_param(param, type)
-      RBI::TypedParam.new(param: param, type: sanitize_signature_types(type))
+      RBI::TypedParam.new(param: param, type: type)
     end
 
     #: (String sig_string) -> String
@@ -76,19 +76,15 @@ def sanitize_signature_types(sig_string)
         .gsub(".params()", "")
     end
 
-    #: (String type) -> String
+    #: (RBI::Type type) -> RBI::Type
     def as_nilable_type(type)
-      if type.start_with?("T.nilable(", "::T.nilable(") || type == "T.untyped" || type == "::T.untyped"
-        type
-      else
-        "T.nilable(#{type})"
-      end
+      type.nilable
     end
 
-    #: (String type) -> String
+    #: (RBI::Type type) -> RBI::Type
     def as_non_nilable_type(type)
-      if type.match(/\A(?:::)?T.nilable\((.+)\)\z/)
-        T.must(::Regexp.last_match(1))
+      if type.nilable?
+        type.non_nilable
       else
         type
       end
diff --git a/lib/tapioca/rbi_ext/model.rb b/lib/tapioca/rbi_ext/model.rb
index 31dca1108..b7e16357b 100644
--- a/lib/tapioca/rbi_ext/model.rb
+++ b/lib/tapioca/rbi_ext/model.rb
@@ -53,7 +53,7 @@ def create_mixes_in_class_methods(name)
       create_node(RBI::MixesInClassMethods.new(name))
     end
 
-    #: (String name, type: String, ?variance: Symbol, ?fixed: String?, ?upper: String?, ?lower: String?) -> void
+    #: (String name, type: String, ?variance: Symbol, ?fixed: RBI::Type?, ?upper: RBI::Type?, ?lower: RBI::Type?) -> void
     def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: nil, lower: nil)
       value = Tapioca::RBIHelper.serialize_type_variable(type, variance, fixed, upper, lower)
       create_node(RBI::TypeMember.new(name, value))
@@ -62,7 +62,7 @@ def create_type_variable(name, type:, variance: :invariant, fixed: nil, upper: n
     #: (
     #|   String name,
     #|   ?parameters: Array[TypedParam],
-    #|   ?return_type: String?,
+    #|   ?return_type: RBI::Type?,
     #|   ?class_method: bool,
     #|   ?visibility: RBI::Visibility,
     #|   ?comments: Array[RBI::Comment]
@@ -77,7 +77,7 @@ def create_method(name, parameters: [], return_type: nil, class_method: false, v
         # If there is no block, and the params and return type have not been supplied, then
         # we create a single signature with the given parameters and return type
         params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
-        sigs << RBI::Sig.new(params: params, return_type: return_type || "T.untyped")
+        sigs << RBI::Sig.new(params: params, return_type: return_type || RBI::Type.untyped)
       end
 
       method = RBI::Method.new(
@@ -112,6 +112,6 @@ def create_node(node)
 
   class TypedParam < T::Struct
     const :param, RBI::Param
-    const :type, String
+    const :type, RBI::Type
   end
 end
diff --git a/sorbet/rbi/gems/racc@1.8.1.rbi b/sorbet/rbi/gems/racc@1.8.1.rbi
index 3093bab7a..3dbd3eeae 100644
--- a/sorbet/rbi/gems/racc@1.8.1.rbi
+++ b/sorbet/rbi/gems/racc@1.8.1.rbi
@@ -144,13 +144,9 @@ end
 # pkg:gem/racc#lib/racc/parser.rb:205
 Racc::Parser::Racc_Main_Parsing_Routine = T.let(T.unsafe(nil), Symbol)
 
-Racc::Parser::Racc_Runtime_Core_Id_C = T.let(T.unsafe(nil), String)
-
 # pkg:gem/racc#lib/racc/parser.rb:207
 Racc::Parser::Racc_Runtime_Core_Version = T.let(T.unsafe(nil), String)
 
-Racc::Parser::Racc_Runtime_Core_Version_C = T.let(T.unsafe(nil), String)
-
 # pkg:gem/racc#lib/racc/parser.rb:187
 Racc::Parser::Racc_Runtime_Core_Version_R = T.let(T.unsafe(nil), String)
 
diff --git a/spec/tapioca/dsl/compilers/aasm_spec.rb b/spec/tapioca/dsl/compilers/aasm_spec.rb
index 47da87e3d..4230f050e 100644
--- a/spec/tapioca/dsl/compilers/aasm_spec.rb
+++ b/spec/tapioca/dsl/compilers/aasm_spec.rb
@@ -79,13 +79,13 @@ def cleaning?; end
                   sig { returns(T::Boolean) }
                   def may_run?; end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run!(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run_without_validation!(*opts); end
 
                   sig { returns(T::Boolean) }
@@ -95,85 +95,85 @@ def running?; end
                   def sleeping?; end
 
                   class << self
-                    sig { params(args: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
+                    sig { params(args: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
                     def aasm(*args, &block); end
                   end
 
                   class PrivateAASMMachine < AASM::Base
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transitions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def ensure_on_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def error_on_all_events(*callbacks, &block); end
 
-                    sig { params(name: T.untyped, options: T.untyped, block: T.proc.bind(PrivateAASMEvent).void).returns(T.untyped) }
+                    sig { params(name: ::T.untyped, options: ::T.untyped, block: ::T.proc.bind(PrivateAASMEvent).void).returns(::T.untyped) }
                     def event(name, options = nil, &block); end
 
                     class PrivateAASMEvent < AASM::Core::Event
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_commit(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_success(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def ensure(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def error(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(symbol = nil, &block); end
 
-                      sig { params(definitions: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMTransition).void)).returns(T.untyped) }
+                      sig { params(definitions: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMTransition).void)).returns(::T.untyped) }
                       def transitions(definitions = nil, &block); end
                     end
 
                     class PrivateAASMTransition < AASM::Core::Transition
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T::Boolean) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(T::Boolean) }
                       def guard(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def on_transition(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(&block); end
                     end
                   end
 
-                  STATE_CLEANING = T.let(T.unsafe(nil), Symbol)
-                  STATE_RUNNING = T.let(T.unsafe(nil), Symbol)
-                  STATE_SLEEPING = T.let(T.unsafe(nil), Symbol)
+                  STATE_CLEANING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_RUNNING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_SLEEPING = T.let(T.unsafe(nil), ::Symbol)
                 end
               RBI
 
@@ -220,13 +220,13 @@ def existing?; end
                   sig { returns(T::Boolean) }
                   def may_run?; end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run!(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run_without_validation!(*opts); end
 
                   sig { returns(T::Boolean) }
@@ -236,86 +236,86 @@ def running?; end
                   def sleeping?; end
 
                   class << self
-                    sig { params(args: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
+                    sig { params(args: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
                     def aasm(*args, &block); end
                   end
 
                   class PrivateAASMMachine < AASM::Base
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transitions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def ensure_on_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def error_on_all_events(*callbacks, &block); end
 
-                    sig { params(name: T.untyped, options: T.untyped, block: T.proc.bind(PrivateAASMEvent).void).returns(T.untyped) }
+                    sig { params(name: ::T.untyped, options: ::T.untyped, block: ::T.proc.bind(PrivateAASMEvent).void).returns(::T.untyped) }
                     def event(name, options = nil, &block); end
 
                     class PrivateAASMEvent < AASM::Core::Event
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_commit(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_success(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def ensure(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def error(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(symbol = nil, &block); end
 
-                      sig { params(definitions: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMTransition).void)).returns(T.untyped) }
+                      sig { params(definitions: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMTransition).void)).returns(::T.untyped) }
                       def transitions(definitions = nil, &block); end
                     end
 
                     class PrivateAASMTransition < AASM::Core::Transition
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T::Boolean) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(T::Boolean) }
                       def guard(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def on_transition(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(&block); end
                     end
                   end
 
-                  STATE_CLEANING = T.let(T.unsafe(nil), Symbol)
-                  STATE_EXISTING = T.let(T.unsafe(nil), Symbol)
-                  STATE_RUNNING = T.let(T.unsafe(nil), Symbol)
-                  STATE_SLEEPING = T.let(T.unsafe(nil), Symbol)
+                  STATE_CLEANING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_EXISTING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_RUNNING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_SLEEPING = T.let(T.unsafe(nil), ::Symbol)
                 end
               RBI
 
@@ -364,101 +364,101 @@ def may_run?; end
                   sig { returns(T::Boolean) }
                   def may_run_foo?; end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run!(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run_foo(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run_foo!(*opts); end
 
-                  sig { params(opts: T.untyped).returns(T.untyped) }
+                  sig { params(opts: ::T.untyped).returns(::T.untyped) }
                   def run_without_validation!(*opts); end
 
                   class << self
-                    sig { params(args: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
+                    sig { params(args: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMMachine).void)).returns(PrivateAASMMachine) }
                     def aasm(*args, &block); end
                   end
 
                   class PrivateAASMMachine < AASM::Base
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def after_all_transitions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def before_all_transactions(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def ensure_on_all_events(*callbacks, &block); end
 
-                    sig { params(callbacks: T.any(String, Symbol, T::Class[T.anything], Proc), block: T.nilable(T.proc.bind(StateMachine).void)).returns(T.untyped) }
+                    sig { params(callbacks: ::T.any(String, Symbol, T::Class[::T.anything], ::T.proc.void), block: ::T.nilable(::T.proc.bind(StateMachine).void)).returns(::T.untyped) }
                     def error_on_all_events(*callbacks, &block); end
 
-                    sig { params(name: T.untyped, options: T.untyped, block: T.proc.bind(PrivateAASMEvent).void).returns(T.untyped) }
+                    sig { params(name: ::T.untyped, options: ::T.untyped, block: ::T.proc.bind(PrivateAASMEvent).void).returns(::T.untyped) }
                     def event(name, options = nil, &block); end
 
                     class PrivateAASMEvent < AASM::Core::Event
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_commit(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_success(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def before_transaction(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def ensure(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def error(symbol = nil, &block); end
 
-                      sig { params(symbol: T.nilable(Symbol), block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(symbol: ::T.nilable(::Symbol), block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(symbol = nil, &block); end
 
-                      sig { params(definitions: T.untyped, block: T.nilable(T.proc.bind(PrivateAASMTransition).void)).returns(T.untyped) }
+                      sig { params(definitions: ::T.untyped, block: ::T.nilable(::T.proc.bind(PrivateAASMTransition).void)).returns(::T.untyped) }
                       def transitions(definitions = nil, &block); end
                     end
 
                     class PrivateAASMTransition < AASM::Core::Transition
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def after(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T::Boolean) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(T::Boolean) }
                       def guard(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def on_transition(&block); end
 
-                      sig { params(block: T.nilable(T.proc.bind(StateMachine).params(opts: T.untyped).void)).returns(T.untyped) }
+                      sig { params(block: ::T.nilable(::T.proc.bind(StateMachine).params(opts: ::T.untyped).void)).returns(::T.untyped) }
                       def success(&block); end
                     end
                   end
 
-                  STATE_FOO_CLEANING = T.let(T.unsafe(nil), Symbol)
-                  STATE_FOO_RUNNING = T.let(T.unsafe(nil), Symbol)
-                  STATE_FOO_SLEEPING = T.let(T.unsafe(nil), Symbol)
+                  STATE_FOO_CLEANING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_FOO_RUNNING = T.let(T.unsafe(nil), ::Symbol)
+                  STATE_FOO_SLEEPING = T.let(T.unsafe(nil), ::Symbol)
                 end
               RBI
 
diff --git a/spec/tapioca/dsl/compilers/action_controller_helpers_spec.rb b/spec/tapioca/dsl/compilers/action_controller_helpers_spec.rb
index f73d31717..8926008e0 100644
--- a/spec/tapioca/dsl/compilers/action_controller_helpers_spec.rb
+++ b/spec/tapioca/dsl/compilers/action_controller_helpers_spec.rb
@@ -124,10 +124,10 @@ def helpers; end
                   module HelperMethods
                     include ::ActionController::Base::HelperMethods
 
-                    sig { params(args: T.untyped, kwargs: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, kwargs: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def current_user_name(*args, **kwargs, &blk); end
 
-                    sig { params(args: T.untyped, kwargs: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, kwargs: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def notify_user(*args, **kwargs, &blk); end
                   end
 
@@ -169,7 +169,7 @@ def helpers; end
                   module HelperMethods
                     include ::ActionController::Base::HelperMethods
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def current_user_name; end
 
                     sig { params(user_id: ::Integer).void }
@@ -214,7 +214,7 @@ def helpers; end
                   module HelperMethods
                     include ::ActionController::Base::HelperMethods
 
-                    sig { params(user: T.untyped).returns(T.untyped) }
+                    sig { params(user: ::T.untyped).returns(::T.untyped) }
                     def greet(user); end
 
                     sig { params(user_id: ::Integer).void }
@@ -352,7 +352,7 @@ def helpers; end
                   module HelperMethods
                     include ::ActionController::Base::HelperMethods
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def foo; end
                   end
 
diff --git a/spec/tapioca/dsl/compilers/action_mailer_spec.rb b/spec/tapioca/dsl/compilers/action_mailer_spec.rb
index b606c4452..955a178ed 100644
--- a/spec/tapioca/dsl/compilers/action_mailer_spec.rb
+++ b/spec/tapioca/dsl/compilers/action_mailer_spec.rb
@@ -86,7 +86,7 @@ def notify_customer(customer_id)
 
                 class NotifierMailer
                   class << self
-                    sig { params(customer_id: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(customer_id: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_customer(customer_id); end
                   end
                 end
@@ -134,10 +134,10 @@ def notify_admin(...); end
 
                 class NotifierMailer
                   class << self
-                    sig { params(_arg0: T.untyped, _arg1: T.untyped, _arg2: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(_arg0: ::T.untyped, _arg1: ::T.untyped, _arg2: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_admin(*_arg0, **_arg1, &_arg2); end
 
-                    sig { params(_arg0: T.untyped, _arg1: T.untyped, _arg2: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(_arg0: ::T.untyped, _arg1: ::T.untyped, _arg2: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_customer(*_arg0, **_arg1, &_arg2); end
                   end
                 end
@@ -168,7 +168,7 @@ def notify_customer(customer_id)
 
                 class NotifierMailer
                   class << self
-                    sig { params(customer_id: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(customer_id: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_customer(customer_id); end
                   end
                 end
@@ -194,7 +194,7 @@ class SecondaryMailer < NotifierMailer
 
                 class SecondaryMailer
                   class << self
-                    sig { params(customer_id: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(customer_id: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_customer(customer_id); end
                   end
                 end
@@ -233,7 +233,7 @@ class << self
                     sig { returns(::ActionMailer::MessageDelivery) }
                     def foo_helper_method; end
 
-                    sig { params(customer_id: T.untyped).returns(::ActionMailer::MessageDelivery) }
+                    sig { params(customer_id: ::T.untyped).returns(::ActionMailer::MessageDelivery) }
                     def notify_customer(customer_id); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/action_text_spec.rb b/spec/tapioca/dsl/compilers/action_text_spec.rb
index e49071b2a..055ce7437 100644
--- a/spec/tapioca/dsl/compilers/action_text_spec.rb
+++ b/spec/tapioca/dsl/compilers/action_text_spec.rb
@@ -61,7 +61,7 @@ class Post
                   sig { returns(ActionText::RichText) }
                   def body; end
 
-                  sig { params(value: T.nilable(T.any(ActionText::RichText, String))).returns(T.untyped) }
+                  sig { params(value: ::T.nilable(::T.any(ActionText::RichText, ::String))).returns(::T.untyped) }
                   def body=(value); end
 
                   sig { returns(T::Boolean) }
@@ -70,7 +70,7 @@ def body?; end
                   sig { returns(ActionText::RichText) }
                   def title; end
 
-                  sig { params(value: T.nilable(T.any(ActionText::RichText, String))).returns(T.untyped) }
+                  sig { params(value: ::T.nilable(::T.any(ActionText::RichText, ::String))).returns(::T.untyped) }
                   def title=(value); end
 
                   sig { returns(T::Boolean) }
@@ -97,7 +97,7 @@ class Post
                   sig { returns(ActionText::EncryptedRichText) }
                   def body; end
 
-                  sig { params(value: T.nilable(T.any(ActionText::EncryptedRichText, String))).returns(T.untyped) }
+                  sig { params(value: ::T.nilable(::T.any(ActionText::EncryptedRichText, ::String))).returns(::T.untyped) }
                   def body=(value); end
 
                   sig { returns(T::Boolean) }
diff --git a/spec/tapioca/dsl/compilers/active_job_spec.rb b/spec/tapioca/dsl/compilers/active_job_spec.rb
index aa47ab272..2c7b896f8 100644
--- a/spec/tapioca/dsl/compilers/active_job_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_job_spec.rb
@@ -73,10 +73,10 @@ def perform(user_id)
 
                 class NotifyJob
                   class << self
-                    sig { params(user_id: T.untyped, block: T.nilable(T.proc.params(job: NotifyJob).void)).returns(T.any(NotifyJob, FalseClass)) }
+                    sig { params(user_id: ::T.untyped, block: ::T.nilable(::T.proc.params(job: NotifyJob).void)).returns(::T.any(::NotifyJob, ::FalseClass)) }
                     def perform_later(user_id, &block); end
 
-                    sig { params(user_id: T.untyped).returns(T.untyped) }
+                    sig { params(user_id: ::T.untyped).returns(::T.untyped) }
                     def perform_now(user_id); end
                   end
                 end
@@ -100,7 +100,7 @@ def perform(user_id)
 
                 class NotifyJob
                   class << self
-                    sig { params(user_id: ::Integer, block: T.nilable(T.proc.params(job: NotifyJob).void)).returns(T.any(NotifyJob, FalseClass)) }
+                    sig { params(user_id: ::Integer, block: ::T.nilable(::T.proc.params(job: NotifyJob).void)).returns(::T.any(::NotifyJob, ::FalseClass)) }
                     def perform_later(user_id, &block); end
 
                     sig { params(user_id: ::Integer).void }
@@ -125,10 +125,10 @@ def perform(user_id, &blk)
 
                 class NotifyJob
                   class << self
-                    sig { params(user_id: T.untyped, block: T.nilable(T.proc.params(job: NotifyJob).void)).returns(T.any(NotifyJob, FalseClass)) }
+                    sig { params(user_id: ::T.untyped, block: ::T.nilable(::T.proc.params(job: NotifyJob).void)).returns(::T.any(::NotifyJob, ::FalseClass)) }
                     def perform_later(user_id, &block); end
 
-                    sig { params(user_id: T.untyped).returns(T.untyped) }
+                    sig { params(user_id: ::T.untyped).returns(::T.untyped) }
                     def perform_now(user_id); end
                   end
                 end
@@ -153,7 +153,7 @@ def perform(user_id)
 
                 class NotifyJob
                   class << self
-                    sig { params(user_id: ::Integer, block: T.nilable(T.proc.params(job: NotifyJob).void)).returns(T.any(NotifyJob, FalseClass)) }
+                    sig { params(user_id: ::Integer, block: ::T.nilable(::T.proc.params(job: NotifyJob).void)).returns(::T.any(::NotifyJob, ::FalseClass)) }
                     def perform_later(user_id, &block); end
 
                     sig { params(user_id: ::Integer).void }
diff --git a/spec/tapioca/dsl/compilers/active_model_attributes_spec.rb b/spec/tapioca/dsl/compilers/active_model_attributes_spec.rb
index 8a737469d..33ab0e8ec 100644
--- a/spec/tapioca/dsl/compilers/active_model_attributes_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_model_attributes_spec.rb
@@ -73,10 +73,10 @@ class Shop
                   include GeneratedAttributeMethods
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def name; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def name=(value); end
                   end
                 end
@@ -102,10 +102,10 @@ class Shop
                   include GeneratedAttributeMethods
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def name; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def name=(value); end
                   end
                 end
@@ -134,34 +134,34 @@ class Shop
                   include GeneratedAttributeMethods
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::Time)) }
+                    sig { returns(::T.nilable(::Time)) }
                     def created_at; end
 
-                    sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+                    sig { params(value: ::T.nilable(::Time)).returns(::T.nilable(::Time)) }
                     def created_at=(value); end
 
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def id; end
 
-                    sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                    sig { params(value: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                     def id=(value); end
 
-                    sig { returns(T.nilable(::Float)) }
+                    sig { returns(::T.nilable(::Float)) }
                     def latitude; end
 
-                    sig { params(value: T.nilable(::Float)).returns(T.nilable(::Float)) }
+                    sig { params(value: ::T.nilable(::Float)).returns(::T.nilable(::Float)) }
                     def latitude=(value); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def name; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def name=(value); end
 
-                    sig { returns(T.nilable(T::Boolean)) }
+                    sig { returns(::T.nilable(T::Boolean)) }
                     def test_shop; end
 
-                    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+                    sig { params(value: ::T.nilable(T::Boolean)).returns(::T.nilable(T::Boolean)) }
                     def test_shop=(value); end
                   end
                 end
@@ -194,10 +194,10 @@ class Shop
                   include GeneratedAttributeMethods
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def custom_with_cast_sig_attr; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def custom_with_cast_sig_attr=(value); end
                   end
                 end
@@ -240,10 +240,10 @@ class Shop
                   include GeneratedAttributeMethods
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def post; end
 
-                    sig { params(value: T.nilable(::Post)).returns(T.nilable(::Post)) }
+                    sig { params(value: ::T.nilable(::Post)).returns(::T.nilable(::Post)) }
                     def post=(value); end
 
                     sig { returns(::User) }
diff --git a/spec/tapioca/dsl/compilers/active_model_secure_password_spec.rb b/spec/tapioca/dsl/compilers/active_model_secure_password_spec.rb
index d73621a31..a757766e1 100644
--- a/spec/tapioca/dsl/compilers/active_model_secure_password_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_model_secure_password_spec.rb
@@ -67,34 +67,34 @@ class User
                 # typed: strong
 
                 class User
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate(unencrypted_password); end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate_password(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password; end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.untyped) }
                   def password=(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_challenge; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def password_challenge=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_confirmation; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def password_confirmation=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_reset_token; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_salt; end
                 end
               RBI
@@ -115,31 +115,31 @@ class User
                 # typed: strong
 
                 class User
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate_token(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token; end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.untyped) }
                   def token=(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_challenge; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def token_challenge=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_confirmation; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def token_confirmation=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_reset_token; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_salt; end
                 end
               RBI
@@ -161,61 +161,61 @@ class User
                 # typed: strong
 
                 class User
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate(unencrypted_password); end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate_password(unencrypted_password); end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.any(User, FalseClass)) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.any(::User, T::Boolean)) }
                   def authenticate_token(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password; end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.untyped) }
                   def password=(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_challenge; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def password_challenge=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_confirmation; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def password_confirmation=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_reset_token; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_salt; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token; end
 
-                  sig { params(unencrypted_password: T.untyped).returns(T.untyped) }
+                  sig { params(unencrypted_password: ::T.untyped).returns(::T.untyped) }
                   def token=(unencrypted_password); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_challenge; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def token_challenge=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_confirmation; end
 
-                  sig { params(_arg0: T.untyped).returns(T.untyped) }
+                  sig { params(_arg0: ::T.untyped).returns(::T.untyped) }
                   def token_confirmation=(_arg0); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_reset_token; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def token_salt; end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/active_model_validations_confirmation_spec.rb b/spec/tapioca/dsl/compilers/active_model_validations_confirmation_spec.rb
index a2d269f13..7d48a841e 100644
--- a/spec/tapioca/dsl/compilers/active_model_validations_confirmation_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_model_validations_confirmation_spec.rb
@@ -68,16 +68,16 @@ class Shop
                 # typed: strong
 
                 class Shop
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def name_confirmation; end
 
-                  sig { params(name_confirmation: T.untyped).returns(T.untyped) }
+                  sig { params(name_confirmation: ::T.untyped).returns(::T.untyped) }
                   def name_confirmation=(name_confirmation); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def password_confirmation; end
 
-                  sig { params(password_confirmation: T.untyped).returns(T.untyped) }
+                  sig { params(password_confirmation: ::T.untyped).returns(::T.untyped) }
                   def password_confirmation=(password_confirmation); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/active_record_associations_spec.rb b/spec/tapioca/dsl/compilers/active_record_associations_spec.rb
index 5999f9439..c86a081a9 100644
--- a/spec/tapioca/dsl/compilers/active_record_associations_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_associations_spec.rb
@@ -115,13 +115,13 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::User)).void }
+                        sig { params(value: ::T.nilable(::User)).void }
                         def author=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def author_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -130,19 +130,19 @@ def author_changed?; end
                         sig { returns(T::Boolean) }
                         def author_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def build_category(*args, &blk); end
 
-                        sig { returns(T.nilable(::Category)) }
+                        sig { returns(::T.nilable(::Category)) }
                         def category; end
 
-                        sig { params(value: T.nilable(::Category)).void }
+                        sig { params(value: ::T.nilable(::Category)).void }
                         def category=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def category_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -151,22 +151,22 @@ def category_changed?; end
                         sig { returns(T::Boolean) }
                         def category_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author!(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def create_category(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def create_category!(*args, &blk); end
 
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def reload_author; end
 
-                        sig { returns(T.nilable(::Category)) }
+                        sig { returns(::T.nilable(::Category)) }
                         def reload_category; end
 
                         sig { void }
@@ -202,13 +202,13 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.untyped) }
+                        sig { returns(::T.untyped) }
                         def category; end
 
-                        sig { params(value: T.untyped).void }
+                        sig { params(value: ::T.untyped).void }
                         def category=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def category_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -217,7 +217,7 @@ def category_changed?; end
                         sig { returns(T::Boolean) }
                         def category_previously_changed?; end
 
-                        sig { returns(T.untyped) }
+                        sig { returns(::T.untyped) }
                         def reload_category; end
 
                         sig { void }
@@ -251,18 +251,18 @@ class Employee
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def picture_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def picture_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Employee` class because it declared `has_many :pictures`.
                         # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
-                        sig { returns(ActiveRecord::Associations::CollectionProxy) }
+                        sig { returns(::ActiveRecord::Associations::CollectionProxy) }
                         def pictures; end
 
-                        sig { params(value: T::Enumerable[T.untyped]).void }
+                        sig { params(value: T::Enumerable[::T.untyped]).void }
                         def pictures=(value); end
                       end
                     end
@@ -301,25 +301,25 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::User)).void }
+                        sig { params(value: ::T.nilable(::User)).void }
                         def author=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def author_attributes=(attributes); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author!(*args, &blk); end
 
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def reload_author; end
 
                         sig { void }
@@ -364,10 +364,10 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :comments`.
@@ -378,7 +378,7 @@ def comments; end
                         sig { params(value: T::Enumerable[::Comment]).void }
                         def comments=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def comments_attributes=(attributes); end
                       end
                     end
@@ -427,16 +427,16 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def commenter_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def commenter_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :commenters, through: :comments`.
@@ -447,7 +447,7 @@ def commenters; end
                         sig { params(value: T::Enumerable[::Commenter]).void }
                         def commenters=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def commenters_attributes=(attributes); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :comments`.
@@ -498,10 +498,10 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def commenter_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def commenter_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_and_belongs_to_many :commenters`.
@@ -512,7 +512,7 @@ def commenters; end
                         sig { params(value: T::Enumerable[::Commenter]).void }
                         def commenters=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def commenters_attributes=(attributes); end
                       end
                     end
@@ -570,10 +570,10 @@ class Blog::Core::Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::Blog::Author)) }
+                        sig { returns(::T.nilable(::Blog::Author)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::Blog::Author)).void }
+                        sig { params(value: ::T.nilable(::Blog::Author)).void }
                         def author=(value); end
 
                         sig { returns(T::Boolean) }
@@ -582,16 +582,16 @@ def author_changed?; end
                         sig { returns(T::Boolean) }
                         def author_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def create_author!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Blog::Author)) }
+                        sig { returns(::T.nilable(::Blog::Author)) }
                         def reload_author; end
 
                         sig { void }
@@ -609,10 +609,10 @@ class Blog::Author
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Blog::Author` class because it declared `has_many :comments`.
@@ -623,10 +623,10 @@ def comments; end
                         sig { params(value: T::Enumerable[::Comment]).void }
                         def comments=(value); end
 
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def draft_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def draft_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Blog::Author` class because it declared `has_many :drafts`.
@@ -649,19 +649,19 @@ class Comment
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def build_post(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def create_post(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def create_post!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Blog::Core::Post)) }
+                        sig { returns(::T.nilable(::Blog::Core::Post)) }
                         def post; end
 
-                        sig { params(value: T.nilable(::Blog::Core::Post)).void }
+                        sig { params(value: ::T.nilable(::Blog::Core::Post)).void }
                         def post=(value); end
 
                         sig { returns(T::Boolean) }
@@ -670,7 +670,7 @@ def post_changed?; end
                         sig { returns(T::Boolean) }
                         def post_previously_changed?; end
 
-                        sig { returns(T.nilable(::Blog::Core::Post)) }
+                        sig { returns(::T.nilable(::Blog::Core::Post)) }
                         def reload_post; end
 
                         sig { void }
@@ -779,25 +779,25 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def build_shop(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def create_shop(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def create_shop!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Shop)) }
+                        sig { returns(::T.nilable(::Shop)) }
                         def reload_shop; end
 
                         sig { void }
                         def reset_shop; end
 
-                        sig { returns(T.nilable(::Shop)) }
+                        sig { returns(::T.nilable(::Shop)) }
                         def shop; end
 
-                        sig { params(value: T.nilable(::Shop)).void }
+                        sig { params(value: ::T.nilable(::Shop)).void }
                         def shop=(value); end
 
                         sig { returns(T::Boolean) }
@@ -872,13 +872,13 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::User)).void }
+                        sig { params(value: ::T.nilable(::User)).void }
                         def author=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def author_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -887,19 +887,19 @@ def author_changed?; end
                         sig { returns(T::Boolean) }
                         def author_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def build_category(*args, &blk); end
 
-                        sig { returns(T.nilable(::Category)) }
+                        sig { returns(::T.nilable(::Category)) }
                         def category; end
 
-                        sig { params(value: T.nilable(::Category)).void }
+                        sig { params(value: ::T.nilable(::Category)).void }
                         def category=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def category_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -908,22 +908,22 @@ def category_changed?; end
                         sig { returns(T::Boolean) }
                         def category_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author!(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def create_category(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Category) }
                         def create_category!(*args, &blk); end
 
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def reload_author; end
 
-                        sig { returns(T.nilable(::Category)) }
+                        sig { returns(::T.nilable(::Category)) }
                         def reload_category; end
 
                         sig { void }
@@ -959,13 +959,13 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.untyped) }
+                        sig { returns(::T.untyped) }
                         def category; end
 
-                        sig { params(value: T.untyped).void }
+                        sig { params(value: ::T.untyped).void }
                         def category=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def category_attributes=(attributes); end
 
                         sig { returns(T::Boolean) }
@@ -974,7 +974,7 @@ def category_changed?; end
                         sig { returns(T::Boolean) }
                         def category_previously_changed?; end
 
-                        sig { returns(T.untyped) }
+                        sig { returns(::T.untyped) }
                         def reload_category; end
 
                         sig { void }
@@ -1008,18 +1008,18 @@ class Employee
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def picture_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def picture_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Employee` class because it declared `has_many :pictures`.
                         # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association)
-                        sig { returns(ActiveRecord::Associations::CollectionProxy[T.untyped]) }
+                        sig { returns(::ActiveRecord::Associations::CollectionProxy[::T.untyped]) }
                         def pictures; end
 
-                        sig { params(value: T::Enumerable[T.untyped]).void }
+                        sig { params(value: T::Enumerable[::T.untyped]).void }
                         def pictures=(value); end
                       end
                     end
@@ -1058,25 +1058,25 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::User)).void }
+                        sig { params(value: ::T.nilable(::User)).void }
                         def author=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def author_attributes=(attributes); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::User) }
                         def create_author!(*args, &blk); end
 
-                        sig { returns(T.nilable(::User)) }
+                        sig { returns(::T.nilable(::User)) }
                         def reload_author; end
 
                         sig { void }
@@ -1121,10 +1121,10 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :comments`.
@@ -1135,7 +1135,7 @@ def comments; end
                         sig { params(value: T::Enumerable[::Comment]).void }
                         def comments=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def comments_attributes=(attributes); end
                       end
                     end
@@ -1184,16 +1184,16 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def commenter_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def commenter_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :commenters, through: :comments`.
@@ -1204,7 +1204,7 @@ def commenters; end
                         sig { params(value: T::Enumerable[::Commenter]).void }
                         def commenters=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def commenters_attributes=(attributes); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_many :comments`.
@@ -1255,10 +1255,10 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def commenter_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def commenter_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Post` class because it declared `has_and_belongs_to_many :commenters`.
@@ -1269,7 +1269,7 @@ def commenters; end
                         sig { params(value: T::Enumerable[::Commenter]).void }
                         def commenters=(value); end
 
-                        sig { params(attributes: T.untyped).returns(T.untyped) }
+                        sig { params(attributes: ::T.untyped).returns(::T.untyped) }
                         def commenters_attributes=(attributes); end
                       end
                     end
@@ -1327,10 +1327,10 @@ class Blog::Core::Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T.nilable(::Blog::Author)) }
+                        sig { returns(::T.nilable(::Blog::Author)) }
                         def author; end
 
-                        sig { params(value: T.nilable(::Blog::Author)).void }
+                        sig { params(value: ::T.nilable(::Blog::Author)).void }
                         def author=(value); end
 
                         sig { returns(T::Boolean) }
@@ -1339,16 +1339,16 @@ def author_changed?; end
                         sig { returns(T::Boolean) }
                         def author_previously_changed?; end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def build_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def create_author(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Author) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Author) }
                         def create_author!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Blog::Author)) }
+                        sig { returns(::T.nilable(::Blog::Author)) }
                         def reload_author; end
 
                         sig { void }
@@ -1366,10 +1366,10 @@ class Blog::Author
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def comment_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def comment_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Blog::Author` class because it declared `has_many :comments`.
@@ -1380,10 +1380,10 @@ def comments; end
                         sig { params(value: T::Enumerable[::Comment]).void }
                         def comments=(value); end
 
-                        sig { returns(T::Array[T.untyped]) }
+                        sig { returns(T::Array[::T.untyped]) }
                         def draft_ids; end
 
-                        sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                        sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                         def draft_ids=(ids); end
 
                         # This method is created by ActiveRecord on the `Blog::Author` class because it declared `has_many :drafts`.
@@ -1406,19 +1406,19 @@ class Comment
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def build_post(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def create_post(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Blog::Core::Post) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Blog::Core::Post) }
                         def create_post!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Blog::Core::Post)) }
+                        sig { returns(::T.nilable(::Blog::Core::Post)) }
                         def post; end
 
-                        sig { params(value: T.nilable(::Blog::Core::Post)).void }
+                        sig { params(value: ::T.nilable(::Blog::Core::Post)).void }
                         def post=(value); end
 
                         sig { returns(T::Boolean) }
@@ -1427,7 +1427,7 @@ def post_changed?; end
                         sig { returns(T::Boolean) }
                         def post_previously_changed?; end
 
-                        sig { returns(T.nilable(::Blog::Core::Post)) }
+                        sig { returns(::T.nilable(::Blog::Core::Post)) }
                         def reload_post; end
 
                         sig { void }
@@ -1536,25 +1536,25 @@ class Post
                       include GeneratedAssociationMethods
 
                       module GeneratedAssociationMethods
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def build_shop(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def create_shop(*args, &blk); end
 
-                        sig { params(args: T.untyped, blk: T.untyped).returns(::Shop) }
+                        sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::Shop) }
                         def create_shop!(*args, &blk); end
 
-                        sig { returns(T.nilable(::Shop)) }
+                        sig { returns(::T.nilable(::Shop)) }
                         def reload_shop; end
 
                         sig { void }
                         def reset_shop; end
 
-                        sig { returns(T.nilable(::Shop)) }
+                        sig { returns(::T.nilable(::Shop)) }
                         def shop; end
 
-                        sig { params(value: T.nilable(::Shop)).void }
+                        sig { params(value: ::T.nilable(::Shop)).void }
                         def shop=(value); end
 
                         sig { returns(T::Boolean) }
@@ -1599,40 +1599,40 @@ class Post
                   include GeneratedAssociationMethods
 
                   module GeneratedAssociationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def build_photo_attachment(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def build_photo_blob(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def create_photo_attachment(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def create_photo_attachment!(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def create_photo_blob(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def create_photo_blob!(*args, &blk); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def photo_attachment; end
 
-                    sig { params(value: T.untyped).void }
+                    sig { params(value: ::T.untyped).void }
                     def photo_attachment=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def photo_blob; end
 
-                    sig { params(value: T.untyped).void }
+                    sig { params(value: ::T.untyped).void }
                     def photo_blob=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def reload_photo_attachment; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def reload_photo_blob; end
 
                     sig { void }
@@ -1670,10 +1670,10 @@ class Post
                   include GeneratedAssociationMethods
 
                   module GeneratedAssociationMethods
-                    sig { returns(T::Array[T.untyped]) }
+                    sig { returns(T::Array[::T.untyped]) }
                     def photos_attachment_ids; end
 
-                    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                    sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                     def photos_attachment_ids=(ids); end
 
                     # This method is created by ActiveRecord on the `Post` class because it declared `has_many :photos_attachments`.
@@ -1684,10 +1684,10 @@ def photos_attachments; end
                     sig { params(value: T::Enumerable[::ActiveStorage::Attachment]).void }
                     def photos_attachments=(value); end
 
-                    sig { returns(T::Array[T.untyped]) }
+                    sig { returns(T::Array[::T.untyped]) }
                     def photos_blob_ids; end
 
-                    sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+                    sig { params(ids: T::Array[::T.untyped]).returns(T::Array[::T.untyped]) }
                     def photos_blob_ids=(ids); end
 
                     # This method is created by ActiveRecord on the `Post` class because it declared `has_many :photos_blobs, through: :photos_attachments`.
diff --git a/spec/tapioca/dsl/compilers/active_record_columns_spec.rb b/spec/tapioca/dsl/compilers/active_record_columns_spec.rb
index 1c119da3b..1b8eb69d3 100644
--- a/spec/tapioca/dsl/compilers/active_record_columns_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_columns_spec.rb
@@ -88,34 +88,34 @@ def id=(value); end
                       sig { returns(T::Boolean) }
                       def id?; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_came_from_user?; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_change; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_in_database; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_previously_was; end
 
                       sig { returns(::Integer) }
@@ -127,43 +127,43 @@ def id_value=(value); end
                       sig { returns(T::Boolean) }
                       def id_value?; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_value_came_from_user?; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_value_change; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_value_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_in_database; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def id_value_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_previously_was; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_was; end
 
                       sig { void }
                       def id_value_will_change!; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_was; end
 
                       sig { void }
@@ -175,22 +175,22 @@ def restore_id!; end
                       sig { void }
                       def restore_id_value!; end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def saved_change_to_id; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable([::Integer, ::Integer])) }
+                      sig { returns(::T.nilable([::Integer, ::Integer])) }
                       def saved_change_to_id_value; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                     end
                   end
@@ -217,10 +217,10 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def body=(value); end
 
                     sig { returns(T::Boolean) }
@@ -270,7 +270,7 @@ def id; end
                   class CustomType < ActiveRecord::Encryption::EncryptedAttributeType
                     extend T::Sig
 
-                    sig { params(value: T.untyped).returns(T.nilable(CustomType)) }
+                    sig { params(value: T.untyped).returns(::T.nilable(CustomType)) }
                     def deserialize(value)
                       CustomType.new(value) unless value.nil?
                     end
@@ -291,7 +291,7 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::CustomType)) }
+                    sig { returns(::T.nilable(::CustomType)) }
                     def custom; end
                 RBI
 
@@ -313,7 +313,7 @@ def custom; end
                   class CustomType < ActiveRecord::Encryption::EncryptedAttributeType
                     extend T::Sig
 
-                    sig { params(value: T.untyped).returns(T.nilable(CustomType)) }
+                    sig { params(value: T.untyped).returns(::T.nilable(CustomType)) }
                     def deserialize(value)
                       CustomType.new(value) unless value.nil?
                     end
@@ -362,10 +362,10 @@ class Post < ActiveRecord::Base
                 output = rbi_for(:Post)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def body; end
 
-                  sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                  sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                   def body=(value); end
 
                   sig { returns(T::Boolean) }
@@ -453,91 +453,91 @@ class Post < ActiveRecord::Base
                 output = rbi_for(:Post)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                  sig { params(value: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                   def integer_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                  sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                   def string_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::Date)).returns(T.nilable(::Date)) }
+                  sig { params(value: ::T.nilable(::Date)).returns(::T.nilable(::Date)) }
                   def date_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::BigDecimal)).returns(T.nilable(::BigDecimal)) }
+                  sig { params(value: ::T.nilable(::BigDecimal)).returns(::T.nilable(::BigDecimal)) }
                   def decimal_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::Float)).returns(T.nilable(::Float)) }
+                  sig { params(value: ::T.nilable(::Float)).returns(::T.nilable(::Float)) }
                   def float_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+                  sig { params(value: ::T.nilable(T::Boolean)).returns(::T.nilable(T::Boolean)) }
                   def boolean_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::Time)).returns(T.nilable(::Time)) }
+                  sig { params(value: ::T.nilable(::Time)).returns(::T.nilable(::Time)) }
                   def datetime_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::Money)).returns(T.nilable(::Money)) }
+                  sig { params(value: ::T.nilable(::Money)).returns(::T.nilable(::Money)) }
                   def money_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def serialized_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def integer_enum_column; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(T.any(::String, ::Symbol, ::Integer))).returns(T.nilable(T.any(::String, ::Symbol, ::Integer))) }
+                  sig { params(value: ::T.nilable(::T.any(::String, ::Symbol, ::Integer))).returns(::T.nilable(::T.any(::String, ::Symbol, ::Integer))) }
                   def integer_enum_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def string_enum_column; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(T.any(::String, ::Symbol))).returns(T.nilable(T.any(::String, ::Symbol))) }
+                  sig { params(value: ::T.nilable(::T.any(::String, ::Symbol))).returns(::T.nilable(::T.any(::String, ::Symbol))) }
                   def string_enum_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def binary_column; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                  sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                   def binary_column=(value); end
                 RBI
                 assert_includes(output, expected)
@@ -574,49 +574,49 @@ class Post < ActiveRecord::Base
                 output = rbi_for(:Post)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(T::Array[T.untyped])).returns(T.nilable(T::Array[T.untyped])) }
+                  sig { params(value: ::T.nilable(T::Array[::T.untyped])).returns(::T.nilable(T::Array[::T.untyped])) }
                   def serialized_column_array=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T::Array[T.untyped]) }
+                  sig { returns(T::Array[::T.untyped]) }
                   def serialized_column_array; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def serialized_column_custom=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def serialized_column_custom; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(T::Hash[T.untyped, T.untyped])).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+                  sig { params(value: ::T.nilable(T::Hash[::T.untyped, ::T.untyped])).returns(::T.nilable(T::Hash[::T.untyped, ::T.untyped])) }
                   def serialized_column_hash=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T::Hash[T.untyped, T.untyped]) }
+                  sig { returns(T::Hash[::T.untyped, ::T.untyped]) }
                   def serialized_column_hash; end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def serialized_column_json=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def serialized_column_json; end
                 RBI
                 assert_includes(output, expected)
@@ -648,7 +648,7 @@ class Post < ActiveRecord::Base
                 output = rbi_for(:Post)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::BigDecimal)).returns(T.nilable(::BigDecimal)) }
+                  sig { params(value: ::T.nilable(::BigDecimal)).returns(::T.nilable(::BigDecimal)) }
                   def money_column=(value); end
                 RBI
                 assert_includes(output, expected)
@@ -676,19 +676,19 @@ class Post < ActiveRecord::Base
                 output = rbi_for(:Post)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+                  sig { params(value: ::T.nilable(::ActiveSupport::TimeWithZone)).returns(::T.nilable(::ActiveSupport::TimeWithZone)) }
                   def timestamp_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+                  sig { params(value: ::T.nilable(::ActiveSupport::TimeWithZone)).returns(::T.nilable(::ActiveSupport::TimeWithZone)) }
                   def datetime_column=(value); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+                  sig { params(value: ::T.nilable(::ActiveSupport::TimeWithZone)).returns(::T.nilable(::ActiveSupport::TimeWithZone)) }
                   def time_column=(value); end
                 RBI
                 assert_includes(output, expected)
@@ -715,46 +715,46 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def author; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def author=(value); end
 
                     sig { returns(T::Boolean) }
                     def author?; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def author_before_last_save; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def author_before_type_cast; end
 
                     sig { returns(T::Boolean) }
                     def author_came_from_user?; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def author_change; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def author_change_to_be_saved; end
 
-                    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                    sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                     def author_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def author_in_database; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def author_previous_change; end
 
-                    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                    sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                     def author_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def author_previously_was; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def author_was; end
 
                     sig { void }
@@ -769,16 +769,16 @@ def restore_author!; end
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                  sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                   def saved_change_to_author; end
 
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def saved_change_to_author?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def will_save_change_to_author?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
@@ -805,46 +805,46 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def body=(value); end
 
                     sig { returns(T::Boolean) }
                     def body?; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body_before_last_save; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def body_before_type_cast; end
 
                     sig { returns(T::Boolean) }
                     def body_came_from_user?; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def body_change; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def body_change_to_be_saved; end
 
-                    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                    sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                     def body_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body_in_database; end
 
-                    sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def body_previous_change; end
 
-                    sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                    sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                     def body_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body_previously_was; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body_was; end
 
                     sig { void }
@@ -859,16 +859,16 @@ def restore_body!; end
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) }
+                  sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                   def saved_change_to_body; end
 
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def saved_change_to_body?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def will_save_change_to_body?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
@@ -902,37 +902,37 @@ def publication_date=(value); end
                   sig { returns(T::Boolean) }
                   def publication_date?; end
 
-                  sig { returns(T.nilable(::Date)) }
+                  sig { returns(::T.nilable(::Date)) }
                   def publication_date_before_last_save; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def publication_date_before_type_cast; end
 
                   sig { returns(T::Boolean) }
                   def publication_date_came_from_user?; end
 
-                  sig { returns(T.nilable([::Date, ::Date])) }
+                  sig { returns(::T.nilable([::Date, ::Date])) }
                   def publication_date_change; end
 
-                  sig { returns(T.nilable([::Date, ::Date])) }
+                  sig { returns(::T.nilable([::Date, ::Date])) }
                   def publication_date_change_to_be_saved; end
 
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def publication_date_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                  sig { returns(T.nilable(::Date)) }
+                  sig { returns(::T.nilable(::Date)) }
                   def publication_date_in_database; end
 
-                  sig { returns(T.nilable([::Date, ::Date])) }
+                  sig { returns(::T.nilable([::Date, ::Date])) }
                   def publication_date_previous_change; end
 
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def publication_date_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                  sig { returns(T.nilable(::Date)) }
+                  sig { returns(::T.nilable(::Date)) }
                   def publication_date_previously_was; end
 
-                  sig { returns(T.nilable(::Date)) }
+                  sig { returns(::T.nilable(::Date)) }
                   def publication_date_was; end
 
                   sig { void }
@@ -947,16 +947,16 @@ def restore_publication_date!; end
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable([::Date, ::Date])) }
+                  sig { returns(::T.nilable([::Date, ::Date])) }
                   def saved_change_to_publication_date; end
 
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def saved_change_to_publication_date?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
 
                 expected = indented(<<~RBI, 4)
-                  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                  sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                   def will_save_change_to_publication_date?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                 RBI
                 assert_includes(output, expected)
@@ -980,10 +980,10 @@ class Post < ActiveRecord::Base
                 RUBY
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def title; end
 
-                  sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                  sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                   def title=(value); end
 
                   sig { returns(T::Boolean) }
@@ -1030,10 +1030,10 @@ class Post < ActiveRecord::Base
                 RUBY
 
                 expected = indented(<<~RBI, 4)
-                  sig { returns(T.nilable(::CustomType)) }
+                  sig { returns(::T.nilable(::CustomType)) }
                   def cost; end
 
-                  sig { params(value: T.nilable(::CustomType)).returns(T.nilable(::CustomType)) }
+                  sig { params(value: ::T.nilable(::CustomType)).returns(::T.nilable(::CustomType)) }
                   def cost=(value); end
                 RBI
 
@@ -1062,7 +1062,7 @@ def initialize(number = 0.0)
                     class Type < ActiveRecord::Type::Value
                       extend(T::Sig)
 
-                      sig { params(value: T.nilable(Numeric)).returns(T.nilable(::CustomType))}
+                      sig { params(value: ::T.nilable(Numeric)).returns(::T.nilable(::CustomType))}
                       def deserialize(value)
                         CustomType.new(value) if value
                       end
@@ -1131,10 +1131,10 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def body; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def body=(value); end
 
                     sig { returns(T::Boolean) }
@@ -1166,91 +1166,91 @@ class Post
                     include GeneratedAttributeMethods
 
                     module GeneratedAttributeMethods
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id; end
 
-                      sig { params(value: T.untyped).returns(T.untyped) }
+                      sig { params(value: ::T.untyped).returns(::T.untyped) }
                       def id=(value); end
 
                       sig { returns(T::Boolean) }
                       def id?; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_came_from_user?; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_change; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_in_database; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_previously_was; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value; end
 
-                      sig { params(value: T.untyped).returns(T.untyped) }
+                      sig { params(value: ::T.untyped).returns(::T.untyped) }
                       def id_value=(value); end
 
                       sig { returns(T::Boolean) }
                       def id_value?; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_value_came_from_user?; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_value_change; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_value_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_in_database; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def id_value_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_previously_was; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_was; end
 
                       sig { void }
                       def id_value_will_change!; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_was; end
 
                       sig { void }
@@ -1262,22 +1262,22 @@ def restore_id!; end
                       sig { void }
                       def restore_id_value!; end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def saved_change_to_id; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable([T.untyped, T.untyped])) }
+                      sig { returns(::T.nilable([::T.untyped, ::T.untyped])) }
                       def saved_change_to_id_value; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                     end
                   end
@@ -1308,10 +1308,10 @@ class Post < ActiveRecord::Base
 
                 expected = indented(<<~RBI, 2)
                   module GeneratedAttributeMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body; end
 
-                    sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(value: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def body=(value); end
 
                     sig { returns(T::Boolean) }
@@ -1343,91 +1343,91 @@ class Post
                     include GeneratedAttributeMethods
 
                     module GeneratedAttributeMethods
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id; end
 
-                      sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                      sig { params(value: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                       def id=(value); end
 
                       sig { returns(T::Boolean) }
                       def id?; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_came_from_user?; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_change; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_in_database; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_previously_was; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value; end
 
-                      sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                      sig { params(value: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                       def id_value=(value); end
 
                       sig { returns(T::Boolean) }
                       def id_value?; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_before_last_save; end
 
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def id_value_before_type_cast; end
 
                       sig { returns(T::Boolean) }
                       def id_value_came_from_user?; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_value_change; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_value_change_to_be_saved; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_in_database; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def id_value_previous_change; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_previously_was; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_value_was; end
 
                       sig { void }
                       def id_value_will_change!; end
 
-                      sig { returns(T.nilable(::Integer)) }
+                      sig { returns(::T.nilable(::Integer)) }
                       def id_was; end
 
                       sig { void }
@@ -1439,22 +1439,22 @@ def restore_id!; end
                       sig { void }
                       def restore_id_value!; end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def saved_change_to_id; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) }
+                      sig { returns(::T.nilable([::T.nilable(::Integer), ::T.nilable(::Integer)])) }
                       def saved_change_to_id_value; end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def saved_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id?(from: T.unsafe(nil), to: T.unsafe(nil)); end
 
-                      sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+                      sig { params(from: ::T.untyped, to: ::T.untyped).returns(T::Boolean) }
                       def will_save_change_to_id_value?(from: T.unsafe(nil), to: T.unsafe(nil)); end
                     end
                   end
diff --git a/spec/tapioca/dsl/compilers/active_record_delegated_types_spec.rb b/spec/tapioca/dsl/compilers/active_record_delegated_types_spec.rb
index b0871ee1b..6281f1387 100644
--- a/spec/tapioca/dsl/compilers/active_record_delegated_types_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_delegated_types_spec.rb
@@ -104,31 +104,31 @@ class Entry
                   include GeneratedDelegatedTypeMethods
 
                   module GeneratedDelegatedTypeMethods
-                    sig { params(args: T.untyped).returns(T.any(Message, Comment)) }
+                    sig { params(args: ::T.untyped).returns(::T.any(Message, Comment)) }
                     def build_entryable(*args); end
 
-                    sig { returns(T.nilable(Comment)) }
+                    sig { returns(::T.nilable(Comment)) }
                     def comment; end
 
                     sig { returns(T::Boolean) }
                     def comment?; end
 
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def comment_id; end
 
-                    sig { returns(T::Class[T.anything]) }
+                    sig { returns(T::Class[::T.anything]) }
                     def entryable_class; end
 
                     sig { returns(ActiveSupport::StringInquirer) }
                     def entryable_name; end
 
-                    sig { returns(T.nilable(Message)) }
+                    sig { returns(::T.nilable(Message)) }
                     def message; end
 
                     sig { returns(T::Boolean) }
                     def message?; end
 
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def message_id; end
                   end
                 end
@@ -172,31 +172,31 @@ class Entry
                   include GeneratedDelegatedTypeMethods
 
                   module GeneratedDelegatedTypeMethods
-                    sig { params(args: T.untyped).returns(T.any(Message, Comment)) }
+                    sig { params(args: ::T.untyped).returns(::T.any(Message, Comment)) }
                     def build_entryable(*args); end
 
-                    sig { returns(T.nilable(Comment)) }
+                    sig { returns(::T.nilable(Comment)) }
                     def comment; end
 
                     sig { returns(T::Boolean) }
                     def comment?; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def comment_uuid; end
 
-                    sig { returns(T::Class[T.anything]) }
+                    sig { returns(T::Class[::T.anything]) }
                     def entryable_class; end
 
                     sig { returns(ActiveSupport::StringInquirer) }
                     def entryable_name; end
 
-                    sig { returns(T.nilable(Message)) }
+                    sig { returns(::T.nilable(Message)) }
                     def message; end
 
                     sig { returns(T::Boolean) }
                     def message?; end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def message_uuid; end
                   end
                 end
@@ -235,22 +235,22 @@ class Entry
                   include GeneratedDelegatedTypeMethods
 
                   module GeneratedDelegatedTypeMethods
-                    sig { params(args: T.untyped).returns(Message) }
+                    sig { params(args: ::T.untyped).returns(Message) }
                     def build_entryable(*args); end
 
-                    sig { returns(T::Class[T.anything]) }
+                    sig { returns(T::Class[::T.anything]) }
                     def entryable_class; end
 
                     sig { returns(ActiveSupport::StringInquirer) }
                     def entryable_name; end
 
-                    sig { returns(T.nilable(Message)) }
+                    sig { returns(::T.nilable(Message)) }
                     def message; end
 
                     sig { returns(T::Boolean) }
                     def message?; end
 
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def message_id; end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/active_record_enum_spec.rb b/spec/tapioca/dsl/compilers/active_record_enum_spec.rb
index 114b78124..a4e8e1988 100644
--- a/spec/tapioca/dsl/compilers/active_record_enum_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_enum_spec.rb
@@ -50,7 +50,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -88,7 +88,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), String]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::String]) }
                     def statuses; end
                   end
 
@@ -125,7 +125,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), T.any(Integer, TrueClass, String)]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::T.any(::Integer, ::TrueClass, ::String)]) }
                     def statuses; end
                   end
 
@@ -169,10 +169,10 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def comments_statuses; end
 
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -222,10 +222,10 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), T.any(Integer, FalseClass, String)]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::T.any(::Integer, ::FalseClass, ::String)]) }
                     def comments_statuses; end
 
-                    sig { returns(T::Hash[T.any(String, Symbol), T.any(Integer, TrueClass, String)]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::T.any(::Integer, ::TrueClass, ::String)]) }
                     def statuses; end
                   end
 
@@ -286,7 +286,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -323,7 +323,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -364,7 +364,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -387,7 +387,7 @@ class AbstractConversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -430,7 +430,7 @@ class Conversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
@@ -453,7 +453,7 @@ class AbstractConversation
                   include EnumMethodsModule
 
                   class << self
-                    sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+                    sig { returns(T::Hash[::T.any(::String, ::Symbol), ::Integer]) }
                     def statuses; end
                   end
 
diff --git a/spec/tapioca/dsl/compilers/active_record_fixtures_spec.rb b/spec/tapioca/dsl/compilers/active_record_fixtures_spec.rb
index af311d073..40785b104 100644
--- a/spec/tapioca/dsl/compilers/active_record_fixtures_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_fixtures_spec.rb
@@ -79,9 +79,9 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class ActiveSupport::TestCase
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[Post]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(Post) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(Post) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[Post]) }
                   def posts(fixture_name = nil, *other_fixtures); end
                 end
               RBI
@@ -107,9 +107,9 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class ActiveSupport::TestCase
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[Post]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(Post) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(Post) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[Post]) }
                   def posts(fixture_name = nil, *other_fixtures); end
                 end
               RBI
@@ -146,14 +146,14 @@ class User < ActiveRecord::Base
                 # typed: strong
 
                 class ActiveSupport::TestCase
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[Blog::Post]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(Blog::Post) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[Blog::Post]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[Blog::Post]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(Blog::Post) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[Blog::Post]) }
                   def blog_posts(fixture_name = nil, *other_fixtures); end
 
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[User]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(User) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[User]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[User]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(User) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[User]) }
                   def users(fixture_name = nil, *other_fixtures); end
                 end
               RBI
@@ -181,9 +181,9 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class ActiveSupport::TestCase
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[Post]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(Post) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[Post]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(Post) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[Post]) }
                   def posts_with_other_names(fixture_name = nil, *other_fixtures); end
                 end
               RBI
@@ -204,9 +204,9 @@ def posts_with_other_names(fixture_name = nil, *other_fixtures); end
                 # typed: strong
 
                 class ActiveSupport::TestCase
-                  sig { params(fixture_name: NilClass, other_fixtures: NilClass).returns(T::Array[T.untyped]) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: NilClass).returns(T.untyped) }
-                  sig { params(fixture_name: T.any(String, Symbol), other_fixtures: T.any(String, Symbol)).returns(T::Array[T.untyped]) }
+                  sig { params(fixture_name: ::NilClass, other_fixtures: ::NilClass).returns(T::Array[::T.untyped]) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::NilClass).returns(::T.untyped) }
+                  sig { params(fixture_name: ::T.any(::String, ::Symbol), other_fixtures: ::T.any(::String, ::Symbol)).returns(T::Array[::T.untyped]) }
                   def posts(fixture_name = nil, *other_fixtures); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/active_record_relations_spec.rb b/spec/tapioca/dsl/compilers/active_record_relations_spec.rb
index 4504da66a..4f1ab0536 100644
--- a/spec/tapioca/dsl/compilers/active_record_relations_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_relations_spec.rb
@@ -61,7 +61,7 @@ class User
                 class CustomId < ActiveRecord::Type::Value
                   extend T::Sig
 
-                  sig { params(value: T.untyped).returns(T.nilable(CustomId)) }
+                  sig { params(value: ::T.untyped).returns(::T.nilable(CustomId)) }
                   def deserialize(value)
                     CustomId.new(value) unless value.nil?
                   end
@@ -91,57 +91,57 @@ class Post
                   def to_ary; end
 
                   class << self
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def new(attributes = nil, &block); end
                   end
 
                   module CommonRelationMethods
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def any?(&block); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
                     def average(column_name); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def build(attributes = nil, &block); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
-                    sig { params(column_name: NilClass, block: T.proc.params(object: ::Post).void).returns(Integer) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol))).returns(::Integer) }
+                    sig { params(column_name: NilClass, block: ::T.proc.params(object: ::Post).void).returns(::Integer) }
                     def count(column_name = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create(attributes = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create!(attributes = nil, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create_or_find_by(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create_or_find_by!(attributes, &block); end
 
-                    sig { params(records: T.any(::Post, Integer, String, T::Enumerable[T.any(::Post, Integer, String, T::Enumerable[::Post])])).returns(Integer) }
+                    sig { params(records: ::T.any(::Post, ::Integer, ::String, T::Enumerable[::T.any(::Post, ::Integer, ::String, T::Enumerable[::Post])])).returns(::Integer) }
                     def delete(*records); end
 
-                    sig { returns(Integer) }
+                    sig { returns(::Integer) }
                     def delete_all; end
 
-                    sig { params(args: T.untyped).returns(Integer) }
+                    sig { params(args: ::T.untyped).returns(::Integer) }
                     def delete_by(args); end
 
-                    sig { params(records: T.any(::Post, Integer, String, T::Enumerable[T.any(::Post, Integer, String, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
+                    sig { params(records: ::T.any(::Post, ::Integer, ::String, T::Enumerable[::T.any(::Post, ::Integer, ::String, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
                     def destroy(*records); end
 
                     sig { returns(T::Array[::Post]) }
@@ -150,84 +150,84 @@ def destroy_all; end
                     sig { returns(T::Array[::Post]) }
                     def destroy_all; end
 
-                    sig { params(args: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(T::Array[::Post]) }
                     def destroy_by(args); end
 
-                    sig { params(conditions: T.untyped).returns(T::Boolean) }
+                    sig { params(conditions: ::T.untyped).returns(T::Boolean) }
                     def exists?(conditions = :none); end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def fifth; end
 
                     sig { returns(::Post) }
                     def fifth!; end
 
-                    sig { params(args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything], ::CustomId)).returns(::Post) }
-                    sig { params(args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything], ::CustomId)]).returns(T::Enumerable[::Post]) }
-                    sig { params(args: NilClass, block: T.proc.params(object: ::Post).void).returns(T.nilable(::Post)) }
+                    sig { params(args: ::T.any(::String, ::Symbol, ::ActiveSupport::Multibyte::Chars, ::BigDecimal, ::Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, ::Date, ::Time, ::ActiveSupport::Duration, T::Class[::T.anything], ::CustomId, T::Boolean)).returns(::Post) }
+                    sig { params(args: T::Array[::T.any(::String, ::Symbol, ::ActiveSupport::Multibyte::Chars, ::BigDecimal, ::Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, ::Date, ::Time, ::ActiveSupport::Duration, T::Class[::T.anything], ::CustomId, T::Boolean)]).returns(T::Enumerable[::Post]) }
+                    sig { params(args: NilClass, block: ::T.proc.params(object: ::Post).void).returns(::T.nilable(::Post)) }
                     def find(args = nil, &block); end
 
-                    sig { params(args: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(args: ::T.untyped).returns(::T.nilable(::Post)) }
                     def find_by(*args); end
 
-                    sig { params(args: T.untyped).returns(::Post) }
+                    sig { params(args: ::T.untyped).returns(::Post) }
                     def find_by!(*args); end
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: ::Post).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[::Post]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: ::Post).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[::Post]) }
                     def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: :asc, &block); end
                 <% else %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: ::Post).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[::Post]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: ::Post).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[::Post]) }
                     def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
                 <% end %>
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: T::Array[::Post]).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: T::Array[::Post]).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
                     def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: :asc, &block); end
                 <% else %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: T::Array[::Post]).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: T::Array[::Post]).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
                     def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
                 <% end %>
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_create_by(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_create_by!(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_initialize_by(attributes, &block); end
 
-                    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(signed_id: ::T.untyped, purpose: ::T.untyped).returns(::T.nilable(::Post)) }
                     def find_signed(signed_id, purpose: nil); end
 
-                    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::Post) }
+                    sig { params(signed_id: ::T.untyped, purpose: ::T.untyped).returns(::Post) }
                     def find_signed!(signed_id, purpose: nil); end
 
-                    sig { params(arg: T.untyped, args: T.untyped).returns(::Post) }
+                    sig { params(arg: ::T.untyped, args: ::T.untyped).returns(::Post) }
                     def find_sole_by(arg, *args); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def first(limit = nil); end
 
                     sig { returns(::Post) }
                     def first!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def forty_two; end
 
                     sig { returns(::Post) }
                     def forty_two!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def fourth; end
 
                     sig { returns(::Post) }
@@ -237,61 +237,61 @@ def fourth!; end
                     def ids; end
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped, block: T.proc.params(object: PrivateRelation).void).void }
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped, block: ::T.proc.params(object: PrivateRelation).void).void }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
                     def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, cursor: primary_key, order: :asc, use_ranges: nil, &block); end
                 <% else %>
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped, block: T.proc.params(object: PrivateRelation).void).void }
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped, block: ::T.proc.params(object: PrivateRelation).void).void }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
                     def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
                 <% end %>
 
-                    sig { params(record: T.untyped).returns(T::Boolean) }
+                    sig { params(record: ::T.untyped).returns(T::Boolean) }
                     def include?(record); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def last(limit = nil); end
 
                     sig { returns(::Post) }
                     def last!; end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def many?(&block); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                     def maximum(column_name); end
 
-                    sig { params(record: T.untyped).returns(T::Boolean) }
+                    sig { params(record: ::T.untyped).returns(T::Boolean) }
                     def member?(record); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                     def minimum(column_name); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def new(attributes = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def none?(&block); end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def one?(&block); end
 
-                    sig { params(column_names: T.untyped).returns(T.untyped) }
+                    sig { params(column_names: ::T.untyped).returns(::T.untyped) }
                     def pick(*column_names); end
 
-                    sig { params(column_names: T.untyped).returns(T.untyped) }
+                    sig { params(column_names: ::T.untyped).returns(::T.untyped) }
                     def pluck(*column_names); end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def second; end
 
                     sig { returns(::Post) }
                     def second!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def second_to_last; end
 
                     sig { returns(::Post) }
@@ -300,24 +300,24 @@ def second_to_last!; end
                     sig { returns(::Post) }
                     def sole; end
 
-                    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
-                    sig { type_parameters(:U).params(initial_value_or_column: T.nilable(T.type_parameter(:U)), block: T.proc.params(object: ::Post).returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { params(initial_value_or_column: ::T.untyped).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
+                    sig { type_parameters(:U).params(initial_value_or_column: ::T.nilable(::T.type_parameter(:U)), block: ::T.proc.params(object: ::Post).returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def sum(initial_value_or_column = nil, &block); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def take(limit = nil); end
 
                     sig { returns(::Post) }
                     def take!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def third; end
 
                     sig { returns(::Post) }
                     def third!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def third_to_last; end
 
                     sig { returns(::Post) }
@@ -328,148 +328,148 @@ module GeneratedAssociationRelationMethods
                     sig { returns(PrivateAssociationRelation) }
                     def all; end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def and(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def annotate(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def arel_columns(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def create_with(*args, &blk); end
 
                     sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
                     def distinct(value = true); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def eager_load(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def except(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def excluding(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def extending(*args, &blk); end
 
-                    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+                    sig { params(association: ::Symbol).returns(T::Array[::T.untyped]) }
                     def extract_associated(association); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def from(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelationGroupChain) }
                     def group(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def having(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def in_order_of(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def includes(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def invert_where(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def left_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def left_outer_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def limit(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def lock(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def merge(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def none(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def null_relation?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def offset(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def only(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def optimizer_hints(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def or(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def preload(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def readonly(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def references(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def regroup(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reorder(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reselect(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reverse_order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def rewhere(*args, &blk); end
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
-                    sig { params(blk: T.proc.params(record: ::Post).returns(BasicObject)).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(blk: ::T.proc.params(record: ::Post).returns(::BasicObject)).returns(T::Array[::Post]) }
                     def select(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def strict_loading(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def structurally_compatible?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def uniq!(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def unscope(*args, &blk); end
 
                     sig { returns(PrivateAssociationRelation) }
-                    sig { type_parameters(:U).params(block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { type_parameters(:U).params(block: ::T.proc.returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def unscoped(&block); end
 
                     sig { returns(PrivateAssociationRelationWhereChain) }
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def where(*args); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with_recursive(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def without(*args, &blk); end
                   end
 
@@ -477,148 +477,148 @@ module GeneratedRelationMethods
                     sig { returns(PrivateRelation) }
                     def all; end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def and(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def annotate(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def arel_columns(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def create_with(*args, &blk); end
 
                     sig { params(value: T::Boolean).returns(PrivateRelation) }
                     def distinct(value = true); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def eager_load(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def except(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def excluding(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def extending(*args, &blk); end
 
-                    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+                    sig { params(association: ::Symbol).returns(T::Array[::T.untyped]) }
                     def extract_associated(association); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def from(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelationGroupChain) }
                     def group(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def having(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def in_order_of(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def includes(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def invert_where(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def left_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def left_outer_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def limit(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def lock(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def merge(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def none(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def null_relation?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def offset(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def only(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def optimizer_hints(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def or(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def preload(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def readonly(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def references(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def regroup(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reorder(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reselect(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reverse_order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def rewhere(*args, &blk); end
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
-                    sig { params(blk: T.proc.params(record: ::Post).returns(BasicObject)).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
+                    sig { params(blk: ::T.proc.params(record: ::Post).returns(::BasicObject)).returns(T::Array[::Post]) }
                     def select(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def strict_loading(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def structurally_compatible?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def uniq!(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def unscope(*args, &blk); end
 
                     sig { returns(PrivateRelation) }
-                    sig { type_parameters(:U).params(block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { type_parameters(:U).params(block: ::T.proc.returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def unscoped(&block); end
 
                     sig { returns(PrivateRelationWhereChain) }
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def where(*args); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with_recursive(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def without(*args, &blk); end
                   end
 
@@ -638,41 +638,41 @@ def to_ary; end
                   class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def average(column_name); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+                    sig { params(column_name: ::T.untyped).returns(T::Hash[::T.untyped, ::Integer]) }
                     def count(column_name = nil); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.self_type) }
                     def having(*args, &blk); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def maximum(column_name); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def minimum(column_name); end
 
-                    sig { returns(T::Hash[T.untyped, Integer]) }
+                    sig { returns(T::Hash[::T.untyped, ::Integer]) }
                     def size; end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol)), block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol)), block: ::T.nilable(::T.proc.params(record: ::T.untyped).returns(::T.untyped))).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def sum(column_name = nil, &block); end
                   end
 
                   class PrivateAssociationRelationWhereChain
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def associated(*args); end
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def missing(*args); end
 
-                    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(opts: ::T.untyped, rest: ::T.untyped).returns(PrivateAssociationRelation) }
                     def not(opts, *rest); end
                   end
 
@@ -682,28 +682,28 @@ class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
 
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def <<(*records); end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def append(*records); end
 
                     sig { returns(PrivateCollectionProxy) }
                     def clear; end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def concat(*records); end
 
                     sig { returns(T::Array[::Post]) }
                     def load_target; end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def prepend(*records); end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def push(*records); end
 
-                    sig { params(other_array: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
+                    sig { params(other_array: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
                     def replace(other_array); end
 
                     sig { returns(PrivateAssociationRelation) }
@@ -735,41 +735,41 @@ def to_ary; end
                   class PrivateRelationGroupChain < PrivateRelation
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def average(column_name); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+                    sig { params(column_name: ::T.untyped).returns(T::Hash[::T.untyped, ::Integer]) }
                     def count(column_name = nil); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.self_type) }
                     def having(*args, &blk); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def maximum(column_name); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def minimum(column_name); end
 
-                    sig { returns(T::Hash[T.untyped, Integer]) }
+                    sig { returns(T::Hash[::T.untyped, ::Integer]) }
                     def size; end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol)), block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol)), block: ::T.nilable(::T.proc.params(record: ::T.untyped).returns(::T.untyped))).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def sum(column_name = nil, &block); end
                   end
 
                   class PrivateRelationWhereChain
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def associated(*args); end
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def missing(*args); end
 
-                    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
+                    sig { params(opts: ::T.untyped, rest: ::T.untyped).returns(PrivateRelation) }
                     def not(opts, *rest); end
                   end
                 end
@@ -798,57 +798,57 @@ class Post
                   def to_ary; end
 
                   class << self
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def new(attributes = nil, &block); end
                   end
 
                   module CommonRelationMethods
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def any?(&block); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
                     def average(column_name); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def build(attributes = nil, &block); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) }
-                    sig { params(column_name: NilClass, block: T.proc.params(object: ::Post).void).returns(Integer) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol))).returns(::Integer) }
+                    sig { params(column_name: NilClass, block: ::T.proc.params(object: ::Post).void).returns(::Integer) }
                     def count(column_name = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create(attributes = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create!(attributes = nil, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create_or_find_by(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def create_or_find_by!(attributes, &block); end
 
-                    sig { params(records: T.any(::Post, Integer, String, T::Enumerable[T.any(::Post, Integer, String, T::Enumerable[::Post])])).returns(Integer) }
+                    sig { params(records: ::T.any(::Post, ::Integer, ::String, T::Enumerable[::T.any(::Post, ::Integer, ::String, T::Enumerable[::Post])])).returns(::Integer) }
                     def delete(*records); end
 
-                    sig { returns(Integer) }
+                    sig { returns(::Integer) }
                     def delete_all; end
 
-                    sig { params(args: T.untyped).returns(Integer) }
+                    sig { params(args: ::T.untyped).returns(::Integer) }
                     def delete_by(args); end
 
-                    sig { params(records: T.any(::Post, Integer, String, T::Enumerable[T.any(::Post, Integer, String, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
+                    sig { params(records: ::T.any(::Post, ::Integer, ::String, T::Enumerable[::T.any(::Post, ::Integer, ::String, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
                     def destroy(*records); end
 
                     sig { returns(T::Array[::Post]) }
@@ -857,84 +857,84 @@ def destroy_all; end
                     sig { returns(T::Array[::Post]) }
                     def destroy_all; end
 
-                    sig { params(args: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(T::Array[::Post]) }
                     def destroy_by(args); end
 
-                    sig { params(conditions: T.untyped).returns(T::Boolean) }
+                    sig { params(conditions: ::T.untyped).returns(T::Boolean) }
                     def exists?(conditions = :none); end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def fifth; end
 
                     sig { returns(::Post) }
                     def fifth!; end
 
-                    sig { params(args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]).returns(::Post) }
-                    sig { params(args: T::Array[T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])]]).returns(T::Enumerable[::Post]) }
-                    sig { params(args: NilClass, block: T.proc.params(object: ::Post).void).returns(T.nilable(::Post)) }
+                    sig { params(args: T::Array[::T.any(::String, ::Symbol, ::ActiveSupport::Multibyte::Chars, ::BigDecimal, ::Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, ::Date, ::Time, ::ActiveSupport::Duration, T::Class[::T.anything], T::Boolean)]).returns(::Post) }
+                    sig { params(args: T::Array[T::Array[::T.any(::String, ::Symbol, ::ActiveSupport::Multibyte::Chars, ::BigDecimal, ::Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, ::Date, ::Time, ::ActiveSupport::Duration, T::Class[::T.anything], T::Boolean)]]).returns(T::Enumerable[::Post]) }
+                    sig { params(args: NilClass, block: ::T.proc.params(object: ::Post).void).returns(::T.nilable(::Post)) }
                     def find(args = nil, &block); end
 
-                    sig { params(args: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(args: ::T.untyped).returns(::T.nilable(::Post)) }
                     def find_by(*args); end
 
-                    sig { params(args: T.untyped).returns(::Post) }
+                    sig { params(args: ::T.untyped).returns(::Post) }
                     def find_by!(*args); end
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: ::Post).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[::Post]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: ::Post).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[::Post]) }
                     def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: :asc, &block); end
                 <% else %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: ::Post).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[::Post]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: ::Post).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[::Post]) }
                     def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
                 <% end %>
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: T::Array[::Post]).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: T::Array[::Post]).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
                     def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, order: :asc, &block); end
                 <% else %>
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), block: T.proc.params(object: T::Array[::Post]).void).void }
-                    sig { params(start: T.untyped, finish: T.untyped, batch_size: Integer, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), block: ::T.proc.params(object: T::Array[::Post]).void).void }
+                    sig { params(start: ::T.untyped, finish: ::T.untyped, batch_size: ::Integer, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol])).returns(T::Enumerator[T::Array[::Post]]) }
                     def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end
                 <% end %>
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_create_by(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_create_by!(attributes, &block); end
 
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def find_or_initialize_by(attributes, &block); end
 
-                    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(signed_id: ::T.untyped, purpose: ::T.untyped).returns(::T.nilable(::Post)) }
                     def find_signed(signed_id, purpose: nil); end
 
-                    sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::Post) }
+                    sig { params(signed_id: ::T.untyped, purpose: ::T.untyped).returns(::Post) }
                     def find_signed!(signed_id, purpose: nil); end
 
-                    sig { params(arg: T.untyped, args: T.untyped).returns(::Post) }
+                    sig { params(arg: ::T.untyped, args: ::T.untyped).returns(::Post) }
                     def find_sole_by(arg, *args); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def first(limit = nil); end
 
                     sig { returns(::Post) }
                     def first!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def forty_two; end
 
                     sig { returns(::Post) }
                     def forty_two!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def fourth; end
 
                     sig { returns(::Post) }
@@ -944,61 +944,61 @@ def fourth!; end
                     def ids; end
 
                 <% if rails_version(">= 8.0") %>
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped, block: T.proc.params(object: PrivateRelation).void).void }
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, cursor: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped, block: ::T.proc.params(object: PrivateRelation).void).void }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, cursor: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
                     def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, cursor: primary_key, order: :asc, use_ranges: nil, &block); end
                 <% else %>
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped, block: T.proc.params(object: PrivateRelation).void).void }
-                    sig { params(of: Integer, start: T.untyped, finish: T.untyped, load: T.untyped, error_on_ignore: T.untyped, order: T.any(Symbol, T::Array[Symbol]), use_ranges: T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped, block: ::T.proc.params(object: PrivateRelation).void).void }
+                    sig { params(of: ::Integer, start: ::T.untyped, finish: ::T.untyped, load: ::T.untyped, error_on_ignore: ::T.untyped, order: ::T.any(::Symbol, T::Array[::Symbol]), use_ranges: ::T.untyped).returns(::ActiveRecord::Batches::BatchEnumerator) }
                     def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end
                 <% end %>
 
-                    sig { params(record: T.untyped).returns(T::Boolean) }
+                    sig { params(record: ::T.untyped).returns(T::Boolean) }
                     def include?(record); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def last(limit = nil); end
 
                     sig { returns(::Post) }
                     def last!; end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def many?(&block); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                     def maximum(column_name); end
 
-                    sig { params(record: T.untyped).returns(T::Boolean) }
+                    sig { params(record: ::T.untyped).returns(T::Boolean) }
                     def member?(record); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                     def minimum(column_name); end
 
-                    sig { params(block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
-                    sig { params(attributes: T::Array[T.untyped], block: T.nilable(T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
-                    sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
+                    sig { params(attributes: T::Array[::T.untyped], block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(T::Array[::Post]) }
+                    sig { params(attributes: ::T.untyped, block: ::T.nilable(::T.proc.params(object: ::Post).void)).returns(::Post) }
                     def new(attributes = nil, &block); end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def none?(&block); end
 
-                    sig { params(block: T.nilable(T.proc.params(record: ::Post).returns(T.untyped))).returns(T::Boolean) }
+                    sig { params(block: ::T.nilable(::T.proc.params(record: ::Post).returns(::T.untyped))).returns(T::Boolean) }
                     def one?(&block); end
 
-                    sig { params(column_names: T.untyped).returns(T.untyped) }
+                    sig { params(column_names: ::T.untyped).returns(::T.untyped) }
                     def pick(*column_names); end
 
-                    sig { params(column_names: T.untyped).returns(T.untyped) }
+                    sig { params(column_names: ::T.untyped).returns(::T.untyped) }
                     def pluck(*column_names); end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def second; end
 
                     sig { returns(::Post) }
                     def second!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def second_to_last; end
 
                     sig { returns(::Post) }
@@ -1007,24 +1007,24 @@ def second_to_last!; end
                     sig { returns(::Post) }
                     def sole; end
 
-                    sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) }
-                    sig { type_parameters(:U).params(initial_value_or_column: T.nilable(T.type_parameter(:U)), block: T.proc.params(object: ::Post).returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { params(initial_value_or_column: ::T.untyped).returns(::T.any(::Integer, ::Float, ::BigDecimal)) }
+                    sig { type_parameters(:U).params(initial_value_or_column: ::T.nilable(::T.type_parameter(:U)), block: ::T.proc.params(object: ::Post).returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def sum(initial_value_or_column = nil, &block); end
 
-                    sig { returns(T.nilable(::Post)) }
-                    sig { params(limit: Integer).returns(T::Array[::Post]) }
+                    sig { returns(::T.nilable(::Post)) }
+                    sig { params(limit: ::Integer).returns(T::Array[::Post]) }
                     def take(limit = nil); end
 
                     sig { returns(::Post) }
                     def take!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def third; end
 
                     sig { returns(::Post) }
                     def third!; end
 
-                    sig { returns(T.nilable(::Post)) }
+                    sig { returns(::T.nilable(::Post)) }
                     def third_to_last; end
 
                     sig { returns(::Post) }
@@ -1035,148 +1035,148 @@ module GeneratedAssociationRelationMethods
                     sig { returns(PrivateAssociationRelation) }
                     def all; end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def and(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def annotate(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def arel_columns(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def create_with(*args, &blk); end
 
                     sig { params(value: T::Boolean).returns(PrivateAssociationRelation) }
                     def distinct(value = true); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def eager_load(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def except(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def excluding(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def extending(*args, &blk); end
 
-                    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+                    sig { params(association: ::Symbol).returns(T::Array[::T.untyped]) }
                     def extract_associated(association); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def from(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelationGroupChain) }
                     def group(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def having(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def in_order_of(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def includes(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def invert_where(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def left_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def left_outer_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def limit(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def lock(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def merge(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def none(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def null_relation?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def offset(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def only(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def optimizer_hints(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def or(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def preload(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def readonly(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def references(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def regroup(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reorder(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reselect(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def reverse_order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def rewhere(*args, &blk); end
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
-                    sig { params(blk: T.proc.params(record: ::Post).returns(BasicObject)).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(blk: ::T.proc.params(record: ::Post).returns(::BasicObject)).returns(T::Array[::Post]) }
                     def select(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def strict_loading(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def structurally_compatible?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def uniq!(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def unscope(*args, &blk); end
 
                     sig { returns(PrivateAssociationRelation) }
-                    sig { type_parameters(:U).params(block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { type_parameters(:U).params(block: ::T.proc.returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def unscoped(&block); end
 
                     sig { returns(PrivateAssociationRelationWhereChain) }
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def where(*args); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with_recursive(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def without(*args, &blk); end
                   end
 
@@ -1184,148 +1184,148 @@ module GeneratedRelationMethods
                     sig { returns(PrivateRelation) }
                     def all; end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def and(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def annotate(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def arel_columns(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def create_with(*args, &blk); end
 
                     sig { params(value: T::Boolean).returns(PrivateRelation) }
                     def distinct(value = true); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def eager_load(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def except(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def excluding(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def extending(*args, &blk); end
 
-                    sig { params(association: Symbol).returns(T::Array[T.untyped]) }
+                    sig { params(association: ::Symbol).returns(T::Array[::T.untyped]) }
                     def extract_associated(association); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def from(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelationGroupChain) }
                     def group(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def having(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def in_order_of(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def includes(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def invert_where(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def left_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def left_outer_joins(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def limit(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def lock(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def merge(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def none(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def null_relation?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def offset(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def only(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def optimizer_hints(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def or(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def preload(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def readonly(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def references(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def regroup(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reorder(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reselect(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def reverse_order(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def rewhere(*args, &blk); end
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
-                    sig { params(blk: T.proc.params(record: ::Post).returns(BasicObject)).returns(T::Array[::Post]) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
+                    sig { params(blk: ::T.proc.params(record: ::Post).returns(::BasicObject)).returns(T::Array[::Post]) }
                     def select(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def strict_loading(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def structurally_compatible?(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def uniq!(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def unscope(*args, &blk); end
 
                     sig { returns(PrivateRelation) }
-                    sig { type_parameters(:U).params(block: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
+                    sig { type_parameters(:U).params(block: ::T.proc.returns(::T.type_parameter(:U))).returns(::T.type_parameter(:U)) }
                     def unscoped(&block); end
 
                     sig { returns(PrivateRelationWhereChain) }
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def where(*args); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with_recursive(*args, &blk); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def without(*args, &blk); end
                   end
 
@@ -1345,41 +1345,41 @@ def to_ary; end
                   class PrivateAssociationRelationGroupChain < PrivateAssociationRelation
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def average(column_name); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+                    sig { params(column_name: ::T.untyped).returns(T::Hash[::T.untyped, ::Integer]) }
                     def count(column_name = nil); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.self_type) }
                     def having(*args, &blk); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def maximum(column_name); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def minimum(column_name); end
 
-                    sig { returns(T::Hash[T.untyped, Integer]) }
+                    sig { returns(T::Hash[::T.untyped, ::Integer]) }
                     def size; end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol)), block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol)), block: ::T.nilable(::T.proc.params(record: ::T.untyped).returns(::T.untyped))).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def sum(column_name = nil, &block); end
                   end
 
                   class PrivateAssociationRelationWhereChain
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def associated(*args); end
 
-                    sig { params(args: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateAssociationRelation) }
                     def missing(*args); end
 
-                    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(opts: ::T.untyped, rest: ::T.untyped).returns(PrivateAssociationRelation) }
                     def not(opts, *rest); end
                   end
 
@@ -1389,28 +1389,28 @@ class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy
 
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def <<(*records); end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def append(*records); end
 
                     sig { returns(PrivateCollectionProxy) }
                     def clear; end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def concat(*records); end
 
                     sig { returns(T::Array[::Post]) }
                     def load_target; end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def prepend(*records); end
 
-                    sig { params(records: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
+                    sig { params(records: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(PrivateCollectionProxy) }
                     def push(*records); end
 
-                    sig { params(other_array: T.any(::Post, T::Enumerable[T.any(::Post, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
+                    sig { params(other_array: ::T.any(::Post, T::Enumerable[::T.any(::Post, T::Enumerable[::Post])])).returns(T::Array[::Post]) }
                     def replace(other_array); end
 
                     sig { returns(PrivateAssociationRelation) }
@@ -1442,41 +1442,41 @@ def to_ary; end
                   class PrivateRelationGroupChain < PrivateRelation
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def average(column_name); end
 
-                    sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(operation: ::Symbol, column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def calculate(operation, column_name); end
 
-                    sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) }
+                    sig { params(column_name: ::T.untyped).returns(T::Hash[::T.untyped, ::Integer]) }
                     def count(column_name = nil); end
 
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.self_type) }
                     def having(*args, &blk); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def maximum(column_name); end
 
-                    sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) }
+                    sig { params(column_name: ::T.any(::String, ::Symbol)).returns(T::Hash[::T.untyped, ::T.untyped]) }
                     def minimum(column_name); end
 
-                    sig { returns(T::Hash[T.untyped, Integer]) }
+                    sig { returns(T::Hash[::T.untyped, ::Integer]) }
                     def size; end
 
-                    sig { params(column_name: T.nilable(T.any(String, Symbol)), block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped))).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) }
+                    sig { params(column_name: ::T.nilable(::T.any(::String, ::Symbol)), block: ::T.nilable(::T.proc.params(record: ::T.untyped).returns(::T.untyped))).returns(T::Hash[::T.untyped, ::T.any(::Integer, ::Float, ::BigDecimal)]) }
                     def sum(column_name = nil, &block); end
                   end
 
                   class PrivateRelationWhereChain
                     Elem = type_member { { fixed: ::Post } }
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def associated(*args); end
 
-                    sig { params(args: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped).returns(PrivateRelation) }
                     def missing(*args); end
 
-                    sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) }
+                    sig { params(opts: ::T.untyped, rest: ::T.untyped).returns(PrivateRelation) }
                     def not(opts, *rest); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/active_record_scope_spec.rb b/spec/tapioca/dsl/compilers/active_record_scope_spec.rb
index 0e56bdbde..f638b16f2 100644
--- a/spec/tapioca/dsl/compilers/active_record_scope_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_scope_spec.rb
@@ -69,12 +69,12 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedAssociationRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def public_kind(*args, &blk); end
                     end
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def public_kind(*args, &blk); end
                     end
                   end
@@ -98,18 +98,18 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedAssociationRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def private_kind(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def public_kind(*args, &blk); end
                     end
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def private_kind(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def public_kind(*args, &blk); end
                     end
                   end
@@ -140,24 +140,24 @@ class SuperCustomPost
                     extend GeneratedRelationMethods
 
                     module GeneratedAssociationRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def custom_post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def super_custom_post_scope(*args, &blk); end
                     end
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def custom_post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def super_custom_post_scope(*args, &blk); end
                     end
                   end
@@ -186,18 +186,18 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedAssociationRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def app_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def post_scope(*args, &blk); end
                     end
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def app_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def post_scope(*args, &blk); end
                     end
                   end
@@ -234,12 +234,12 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedAssociationRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                       def post_scope(*args, &blk); end
                     end
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                       def post_scope(*args, &blk); end
                     end
                   end
@@ -277,7 +277,7 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def public_kind(*args, &blk); end
                     end
                   end
@@ -301,10 +301,10 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def private_kind(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def public_kind(*args, &blk); end
                     end
                   end
@@ -327,16 +327,16 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def active(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def archived(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def not_active(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def not_archived(*args, &blk); end
                     end
                   end
@@ -367,13 +367,13 @@ class SuperCustomPost
                     extend GeneratedRelationMethods
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def custom_post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def post_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def super_custom_post_scope(*args, &blk); end
                     end
                   end
@@ -402,10 +402,10 @@ class Post
                     extend GeneratedRelationMethods
 
                     module GeneratedRelationMethods
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def app_scope(*args, &blk); end
 
-                      sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                      sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                       def post_scope(*args, &blk); end
                     end
                   end
@@ -438,12 +438,12 @@ class Post
                   extend GeneratedRelationMethods
 
                   module GeneratedAssociationRelationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with_attached_photo(*args, &blk); end
                   end
 
                   module GeneratedRelationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with_attached_photo(*args, &blk); end
                   end
                 end
@@ -466,12 +466,12 @@ class Post
                   extend GeneratedRelationMethods
 
                   module GeneratedAssociationRelationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateAssociationRelation) }
                     def with_attached_photos(*args, &blk); end
                   end
 
                   module GeneratedRelationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(PrivateRelation) }
                     def with_attached_photos(*args, &blk); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/active_record_store_spec.rb b/spec/tapioca/dsl/compilers/active_record_store_spec.rb
index f0bd40253..526653584 100644
--- a/spec/tapioca/dsl/compilers/active_record_store_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_store_spec.rb
@@ -60,28 +60,28 @@ class User
                   include GeneratedStoredAttributesMethods
 
                   module GeneratedStoredAttributesMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def saved_change_to_theme; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_theme?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def theme=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_before_last_save; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_change; end
 
                     sig { returns(T::Boolean) }
                     def theme_changed?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_was; end
                   end
                 end
@@ -104,28 +104,28 @@ class User
                   include GeneratedStoredAttributesMethods
 
                   module GeneratedStoredAttributesMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def saved_change_to_theme; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_theme?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def theme=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_before_last_save; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_change; end
 
                     sig { returns(T::Boolean) }
                     def theme_changed?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def theme_was; end
                   end
                 end
@@ -145,25 +145,25 @@ class User < ActiveRecord::Base
               output = rbi_for(:User)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def theme=(value); end
               RBI
               assert_includes(output, expected)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def language=(value); end
               RBI
               assert_includes(output, expected)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def power_source=(value); end
               RBI
               assert_includes(output, expected)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def expiry=(value); end
               RBI
               assert_includes(output, expected)
@@ -180,13 +180,13 @@ class User < ActiveRecord::Base
               output = rbi_for(:User)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def settings_theme=(value); end
               RBI
               assert_includes(output, expected)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def prefs_power_source=(value); end
               RBI
               assert_includes(output, expected)
@@ -203,13 +203,13 @@ class User < ActiveRecord::Base
               output = rbi_for(:User)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def theme_settings=(value); end
               RBI
               assert_includes(output, expected)
 
               expected = indented(<<~RBI, 4)
-                sig { params(value: T.untyped).returns(T.untyped) }
+                sig { params(value: ::T.untyped).returns(::T.untyped) }
                 def power_source_prefs=(value); end
               RBI
               assert_includes(output, expected)
diff --git a/spec/tapioca/dsl/compilers/active_record_typed_store_spec.rb b/spec/tapioca/dsl/compilers/active_record_typed_store_spec.rb
index e6e3b3ce2..3a66a659b 100644
--- a/spec/tapioca/dsl/compilers/active_record_typed_store_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_record_typed_store_spec.rb
@@ -83,58 +83,58 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def reviewer; end
 
-                    sig { params(reviewer: T.nilable(String)).returns(T.nilable(String)) }
+                    sig { params(reviewer: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def reviewer=(reviewer); end
 
                     sig { returns(T::Boolean) }
                     def reviewer?; end
 
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def reviewer_before_last_save; end
 
-                    sig { returns(T.nilable([T.nilable(String), T.nilable(String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def reviewer_change; end
 
                     sig { returns(T::Boolean) }
                     def reviewer_changed?; end
 
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def reviewer_was; end
 
-                    sig { returns(T.nilable([T.nilable(String), T.nilable(String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def saved_change_to_reviewer; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_reviewer?; end
 
-                    sig { returns(T.nilable([T.nilable(String), T.nilable(String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def saved_change_to_title; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_title?; end
 
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(String)).returns(T.nilable(String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
 
                     sig { returns(T::Boolean) }
                     def title?; end
 
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title_before_last_save; end
 
-                    sig { returns(T.nilable([T.nilable(String), T.nilable(String)])) }
+                    sig { returns(::T.nilable([::T.nilable(::String), ::T.nilable(::String)])) }
                     def title_change; end
 
                     sig { returns(T::Boolean) }
                     def title_changed?; end
 
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title_was; end
                   end
                 end
@@ -171,7 +171,7 @@ def reviewed?; end
                     sig { returns(T::Boolean) }
                     def reviewed_before_last_save; end
 
-                    sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+                    sig { returns(::T.nilable([T::Boolean, T::Boolean])) }
                     def reviewed_change; end
 
                     sig { returns(T::Boolean) }
@@ -180,7 +180,7 @@ def reviewed_changed?; end
                     sig { returns(T::Boolean) }
                     def reviewed_was; end
 
-                    sig { returns(T.nilable([T::Boolean, T::Boolean])) }
+                    sig { returns(::T.nilable([T::Boolean, T::Boolean])) }
                     def saved_change_to_reviewed; end
 
                     sig { returns(T::Boolean) }
@@ -212,58 +212,58 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def review_date; end
 
-                    sig { params(review_date: T.nilable(Date)).returns(T.nilable(Date)) }
+                    sig { params(review_date: ::T.nilable(::Date)).returns(::T.nilable(::Date)) }
                     def review_date=(review_date); end
 
                     sig { returns(T::Boolean) }
                     def review_date?; end
 
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def review_date_before_last_save; end
 
-                    sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+                    sig { returns(::T.nilable([::T.nilable(::Date), ::T.nilable(::Date)])) }
                     def review_date_change; end
 
                     sig { returns(T::Boolean) }
                     def review_date_changed?; end
 
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def review_date_was; end
 
-                    sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+                    sig { returns(::T.nilable([::T.nilable(::Date), ::T.nilable(::Date)])) }
                     def saved_change_to_review_date; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_review_date?; end
 
-                    sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+                    sig { returns(::T.nilable([::T.nilable(::Date), ::T.nilable(::Date)])) }
                     def saved_change_to_title_date; end
 
                     sig { returns(T::Boolean) }
                     def saved_change_to_title_date?; end
 
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def title_date; end
 
-                    sig { params(title_date: T.nilable(Date)).returns(T.nilable(Date)) }
+                    sig { params(title_date: ::T.nilable(::Date)).returns(::T.nilable(::Date)) }
                     def title_date=(title_date); end
 
                     sig { returns(T::Boolean) }
                     def title_date?; end
 
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def title_date_before_last_save; end
 
-                    sig { returns(T.nilable([T.nilable(Date), T.nilable(Date)])) }
+                    sig { returns(::T.nilable([::T.nilable(::Date), ::T.nilable(::Date)])) }
                     def title_date_change; end
 
                     sig { returns(T::Boolean) }
                     def title_date_changed?; end
 
-                    sig { returns(T.nilable(Date)) }
+                    sig { returns(::T.nilable(::Date)) }
                     def title_date_was; end
                   end
                 end
@@ -288,10 +288,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(DateTime)) }
+                    sig { returns(::T.nilable(::DateTime)) }
                     def review_date; end
 
-                    sig { params(review_date: T.nilable(DateTime)).returns(T.nilable(DateTime)) }
+                    sig { params(review_date: ::T.nilable(::DateTime)).returns(::T.nilable(::DateTime)) }
                     def review_date=(review_date); end
               RBI
 
@@ -314,10 +314,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(Time)) }
+                    sig { returns(::T.nilable(::Time)) }
                     def review_time; end
 
-                    sig { params(review_time: T.nilable(Time)).returns(T.nilable(Time)) }
+                    sig { params(review_time: ::T.nilable(::Time)).returns(::T.nilable(::Time)) }
                     def review_time=(review_time); end
               RBI
 
@@ -340,10 +340,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(BigDecimal)) }
+                    sig { returns(::T.nilable(::BigDecimal)) }
                     def rate; end
 
-                    sig { params(rate: T.nilable(BigDecimal)).returns(T.nilable(BigDecimal)) }
+                    sig { params(rate: ::T.nilable(::BigDecimal)).returns(::T.nilable(::BigDecimal)) }
                     def rate=(rate); end
               RBI
 
@@ -366,10 +366,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def kind; end
 
-                    sig { params(kind: T.untyped).returns(T.untyped) }
+                    sig { params(kind: ::T.untyped).returns(::T.untyped) }
                     def kind=(kind); end
               RBI
 
@@ -392,10 +392,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def rate; end
 
-                    sig { params(rate: T.nilable(Integer)).returns(T.nilable(Integer)) }
+                    sig { params(rate: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                     def rate=(rate); end
               RBI
 
@@ -418,10 +418,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(Float)) }
+                    sig { returns(::T.nilable(::Float)) }
                     def rate; end
 
-                    sig { params(rate: T.nilable(Float)).returns(T.nilable(Float)) }
+                    sig { params(rate: ::T.nilable(::Float)).returns(::T.nilable(::Float)) }
                     def rate=(rate); end
               RBI
 
@@ -444,10 +444,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(T::Array[T.nilable(String)])) }
+                    sig { returns(::T.nilable(T::Array[::T.nilable(::String)])) }
                     def comments; end
 
-                    sig { params(comments: T.nilable(T::Array[T.nilable(String)])).returns(T.nilable(T::Array[T.nilable(String)])) }
+                    sig { params(comments: ::T.nilable(T::Array[::T.nilable(::String)])).returns(::T.nilable(T::Array[::T.nilable(::String)])) }
                     def comments=(comments); end
               RBI
 
@@ -471,10 +471,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T::Array[T.nilable(String)]) }
+                    sig { returns(T::Array[::T.nilable(::String)]) }
                     def comments; end
 
-                    sig { params(comments: T::Array[T.nilable(String)]).returns(T::Array[T.nilable(String)]) }
+                    sig { params(comments: T::Array[::T.nilable(::String)]).returns(T::Array[::T.nilable(::String)]) }
                     def comments=(comments); end
               RBI
 
@@ -498,10 +498,10 @@ class Post
                   include StoreAccessors
 
                   module StoreAccessors
-                    sig { returns(T.nilable(String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def metadata_rate_metadata; end
 
-                    sig { params(metadata_rate_metadata: T.nilable(String)).returns(T.nilable(String)) }
+                    sig { params(metadata_rate_metadata: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def metadata_rate_metadata=(metadata_rate_metadata); end
               RBI
 
diff --git a/spec/tapioca/dsl/compilers/active_resource_spec.rb b/spec/tapioca/dsl/compilers/active_resource_spec.rb
index bd33d532a..3ee0f55fa 100644
--- a/spec/tapioca/dsl/compilers/active_resource_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_resource_spec.rb
@@ -48,10 +48,10 @@ class Post < ActiveResource::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def id; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def id=(value); end
 
                   sig { returns(T::Boolean) }
@@ -75,28 +75,28 @@ class Post < ActiveResource::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def id; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def id=(value); end
 
                   sig { returns(T::Boolean) }
                   def id?; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def month; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def month=(value); end
 
                   sig { returns(T::Boolean) }
                   def month?; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def year; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def year=(value); end
 
                   sig { returns(T::Boolean) }
@@ -121,19 +121,19 @@ class Post < ActiveResource::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def month; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def month=(value); end
 
                   sig { returns(T::Boolean) }
                   def month?; end
 
-                  sig { returns(String) }
+                  sig { returns(::String) }
                   def title; end
 
-                  sig { params(value: String).returns(String) }
+                  sig { params(value: ::String).returns(::String) }
                   def title=(value); end
 
                   sig { returns(T::Boolean) }
@@ -157,10 +157,10 @@ class Post < ActiveResource::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def id; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def id=(value); end
 
                   sig { returns(T::Boolean) }
@@ -197,47 +197,47 @@ def reviewed=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Integer).returns(Integer) }
+                sig { params(value: ::Integer).returns(::Integer) }
                 def id=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: String).returns(String) }
+                sig { params(value: ::String).returns(::String) }
                 def title=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Float).returns(Float) }
+                sig { params(value: ::Float).returns(::Float) }
                 def price=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Date).returns(Date) }
+                sig { params(value: ::Date).returns(::Date) }
                 def month=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Time).returns(Time) }
+                sig { params(value: ::Time).returns(::Time) }
                 def post_time=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: DateTime).returns(DateTime) }
+                sig { params(value: ::DateTime).returns(::DateTime) }
                 def review_time=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: BigDecimal).returns(BigDecimal) }
+                sig { params(value: ::BigDecimal).returns(::BigDecimal) }
                 def credit_point=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: String).returns(String) }
+                sig { params(value: ::String).returns(::String) }
                 def active=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: String).returns(String) }
+                sig { params(value: ::String).returns(::String) }
                 def message=(value); end
               RBI
             end
diff --git a/spec/tapioca/dsl/compilers/active_storage_spec.rb b/spec/tapioca/dsl/compilers/active_storage_spec.rb
index 434daaa1b..088cebb1e 100644
--- a/spec/tapioca/dsl/compilers/active_storage_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_storage_spec.rb
@@ -76,10 +76,10 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(ActiveStorage::Attached::One) }
+                  sig { returns(::ActiveStorage::Attached::One) }
                   def photo; end
 
-                  sig { params(attachable: T.untyped).returns(T.untyped) }
+                  sig { params(attachable: ::T.untyped).returns(::T.untyped) }
                   def photo=(attachable); end
                 end
               RBI
@@ -98,10 +98,10 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(ActiveStorage::Attached::Many) }
+                  sig { returns(::ActiveStorage::Attached::Many) }
                   def photos; end
 
-                  sig { params(attachable: T.untyped).returns(T.untyped) }
+                  sig { params(attachable: ::T.untyped).returns(::T.untyped) }
                   def photos=(attachable); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/active_support_current_attributes_spec.rb b/spec/tapioca/dsl/compilers/active_support_current_attributes_spec.rb
index 94fc7810c..2fa17a3b0 100644
--- a/spec/tapioca/dsl/compilers/active_support_current_attributes_spec.rb
+++ b/spec/tapioca/dsl/compilers/active_support_current_attributes_spec.rb
@@ -60,30 +60,30 @@ class Current
                   include GeneratedAttributeMethods
 
                   class << self
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def account; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def account=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def user; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def user=(value); end
                   end
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def account; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def account=(value); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def user; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def user=(value); end
                   end
                 end
@@ -103,7 +103,7 @@ def helper
                     # ...
                   end
 
-                  sig { params(user_id: Integer, block: T.proc.void).void }
+                  sig { params(user_id: Integer, block: ::T.proc.void).void }
                   def authenticate(user_id, &block)
                     # ...
                   end
@@ -117,24 +117,24 @@ class Current
                   include GeneratedAttributeMethods
 
                   class << self
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def account; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def account=(value); end
 
-                    sig { params(user_id: ::Integer, block: T.proc.void).void }
+                    sig { params(user_id: ::Integer, block: ::T.proc.void).void }
                     def authenticate(user_id, &block); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def helper; end
                   end
 
                   module GeneratedAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def account; end
 
-                    sig { params(value: T.untyped).returns(T.untyped) }
+                    sig { params(value: ::T.untyped).returns(::T.untyped) }
                     def account=(value); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/config_spec.rb b/spec/tapioca/dsl/compilers/config_spec.rb
index 83f82aef8..8f8394a40 100644
--- a/spec/tapioca/dsl/compilers/config_spec.rb
+++ b/spec/tapioca/dsl/compilers/config_spec.rb
@@ -48,18 +48,18 @@ def before_setup
                 class SettingsConfigOptions < ::Config::Options
                   extend T::Generic
 
-                  Elem = type_member { { fixed: T.untyped } }
+                  Elem = type_member { { fixed: ::T.untyped } }
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def github_key; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def github_key=(value); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def slack_token; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def slack_token=(value); end
                 end
               RBI
@@ -86,18 +86,18 @@ def slack_token=(value); end
                 class FooConfigOptions < ::Config::Options
                   extend T::Generic
 
-                  Elem = type_member { { fixed: T.untyped } }
+                  Elem = type_member { { fixed: ::T.untyped } }
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def github_key; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def github_key=(value); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def slack_token; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def slack_token=(value); end
                 end
               RBI
@@ -127,18 +127,18 @@ def slack_token=(value); end
                 class SettingsConfigOptions < ::Config::Options
                   extend T::Generic
 
-                  Elem = type_member { { fixed: T.untyped } }
+                  Elem = type_member { { fixed: ::T.untyped } }
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def github; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def github=(value); end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def slack; end
 
-                  sig { params(value: T.untyped).returns(T.untyped) }
+                  sig { params(value: ::T.untyped).returns(::T.untyped) }
                   def slack=(value); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/frozen_record_spec.rb b/spec/tapioca/dsl/compilers/frozen_record_spec.rb
index 889c9abe9..cf2335aa9 100644
--- a/spec/tapioca/dsl/compilers/frozen_record_spec.rb
+++ b/spec/tapioca/dsl/compilers/frozen_record_spec.rb
@@ -74,19 +74,19 @@ class Student
                   include FrozenRecordAttributeMethods
 
                   module FrozenRecordAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def first_name; end
 
                     sig { returns(T::Boolean) }
                     def first_name?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def id; end
 
                     sig { returns(T::Boolean) }
                     def id?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def last_name; end
 
                     sig { returns(T::Boolean) }
@@ -122,13 +122,13 @@ class Student
                   extend GeneratedRelationMethods
 
                   module FrozenRecordAttributeMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def course; end
 
                     sig { returns(T::Boolean) }
                     def course?; end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def id; end
 
                     sig { returns(T::Boolean) }
@@ -136,7 +136,7 @@ def id?; end
                   end
 
                   module GeneratedRelationMethods
-                    sig { params(args: T.untyped, blk: T.untyped).returns(T.untyped) }
+                    sig { params(args: ::T.untyped, blk: ::T.untyped).returns(::T.untyped) }
                     def programmers(*args, &blk); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/graphql_input_object_spec.rb b/spec/tapioca/dsl/compilers/graphql_input_object_spec.rb
index 918dabfaf..ecfe3d5c8 100644
--- a/spec/tapioca/dsl/compilers/graphql_input_object_spec.rb
+++ b/spec/tapioca/dsl/compilers/graphql_input_object_spec.rb
@@ -126,7 +126,7 @@ def resolve(body:, post_id:)
                 # typed: strong
 
                 class CreateCommentInput
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def transport; end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/graphql_mutation_spec.rb b/spec/tapioca/dsl/compilers/graphql_mutation_spec.rb
index 1311f6ae2..05bf14c09 100644
--- a/spec/tapioca/dsl/compilers/graphql_mutation_spec.rb
+++ b/spec/tapioca/dsl/compilers/graphql_mutation_spec.rb
@@ -73,7 +73,7 @@ def resolve(body:, post_id:)
                 # typed: strong
 
                 class CreateComment
-                  sig { params(body: ::String, post_id: ::String).returns(T.untyped) }
+                  sig { params(body: ::String, post_id: ::String).returns(::T.untyped) }
                   def resolve(body:, post_id:); end
                 end
               RBI
@@ -89,7 +89,7 @@ class CreateComment < GraphQL::Schema::Mutation
                   argument :body, String, required: true
                   argument :post_id, ID, required: true
 
-                  sig { params(body: String, post_id: String).returns(T.untyped) }
+                  sig { params(body: String, post_id: String).returns(::T.untyped) }
                   def resolve(body:, post_id:)
                     # ...
                   end
@@ -120,7 +120,7 @@ def resolve(body:, author:, post_id:)
                 # typed: strong
 
                 class CreateComment
-                  sig { params(body: ::String, author: T.nilable(::String), post_id: ::String).returns(T.untyped) }
+                  sig { params(body: ::String, author: ::T.nilable(::String), post_id: ::String).returns(::T.untyped) }
                   def resolve(body:, author:, post_id:); end
                 end
               RBI
@@ -169,7 +169,7 @@ def resolve(boolean:, float:, id:, int:, big_int:, date:, datetime:, json:, stri
                 # typed: strong
 
                 class CreateComment
-                  sig { params(boolean: T::Boolean, float: ::Float, id: ::String, int: ::Integer, big_int: ::Integer, date: ::Date, datetime: ::Time, json: T::Hash[::String, T.untyped], string: ::String, enum_a: ::String, enum_b: T.any(::String, ::Symbol), input_object: ::CreateCommentInput, custom_scalar: T.untyped).returns(T.untyped) }
+                  sig { params(boolean: T::Boolean, float: ::Float, id: ::String, int: ::Integer, big_int: ::Integer, date: ::Date, datetime: ::Time, json: T::Hash[::String, ::T.untyped], string: ::String, enum_a: ::String, enum_b: ::T.any(::String, ::Symbol), input_object: ::CreateCommentInput, custom_scalar: ::T.untyped).returns(::T.untyped) }
                   def resolve(boolean:, float:, id:, int:, big_int:, date:, datetime:, json:, string:, enum_a:, enum_b:, input_object:, custom_scalar:); end
                 end
               RBI
@@ -216,7 +216,7 @@ def resolve(min:, max:, other:, proc:)
                 # typed: strong
 
                 class CreateComment
-                  sig { params(min: T::Range[::Date], max: ::Date, other: ::Date, proc: ::Date).returns(T.untyped) }
+                  sig { params(min: T::Range[::Date], max: ::Date, other: ::Date, proc: ::Date).returns(::T.untyped) }
                   def resolve(min:, max:, other:, proc:); end
                 end
               RBI
@@ -264,7 +264,7 @@ def resolve(comment_input:)
                 # typed: strong
 
                 class CreateComment
-                  sig { params(comment_input: T.untyped).returns(T.untyped) }
+                  sig { params(comment_input: ::T.untyped).returns(::T.untyped) }
                   def resolve(comment_input:); end
                 end
               RBI
@@ -322,7 +322,7 @@ def resolve(date_range:, void_input:, untyped_input:)
                 # typed: strong
 
                 class CreateComment
-                  sig { params(date_range: T::Range[::Date], void_input: ::VoidInput, untyped_input: ::UntypedInput).returns(T.untyped) }
+                  sig { params(date_range: T::Range[::Date], void_input: ::VoidInput, untyped_input: ::UntypedInput).returns(::T.untyped) }
                   def resolve(date_range:, void_input:, untyped_input:); end
                 end
               RBI
@@ -353,7 +353,7 @@ def resolve(loaded_argument:, loaded_arguments:, custom_name:, optional_loaded_a
                 # typed: strong
 
                 class CreateComment
-                  sig { params(loaded_argument: ::LoadedType, loaded_arguments: T::Array[::LoadedType], custom_name: ::LoadedType, optional_loaded_argument: T.nilable(::LoadedType), optional_loaded_arguments: T.nilable(T::Array[::LoadedType])).returns(T.untyped) }
+                  sig { params(loaded_argument: ::LoadedType, loaded_arguments: T::Array[::LoadedType], custom_name: ::LoadedType, optional_loaded_argument: ::T.nilable(::LoadedType), optional_loaded_arguments: ::T.nilable(T::Array[::LoadedType])).returns(::T.untyped) }
                   def resolve(loaded_argument:, loaded_arguments:, custom_name:, optional_loaded_argument: T.unsafe(nil), optional_loaded_arguments: T.unsafe(nil)); end
                 end
               RBI
@@ -369,7 +369,7 @@ class CustomScalarType < GraphQL::Schema::Scalar
                   class << self
                     extend T::Sig
 
-                    sig { params(value: T.untyped, context: GraphQL::Query::Context).returns(CustomScalar) }
+                    sig { params(value: ::T.untyped, context: GraphQL::Query::Context).returns(CustomScalar) }
                     def coerce_input(value, context)
                       CustomScalar.new
                     end
@@ -380,7 +380,7 @@ class BrokenScalarType < GraphQL::Schema::Scalar
                   class << self
                     extend T::Sig
 
-                    sig { params(value: T.untyped, context: GraphQL::Query::Context).void }
+                    sig { params(value: ::T.untyped, context: GraphQL::Query::Context).void }
                     def coerce_input(value, context)
                     end
                   end
@@ -410,7 +410,7 @@ def resolve(custom_scalar:, custom_scalar_array:, broken_scalar:, no_sig_scalar:
                 # typed: strong
 
                 class CreateComment
-                  sig { params(custom_scalar: ::CustomScalar, custom_scalar_array: T::Array[::CustomScalar], broken_scalar: T.untyped, no_sig_scalar: T.untyped, optional_custom_scalar: T.nilable(::CustomScalar)).returns(T.untyped) }
+                  sig { params(custom_scalar: ::CustomScalar, custom_scalar_array: T::Array[::CustomScalar], broken_scalar: ::T.untyped, no_sig_scalar: ::T.untyped, optional_custom_scalar: ::T.nilable(::CustomScalar)).returns(::T.untyped) }
                   def resolve(custom_scalar:, custom_scalar_array:, broken_scalar:, no_sig_scalar:, optional_custom_scalar: T.unsafe(nil)); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/identity_cache_spec.rb b/spec/tapioca/dsl/compilers/identity_cache_spec.rb
index 1acc4b826..5f5407f2b 100644
--- a/spec/tapioca/dsl/compilers/identity_cache_spec.rb
+++ b/spec/tapioca/dsl/compilers/identity_cache_spec.rb
@@ -84,28 +84,28 @@ class Post < ActiveRecord::Base
 
                 class Post
                   class << self
-                    sig { params(blog_id: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(blog_id: ::T.untyped, includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_by_blog_id(blog_id, includes: nil); end
 
-                    sig { params(title: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(title: ::T.untyped, includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_by_title(title, includes: nil); end
 
-                    sig { params(blog_id: T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
+                    sig { params(blog_id: ::T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
                     def fetch_id_by_blog_id(blog_id); end
 
-                    sig { params(title: T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
+                    sig { params(title: ::T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
                     def fetch_id_by_title(title); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_blog_id(index_values, includes: nil); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_title(index_values, includes: nil); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_blog_id(keys); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_title(keys); end
                   end
                 end
@@ -139,31 +139,31 @@ class Post < ActiveRecord::Base
 
                 class Post
                   class << self
-                    sig { params(blog_id: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(blog_id: ::T.untyped, includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_by_blog_id(blog_id, includes: nil); end
 
-                    sig { params(title: T.untyped, includes: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(title: ::T.untyped, includes: ::T.untyped).returns(::T.nilable(::Post)) }
                     def fetch_by_title(title, includes: nil); end
 
-                    sig { params(title: T.untyped, includes: T.untyped).returns(::Post) }
+                    sig { params(title: ::T.untyped, includes: ::T.untyped).returns(::Post) }
                     def fetch_by_title!(title, includes: nil); end
 
-                    sig { params(blog_id: T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
+                    sig { params(blog_id: ::T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
                     def fetch_id_by_blog_id(blog_id); end
 
-                    sig { params(title: T.untyped).returns(T.nilable(::Integer)) }
+                    sig { params(title: ::T.untyped).returns(::T.nilable(::Integer)) }
                     def fetch_id_by_title(title); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_blog_id(index_values, includes: nil); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_title(index_values, includes: nil); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_blog_id(keys); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_title(keys); end
                   end
                 end
@@ -196,16 +196,16 @@ class Post < ActiveRecord::Base
 
                 class Post
                   class << self
-                    sig { params(blog_id: T.untyped, title: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(blog_id: ::T.untyped, title: ::T.untyped, includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_by_blog_id_and_title(blog_id, title, includes: nil); end
 
-                    sig { params(blog_id: T.untyped, title: T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
+                    sig { params(blog_id: ::T.untyped, title: ::T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
                     def fetch_id_by_blog_id_and_title(blog_id, title); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_blog_id_and_title(index_values, includes: nil); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_blog_id_and_title(keys); end
                   end
                 end
@@ -239,31 +239,31 @@ class Post < ActiveRecord::Base
 
                 class Post
                   class << self
-                    sig { params(title: T.untyped, includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(title: ::T.untyped, includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_by_title(title, includes: nil); end
 
-                    sig { params(title: T.untyped, review_date: T.untyped, includes: T.untyped).returns(T.nilable(::Post)) }
+                    sig { params(title: ::T.untyped, review_date: ::T.untyped, includes: ::T.untyped).returns(::T.nilable(::Post)) }
                     def fetch_by_title_and_review_date(title, review_date, includes: nil); end
 
-                    sig { params(title: T.untyped, review_date: T.untyped, includes: T.untyped).returns(::Post) }
+                    sig { params(title: ::T.untyped, review_date: ::T.untyped, includes: ::T.untyped).returns(::Post) }
                     def fetch_by_title_and_review_date!(title, review_date, includes: nil); end
 
-                    sig { params(title: T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
+                    sig { params(title: ::T.untyped).returns(T::Array[::T.nilable(::Integer)]) }
                     def fetch_id_by_title(title); end
 
-                    sig { params(title: T.untyped, review_date: T.untyped).returns(T.nilable(::Integer)) }
+                    sig { params(title: ::T.untyped, review_date: ::T.untyped).returns(::T.nilable(::Integer)) }
                     def fetch_id_by_title_and_review_date(title, review_date); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_title(index_values, includes: nil); end
 
-                    sig { params(index_values: T::Enumerable[T.untyped], includes: T.untyped).returns(T::Array[::Post]) }
+                    sig { params(index_values: T::Enumerable[::T.untyped], includes: ::T.untyped).returns(T::Array[::Post]) }
                     def fetch_multi_by_title_and_review_date(index_values, includes: nil); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_title(keys); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::Integer]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::Integer]) }
                     def fetch_multi_id_by_title_and_review_date(keys); end
                   end
                 end
@@ -303,7 +303,7 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(T::Array[T.untyped]) }
+                  sig { returns(T::Array[::T.untyped]) }
                   def fetch_user_ids; end
 
                   sig { returns(T::Array[::User]) }
@@ -345,10 +345,10 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(T.nilable(::User)) }
+                  sig { returns(::T.nilable(::User)) }
                   def fetch_user; end
 
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def fetch_user_id; end
                 end
               RBI
@@ -387,7 +387,7 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(T.untyped) }
+                  sig { returns(::T.untyped) }
                   def fetch_user; end
                 end
               RBI
@@ -420,16 +420,16 @@ class Post < ActiveRecord::Base
 
                 class Post
                   class << self
-                    sig { params(id: T.untyped).returns(T.nilable(::String)) }
+                    sig { params(id: ::T.untyped).returns(::T.nilable(::String)) }
                     def fetch_author_by_id(id); end
 
-                    sig { params(id: T.untyped, author: T.untyped).returns(T.nilable(::String)) }
+                    sig { params(id: ::T.untyped, author: ::T.untyped).returns(::T.nilable(::String)) }
                     def fetch_author_by_id_and_author(id, author); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::String]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::String]) }
                     def fetch_multi_author_by_id(keys); end
 
-                    sig { params(keys: T::Enumerable[T.untyped]).returns(T::Array[::String]) }
+                    sig { params(keys: T::Enumerable[::T.untyped]).returns(T::Array[::String]) }
                     def fetch_multi_author_by_id_and_author(keys); end
                   end
                 end
@@ -469,7 +469,7 @@ class Post < ActiveRecord::Base
                 # typed: strong
 
                 class Post
-                  sig { returns(T.nilable(::User)) }
+                  sig { returns(::T.nilable(::User)) }
                   def fetch_user; end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/json_api_client_resource_spec.rb b/spec/tapioca/dsl/compilers/json_api_client_resource_spec.rb
index e30e96638..076084be2 100644
--- a/spec/tapioca/dsl/compilers/json_api_client_resource_spec.rb
+++ b/spec/tapioca/dsl/compilers/json_api_client_resource_spec.rb
@@ -84,16 +84,16 @@ def is_admin; end
                     sig { params(is_admin: T::Boolean).returns(T::Boolean) }
                     def is_admin=(is_admin); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def name; end
 
-                    sig { params(name: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(name: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def name=(name); end
 
-                    sig { returns(T.nilable(T::Array[Post])) }
+                    sig { returns(::T.nilable(T::Array[::Post])) }
                     def posts; end
 
-                    sig { params(posts: T.nilable(T::Array[Post])).returns(T.nilable(T::Array[Post])) }
+                    sig { params(posts: ::T.nilable(T::Array[::Post])).returns(::T.nilable(T::Array[::Post])) }
                     def posts=(posts); end
                   end
                 end
@@ -106,16 +106,16 @@ class Post
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def user_id; end
 
-                    sig { params(user_id: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(user_id: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def user_id=(user_id); end
                   end
                 end
@@ -150,16 +150,16 @@ class Post
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def name; end
 
-                    sig { params(name: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(name: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def name=(name); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -206,10 +206,10 @@ class Image
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def user_id; end
 
-                    sig { params(user_id: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(user_id: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def user_id=(user_id); end
                   end
                 end
@@ -222,16 +222,16 @@ class User
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.nilable(Image)) }
+                    sig { returns(::T.nilable(::Image)) }
                     def image; end
 
-                    sig { params(image: T.nilable(Image)).returns(T.nilable(Image)) }
+                    sig { params(image: ::T.nilable(::Image)).returns(::T.nilable(::Image)) }
                     def image=(image); end
 
-                    sig { returns(T.nilable(T::Array[Post])) }
+                    sig { returns(::T.nilable(T::Array[::Post])) }
                     def posts; end
 
-                    sig { params(posts: T.nilable(T::Array[Post])).returns(T.nilable(T::Array[Post])) }
+                    sig { params(posts: ::T.nilable(T::Array[::Post])).returns(::T.nilable(T::Array[::Post])) }
                     def posts=(posts); end
                   end
                 end
@@ -244,10 +244,10 @@ class Post
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def user_id; end
 
-                    sig { params(user_id: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(user_id: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def user_id=(user_id); end
                   end
                 end
@@ -269,16 +269,16 @@ class Post
                   include JsonApiClientResourceGeneratedMethods
 
                   module JsonApiClientResourceGeneratedMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def name; end
 
-                    sig { params(name: T.untyped).returns(T.untyped) }
+                    sig { params(name: ::T.untyped).returns(::T.untyped) }
                     def name=(name); end
 
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def title; end
 
-                    sig { params(title: T.untyped).returns(T.untyped) }
+                    sig { params(title: ::T.untyped).returns(::T.untyped) }
                     def title=(title); end
                   end
                 end
@@ -318,10 +318,10 @@ class Post
                     include JsonApiClientResourceGeneratedMethods
 
                     module JsonApiClientResourceGeneratedMethods
-                      sig { returns(T.untyped) }
+                      sig { returns(::T.untyped) }
                       def name; end
 
-                      sig { params(name: T.untyped).returns(T.untyped) }
+                      sig { params(name: ::T.untyped).returns(::T.untyped) }
                       def name=(name); end
                     end
                   end
@@ -351,10 +351,10 @@ class Post
                     include JsonApiClientResourceGeneratedMethods
 
                     module JsonApiClientResourceGeneratedMethods
-                      sig { returns(T.nilable(Integer)) }
+                      sig { returns(::T.nilable(Integer)) }
                       def comment_count; end
 
-                      sig { params(comment_count: T.nilable(Integer)).returns(T.nilable(Integer)) }
+                      sig { params(comment_count: ::T.nilable(Integer)).returns(::T.nilable(Integer)) }
                       def comment_count=(comment_count); end
 
                       sig { returns(Integer) }
@@ -390,10 +390,10 @@ class Post
                     include JsonApiClientResourceGeneratedMethods
 
                     module JsonApiClientResourceGeneratedMethods
-                      sig { returns(T.nilable(Integer)) }
+                      sig { returns(::T.nilable(Integer)) }
                       def comment_count; end
 
-                      sig { params(comment_count: T.nilable(Integer)).returns(T.nilable(Integer)) }
+                      sig { params(comment_count: ::T.nilable(Integer)).returns(::T.nilable(Integer)) }
                       def comment_count=(comment_count); end
 
                       sig { returns(Integer) }
diff --git a/spec/tapioca/dsl/compilers/protobuf_spec.rb b/spec/tapioca/dsl/compilers/protobuf_spec.rb
index 04b6753ca..91b87e4de 100644
--- a/spec/tapioca/dsl/compilers/protobuf_spec.rb
+++ b/spec/tapioca/dsl/compilers/protobuf_spec.rb
@@ -52,13 +52,13 @@ def before_setup
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(customer_id: T.nilable(Integer), shop_id: T.nilable(Integer)).void }
+                  sig { params(customer_id: ::T.nilable(::Integer), shop_id: ::T.nilable(::Integer)).void }
                   def initialize(customer_id: nil, shop_id: nil); end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _customer_id; end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _shop_id; end
 
                   sig { void }
@@ -67,22 +67,22 @@ def clear_customer_id; end
                   sig { void }
                   def clear_shop_id; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def customer_id; end
 
-                  sig { params(value: Integer).void }
+                  sig { params(value: ::Integer).void }
                   def customer_id=(value); end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_customer_id?; end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_shop_id?; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def shop_id; end
 
-                  sig { params(value: Integer).void }
+                  sig { params(value: ::Integer).void }
                   def shop_id=(value); end
                 end
               RBI
@@ -103,22 +103,22 @@ def shop_id=(value); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(events: T.nilable(String)).void }
+                  sig { params(events: ::T.nilable(::String)).void }
                   def initialize(events: nil); end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _events; end
 
                   sig { void }
                   def clear_events; end
 
-                  sig { returns(String) }
+                  sig { returns(::String) }
                   def events; end
 
-                  sig { params(value: String).void }
+                  sig { params(value: ::String).void }
                   def events=(value); end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_events?; end
                 end
               RBI
@@ -140,22 +140,22 @@ def has_events?; end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(cart_item_index: T.nilable(Google::Protobuf::UInt64Value)).void }
+                  sig { params(cart_item_index: ::T.nilable(::Google::Protobuf::UInt64Value)).void }
                   def initialize(cart_item_index: nil); end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _cart_item_index; end
 
-                  sig { returns(T.nilable(Google::Protobuf::UInt64Value)) }
+                  sig { returns(::T.nilable(::Google::Protobuf::UInt64Value)) }
                   def cart_item_index; end
 
-                  sig { params(value: T.nilable(Google::Protobuf::UInt64Value)).void }
+                  sig { params(value: ::T.nilable(::Google::Protobuf::UInt64Value)).void }
                   def cart_item_index=(value); end
 
                   sig { void }
                   def clear_cart_item_index; end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_cart_item_index?; end
                 end
               RBI
@@ -182,22 +182,22 @@ def has_cart_item_index?; end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(value_type: T.nilable(T.any(Symbol, Integer))).void }
+                  sig { params(value_type: ::T.nilable(::T.any(::Symbol, ::Integer))).void }
                   def initialize(value_type: nil); end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _value_type; end
 
                   sig { void }
                   def clear_value_type; end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_value_type?; end
 
-                  sig { returns(T.any(Symbol, Integer)) }
+                  sig { returns(::T.any(::Symbol, ::Integer)) }
                   def value_type; end
 
-                  sig { params(value: T.any(Symbol, Integer)).void }
+                  sig { params(value: ::T.any(::Symbol, ::Integer)).void }
                   def value_type=(value); end
                 end
               RBI
@@ -207,13 +207,13 @@ def value_type=(value); end
 
                 module Cart::VALUE_TYPE
                   class << self
-                    sig { returns(Google::Protobuf::EnumDescriptor) }
+                    sig { returns(::Google::Protobuf::EnumDescriptor) }
                     def descriptor; end
 
-                    sig { params(number: Integer).returns(T.nilable(Symbol)) }
+                    sig { params(number: ::Integer).returns(::T.nilable(::Symbol)) }
                     def lookup(number); end
 
-                    sig { params(symbol: Symbol).returns(T.nilable(Integer)) }
+                    sig { params(symbol: ::Symbol).returns(::T.nilable(::Integer)) }
                     def resolve(symbol); end
                   end
                 end
@@ -242,7 +242,7 @@ def resolve(symbol); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(customer_ids: T.nilable(T::Array[Integer]), indices: T.nilable(T::Array[Google::Protobuf::UInt64Value])).void }
+                  sig { params(customer_ids: ::T.nilable(::T.any(Google::Protobuf::RepeatedField[::Integer], Array[::Integer])), indices: ::T.nilable(::T.any(Google::Protobuf::RepeatedField[::Google::Protobuf::UInt64Value], Array[::Google::Protobuf::UInt64Value]))).void }
                   def initialize(customer_ids: T.unsafe(nil), indices: T.unsafe(nil)); end
 
                   sig { void }
@@ -251,16 +251,16 @@ def clear_customer_ids; end
                   sig { void }
                   def clear_indices; end
 
-                  sig { returns(Google::Protobuf::RepeatedField[Integer]) }
+                  sig { returns(Google::Protobuf::RepeatedField[::Integer]) }
                   def customer_ids; end
 
-                  sig { params(value: Google::Protobuf::RepeatedField[Integer]).void }
+                  sig { params(value: Google::Protobuf::RepeatedField[::Integer]).void }
                   def customer_ids=(value); end
 
-                  sig { returns(Google::Protobuf::RepeatedField[Google::Protobuf::UInt64Value]) }
+                  sig { returns(Google::Protobuf::RepeatedField[::Google::Protobuf::UInt64Value]) }
                   def indices; end
 
-                  sig { params(value: Google::Protobuf::RepeatedField[Google::Protobuf::UInt64Value]).void }
+                  sig { params(value: Google::Protobuf::RepeatedField[::Google::Protobuf::UInt64Value]).void }
                   def indices=(value); end
                 end
               RBI
@@ -281,16 +281,16 @@ def indices=(value); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(shop_id: T.nilable(Integer)).void }
+                  sig { params(shop_id: ::T.nilable(::Integer)).void }
                   def initialize(shop_id: nil); end
 
                   sig { void }
                   def clear_shop_id; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def shop_id; end
 
-                  sig { params(value: Integer).void }
+                  sig { params(value: ::Integer).void }
                   def shop_id=(value); end
                 end
               RBI
@@ -313,7 +313,7 @@ def shop_id=(value); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(customers: T.nilable(T.any(Google::Protobuf::Map[String, Integer], T::Hash[String, Integer])), stores: T.nilable(T.any(Google::Protobuf::Map[String, Google::Protobuf::UInt64Value], T::Hash[String, Google::Protobuf::UInt64Value]))).void }
+                  sig { params(customers: ::T.nilable(::T.any(Google::Protobuf::Map[::String, ::Integer], Hash[::String, ::Integer])), stores: ::T.nilable(::T.any(Google::Protobuf::Map[::String, ::Google::Protobuf::UInt64Value], Hash[::String, ::Google::Protobuf::UInt64Value]))).void }
                   def initialize(customers: T.unsafe(nil), stores: T.unsafe(nil)); end
 
                   sig { void }
@@ -322,16 +322,16 @@ def clear_customers; end
                   sig { void }
                   def clear_stores; end
 
-                  sig { returns(Google::Protobuf::Map[String, Integer]) }
+                  sig { returns(Google::Protobuf::Map[::String, ::Integer]) }
                   def customers; end
 
-                  sig { params(value: Google::Protobuf::Map[String, Integer]).void }
+                  sig { params(value: Google::Protobuf::Map[::String, ::Integer]).void }
                   def customers=(value); end
 
-                  sig { returns(Google::Protobuf::Map[String, Google::Protobuf::UInt64Value]) }
+                  sig { returns(Google::Protobuf::Map[::String, ::Google::Protobuf::UInt64Value]) }
                   def stores; end
 
-                  sig { params(value: Google::Protobuf::Map[String, Google::Protobuf::UInt64Value]).void }
+                  sig { params(value: Google::Protobuf::Map[::String, ::Google::Protobuf::UInt64Value]).void }
                   def stores=(value); end
                 end
               RBI
@@ -365,42 +365,42 @@ def bool_value=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: String).void }
+                sig { params(value: ::String).void }
                 def byte_value=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Integer).void }
+                sig { params(value: ::Integer).void }
                 def customer_id=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Integer).void }
+                sig { params(value: ::Integer).void }
                 def id=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Integer).void }
+                sig { params(value: ::Integer).void }
                 def item_id=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Float).void }
+                sig { params(value: ::Float).void }
                 def money_value=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Float).void }
+                sig { params(value: ::Float).void }
                 def number_value=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: Integer).void }
+                sig { params(value: ::Integer).void }
                 def shop_id=(value); end
               RBI
 
               assert_includes(rbi_output, indented(<<~RBI, 2))
-                sig { params(value: String).void }
+                sig { params(value: ::String).void }
                 def string_value=(value); end
               RBI
             end
@@ -419,25 +419,25 @@ def string_value=(value); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(fields: T.untyped).void }
+                  sig { params(fields: ::T.untyped).void }
                   def initialize(**fields); end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def ShopID; end
 
-                  sig { params(value: Integer).void }
+                  sig { params(value: ::Integer).void }
                   def ShopID=(value); end
 
-                  sig { returns(String) }
+                  sig { returns(::String) }
                   def ShopName; end
 
-                  sig { params(value: String).void }
+                  sig { params(value: ::String).void }
                   def ShopName=(value); end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _ShopID; end
 
-                  sig { returns(T.nilable(Symbol)) }
+                  sig { returns(::T.nilable(::Symbol)) }
                   def _ShopName; end
 
                   sig { void }
@@ -446,10 +446,10 @@ def clear_ShopID; end
                   sig { void }
                   def clear_ShopName; end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_ShopID?; end
 
-                  sig { returns(Object) }
+                  sig { returns(::Object) }
                   def has_ShopName?; end
                 end
               RBI
@@ -479,7 +479,7 @@ def clear_email; end
                 sig { void }
                 def clear_phone_number; end
 
-                sig { returns(T.nilable(Symbol)) }
+                sig { returns(::T.nilable(::Symbol)) }
                 def contact_info; end
               RBI
             end
@@ -510,16 +510,16 @@ class Cart; end
                 # typed: strong
 
                 class Google::Protobuf::Struct < Google::Protobuf::AbstractMessage
-                  sig { params(fields: T.nilable(T.any(Google::Protobuf::Map[String, Google::Protobuf::Value], T::Hash[String, Google::Protobuf::Value]))).void }
+                  sig { params(fields: ::T.nilable(::T.any(Google::Protobuf::Map[::String, ::Google::Protobuf::Value], Hash[::String, ::Google::Protobuf::Value]))).void }
                   def initialize(fields: T.unsafe(nil)); end
 
                   sig { void }
                   def clear_fields; end
 
-                  sig { returns(Google::Protobuf::Map[String, Google::Protobuf::Value]) }
+                  sig { returns(Google::Protobuf::Map[::String, ::Google::Protobuf::Value]) }
                   def fields; end
 
-                  sig { params(value: Google::Protobuf::Map[String, Google::Protobuf::Value]).void }
+                  sig { params(value: Google::Protobuf::Map[::String, ::Google::Protobuf::Value]).void }
                   def fields=(value); end
                 end
               RBI
@@ -569,16 +569,16 @@ def fields=(value); end
                 # typed: strong
 
                 class Cart < Google::Protobuf::AbstractMessage
-                  sig { params(progress: T.nilable(T.any(Google::Protobuf::Map[String, Cart::Progress], T::Hash[String, Cart::Progress]))).void }
+                  sig { params(progress: ::T.nilable(::T.any(Google::Protobuf::Map[::String, ::Cart::Progress], Hash[::String, ::Cart::Progress]))).void }
                   def initialize(progress: T.unsafe(nil)); end
 
                   sig { void }
                   def clear_progress; end
 
-                  sig { returns(Google::Protobuf::Map[String, Cart::Progress]) }
+                  sig { returns(Google::Protobuf::Map[::String, ::Cart::Progress]) }
                   def progress; end
 
-                  sig { params(value: Google::Protobuf::Map[String, Cart::Progress]).void }
+                  sig { params(value: Google::Protobuf::Map[::String, ::Cart::Progress]).void }
                   def progress=(value); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/compilers/rails_generators_spec.rb b/spec/tapioca/dsl/compilers/rails_generators_spec.rb
index 7719a32b4..6e12b6e3c 100644
--- a/spec/tapioca/dsl/compilers/rails_generators_spec.rb
+++ b/spec/tapioca/dsl/compilers/rails_generators_spec.rb
@@ -119,19 +119,19 @@ class OptionGenerator < ::Rails::Generators::Base
                 # typed: strong
 
                 class OptionGenerator
-                  sig { returns(T.nilable(T::Array[::String])) }
+                  sig { returns(::T.nilable(T::Array[::String])) }
                   def array; end
 
-                  sig { returns(T.nilable(T::Boolean)) }
+                  sig { returns(::T.nilable(T::Boolean)) }
                   def bool; end
 
-                  sig { returns(T.nilable(T::Hash[::String, ::String])) }
+                  sig { returns(::T.nilable(T::Hash[::String, ::String])) }
                   def hash; end
 
-                  sig { returns(T.nilable(::Numeric)) }
+                  sig { returns(::T.nilable(::Numeric)) }
                   def numeric; end
 
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def string; end
                 end
               RBI
@@ -173,7 +173,7 @@ class OverrideGenerator < ::Rails::Generators::Base
                 # typed: strong
 
                 class OverrideGenerator
-                  sig { returns(T.nilable(::Numeric)) }
+                  sig { returns(::T.nilable(::Numeric)) }
                   def force; end
                 end
               RBI
@@ -201,10 +201,10 @@ class ChildGenerator
                   sig { returns(::String) }
                   def child_arg; end
 
-                  sig { returns(T.nilable(::String)) }
+                  sig { returns(::T.nilable(::String)) }
                   def child_opt; end
 
-                  sig { returns(T.nilable(::Numeric)) }
+                  sig { returns(::T.nilable(::Numeric)) }
                   def number; end
 
                   sig { returns(::String) }
diff --git a/spec/tapioca/dsl/compilers/sidekiq_worker_spec.rb b/spec/tapioca/dsl/compilers/sidekiq_worker_spec.rb
index fecdca196..e809d1906 100644
--- a/spec/tapioca/dsl/compilers/sidekiq_worker_spec.rb
+++ b/spec/tapioca/dsl/compilers/sidekiq_worker_spec.rb
@@ -77,13 +77,13 @@ def perform(customer_id)
 
                 class NotifierWorker
                   class << self
-                    sig { params(customer_id: T.untyped).returns(String) }
+                    sig { params(customer_id: ::T.untyped).returns(::String) }
                     def perform_async(customer_id); end
 
-                    sig { params(interval: T.any(DateTime, Time), customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::T.any(::DateTime, ::Time), customer_id: ::T.untyped).returns(::String) }
                     def perform_at(interval, customer_id); end
 
-                    sig { params(interval: Numeric, customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::Numeric, customer_id: ::T.untyped).returns(::String) }
                     def perform_in(interval, customer_id); end
                   end
                 end
@@ -110,13 +110,13 @@ def perform(customer_id)
 
                 class NotifierWorker
                   class << self
-                    sig { params(customer_id: T.untyped).returns(String) }
+                    sig { params(customer_id: ::T.untyped).returns(::String) }
                     def perform_async(customer_id); end
 
-                    sig { params(interval: T.any(DateTime, Time, ActiveSupport::TimeWithZone), customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::T.any(::DateTime, ::Time, ::ActiveSupport::TimeWithZone), customer_id: ::T.untyped).returns(::String) }
                     def perform_at(interval, customer_id); end
 
-                    sig { params(interval: T.any(Numeric, ActiveSupport::Duration), customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::T.any(::Numeric, ::ActiveSupport::Duration), customer_id: ::T.untyped).returns(::String) }
                     def perform_in(interval, customer_id); end
                   end
                 end
@@ -142,13 +142,13 @@ def perform(customer_id)
 
                 class NotifierWorker
                   class << self
-                    sig { params(customer_id: ::Integer).returns(String) }
+                    sig { params(customer_id: ::Integer).returns(::String) }
                     def perform_async(customer_id); end
 
-                    sig { params(interval: T.any(DateTime, Time), customer_id: ::Integer).returns(String) }
+                    sig { params(interval: ::T.any(::DateTime, ::Time), customer_id: ::Integer).returns(::String) }
                     def perform_at(interval, customer_id); end
 
-                    sig { params(interval: Numeric, customer_id: ::Integer).returns(String) }
+                    sig { params(interval: ::Numeric, customer_id: ::Integer).returns(::String) }
                     def perform_in(interval, customer_id); end
                   end
                 end
@@ -175,13 +175,13 @@ class SecondaryWorker < NotifierWorker
 
                 class SecondaryWorker
                   class << self
-                    sig { params(customer_id: T.untyped).returns(String) }
+                    sig { params(customer_id: ::T.untyped).returns(::String) }
                     def perform_async(customer_id); end
 
-                    sig { params(interval: T.any(DateTime, Time), customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::T.any(::DateTime, ::Time), customer_id: ::T.untyped).returns(::String) }
                     def perform_at(interval, customer_id); end
 
-                    sig { params(interval: Numeric, customer_id: T.untyped).returns(String) }
+                    sig { params(interval: ::Numeric, customer_id: ::T.untyped).returns(::String) }
                     def perform_in(interval, customer_id); end
                   end
                 end
@@ -213,10 +213,10 @@ def self.perform_at(interval, other_id)
 
                 class SecondaryWorker
                   class << self
-                    sig { params(customer_id: T.untyped, other_id: T.untyped).returns(String) }
+                    sig { params(customer_id: ::T.untyped, other_id: ::T.untyped).returns(::String) }
                     def perform_async(customer_id, other_id); end
 
-                    sig { params(interval: Numeric, customer_id: T.untyped, other_id: T.untyped).returns(String) }
+                    sig { params(interval: ::Numeric, customer_id: ::T.untyped, other_id: ::T.untyped).returns(::String) }
                     def perform_in(interval, customer_id, other_id); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/smart_properties_spec.rb b/spec/tapioca/dsl/compilers/smart_properties_spec.rb
index a9a80742b..321bbc712 100644
--- a/spec/tapioca/dsl/compilers/smart_properties_spec.rb
+++ b/spec/tapioca/dsl/compilers/smart_properties_spec.rb
@@ -87,10 +87,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -114,10 +114,10 @@ module Viewable
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -168,10 +168,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def title; end
 
-                    sig { params(title: T.untyped).returns(T.untyped) }
+                    sig { params(title: ::T.untyped).returns(::T.untyped) }
                     def title=(title); end
                   end
                 end
@@ -195,10 +195,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(T::Array[T.untyped])) }
+                    sig { returns(::T.nilable(T::Array[::T.untyped])) }
                     def categories; end
 
-                    sig { params(categories: T.nilable(T::Array[T.untyped])).returns(T.nilable(T::Array[T.untyped])) }
+                    sig { params(categories: ::T.nilable(T::Array[::T.untyped])).returns(::T.nilable(T::Array[::T.untyped])) }
                     def categories=(categories); end
                   end
                 end
@@ -222,10 +222,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(T::Boolean)) }
+                    sig { returns(::T.nilable(T::Boolean)) }
                     def published; end
 
-                    sig { params(published: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+                    sig { params(published: ::T.nilable(T::Boolean)).returns(::T.nilable(T::Boolean)) }
                     def published=(published); end
                   end
                 end
@@ -249,10 +249,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(T.any(::String, ::Integer))) }
+                    sig { returns(::T.nilable(::T.any(::String, ::Integer))) }
                     def status; end
 
-                    sig { params(status: T.nilable(T.any(::String, ::Integer))).returns(T.nilable(T.any(::String, ::Integer))) }
+                    sig { params(status: ::T.nilable(::T.any(::String, ::Integer))).returns(::T.nilable(::T.any(::String, ::Integer))) }
                     def status=(status); end
                   end
                 end
@@ -276,10 +276,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def status; end
 
-                    sig { params(status: T.untyped).returns(T.untyped) }
+                    sig { params(status: ::T.untyped).returns(::T.untyped) }
                     def status=(status); end
                   end
                 end
@@ -303,10 +303,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def status; end
 
-                    sig { params(status: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                    sig { params(status: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                     def status=(status); end
                   end
                 end
@@ -330,10 +330,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def status; end
 
-                    sig { params(status: T.untyped).returns(T.untyped) }
+                    sig { params(status: ::T.untyped).returns(::T.untyped) }
                     def status=(status); end
                   end
                 end
@@ -357,10 +357,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::Integer)) }
+                    sig { returns(::T.nilable(::Integer)) }
                     def reader_for_status; end
 
-                    sig { params(status: T.nilable(::Integer)).returns(T.nilable(::Integer)) }
+                    sig { params(status: ::T.nilable(::Integer)).returns(::T.nilable(::Integer)) }
                     def status=(status); end
                   end
                 end
@@ -384,10 +384,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(T::Boolean)) }
+                    sig { returns(::T.nilable(T::Boolean)) }
                     def enabled; end
 
-                    sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+                    sig { params(enabled: ::T.nilable(T::Boolean)).returns(::T.nilable(T::Boolean)) }
                     def enabled=(enabled); end
                   end
                 end
@@ -411,10 +411,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(T::Boolean)) }
+                    sig { returns(::T.nilable(T::Boolean)) }
                     def enabled; end
 
-                    sig { params(enabled: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+                    sig { params(enabled: ::T.nilable(T::Boolean)).returns(::T.nilable(T::Boolean)) }
                     def enabled=(enabled); end
                   end
                 end
@@ -438,10 +438,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -465,10 +465,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -492,10 +492,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.untyped) }
+                    sig { returns(::T.untyped) }
                     def title; end
 
-                    sig { params(title: T.untyped).returns(T.untyped) }
+                    sig { params(title: ::T.untyped).returns(::T.untyped) }
                     def title=(title); end
                   end
                 end
@@ -533,16 +533,16 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def body; end
 
-                    sig { params(body: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(body: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def body=(body); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(title: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def title=(title); end
                   end
                 end
@@ -575,10 +575,10 @@ class Post
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::Post::TrackingInfoInput)) }
+                    sig { returns(::T.nilable(::Post::TrackingInfoInput)) }
                     def title; end
 
-                    sig { params(title: T.nilable(::Post::TrackingInfoInput)).returns(T.nilable(::Post::TrackingInfoInput)) }
+                    sig { params(title: ::T.nilable(::Post::TrackingInfoInput)).returns(::T.nilable(::Post::TrackingInfoInput)) }
                     def title=(title); end
                   end
                 end
@@ -593,10 +593,10 @@ class Post::TrackingInfoInput
                   include SmartPropertiesGeneratedMethods
 
                   module SmartPropertiesGeneratedMethods
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def carrier_id; end
 
-                    sig { params(carrier_id: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(carrier_id: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def carrier_id=(carrier_id); end
 
                     sig { returns(::String) }
@@ -605,10 +605,10 @@ def number; end
                     sig { params(number: ::String).returns(::String) }
                     def number=(number); end
 
-                    sig { returns(T.nilable(::String)) }
+                    sig { returns(::T.nilable(::String)) }
                     def url; end
 
-                    sig { params(url: T.nilable(::String)).returns(T.nilable(::String)) }
+                    sig { params(url: ::T.nilable(::String)).returns(::T.nilable(::String)) }
                     def url=(url); end
                   end
                 end
diff --git a/spec/tapioca/dsl/compilers/state_machines_spec.rb b/spec/tapioca/dsl/compilers/state_machines_spec.rb
index 9fc10e451..b153f4220 100644
--- a/spec/tapioca/dsl/compilers/state_machines_spec.rb
+++ b/spec/tapioca/dsl/compilers/state_machines_spec.rb
@@ -63,10 +63,10 @@ class Vehicle
                   extend StateMachineClassHelperModule
 
                   module StateMachineClassHelperModule
-                    sig { params(event: T.any(String, Symbol)).returns(String) }
+                    sig { params(event: ::T.any(::String, ::Symbol)).returns(::String) }
                     def human_alarm_state_event_name(event); end
 
-                    sig { params(state: T.any(String, Symbol)).returns(String) }
+                    sig { params(state: ::T.any(::String, ::Symbol)).returns(::String) }
                     def human_alarm_state_name(state); end
                   end
 
@@ -77,25 +77,25 @@ def alarm_active?; end
                     sig { returns(T::Boolean) }
                     def alarm_off?; end
 
-                    sig { returns(Integer) }
+                    sig { returns(::Integer) }
                     def alarm_state; end
 
-                    sig { params(value: Integer).returns(Integer) }
+                    sig { params(value: ::Integer).returns(::Integer) }
                     def alarm_state=(value); end
 
-                    sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
+                    sig { params(state: ::T.any(::String, ::Symbol)).returns(T::Boolean) }
                     def alarm_state?(state); end
 
-                    sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
+                    sig { params(args: ::T.untyped).returns(T::Array[::T.any(::String, ::Symbol)]) }
                     def alarm_state_events(*args); end
 
-                    sig { returns(T.any(String, Symbol)) }
+                    sig { returns(::T.any(::String, ::Symbol)) }
                     def alarm_state_name; end
 
-                    sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+                    sig { params(args: ::T.untyped).returns(T::Array[::StateMachines::Transition]) }
                     def alarm_state_paths(*args); end
 
-                    sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+                    sig { params(args: ::T.untyped).returns(T::Array[::StateMachines::Transition]) }
                     def alarm_state_transitions(*args); end
 
                     sig { returns(T::Boolean) }
@@ -104,28 +104,28 @@ def can_disable_alarm?; end
                     sig { returns(T::Boolean) }
                     def can_enable_alarm?; end
 
-                    sig { params(args: T.untyped).returns(T::Boolean) }
+                    sig { params(args: ::T.untyped).returns(T::Boolean) }
                     def disable_alarm(*args); end
 
-                    sig { params(args: T.untyped).returns(T::Boolean) }
+                    sig { params(args: ::T.untyped).returns(T::Boolean) }
                     def disable_alarm!(*args); end
 
-                    sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+                    sig { params(args: ::T.untyped).returns(::T.nilable(::StateMachines::Transition)) }
                     def disable_alarm_transition(*args); end
 
-                    sig { params(args: T.untyped).returns(T::Boolean) }
+                    sig { params(args: ::T.untyped).returns(T::Boolean) }
                     def enable_alarm(*args); end
 
-                    sig { params(args: T.untyped).returns(T::Boolean) }
+                    sig { params(args: ::T.untyped).returns(T::Boolean) }
                     def enable_alarm!(*args); end
 
-                    sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
+                    sig { params(args: ::T.untyped).returns(::T.nilable(::StateMachines::Transition)) }
                     def enable_alarm_transition(*args); end
 
-                    sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
+                    sig { params(event: ::T.any(::String, ::Symbol), args: ::T.untyped).returns(T::Boolean) }
                     def fire_alarm_state_event(event, *args); end
 
-                    sig { returns(String) }
+                    sig { returns(::String) }
                     def human_alarm_state_name; end
                   end
                 end
@@ -155,10 +155,10 @@ class Vehicle
                   extend StateMachineClassHelperModule
 
                   module StateMachineClassHelperModule
-                    sig { params(event: T.any(String, Symbol)).returns(String) }
+                    sig { params(event: ::T.any(::String, ::Symbol)).returns(::String) }
                     def human_alarm_state_event_name(event); end
 
-                    sig { params(state: T.any(String, Symbol)).returns(String) }
+                    sig { params(state: ::T.any(::String, ::Symbol)).returns(::String) }
                     def human_alarm_state_name(state); end
                   end
               RBI
@@ -184,31 +184,31 @@ def alarm_active?; end
                   sig { returns(T::Boolean) }
                   def alarm_off?; end
 
-                  sig { returns(Integer) }
+                  sig { returns(::Integer) }
                   def alarm_state; end
 
-                  sig { params(value: Integer).returns(Integer) }
+                  sig { params(value: ::Integer).returns(::Integer) }
                   def alarm_state=(value); end
 
-                  sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
+                  sig { params(state: ::T.any(::String, ::Symbol)).returns(T::Boolean) }
                   def alarm_state?(state); end
 
-                  sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
+                  sig { params(args: ::T.untyped).returns(T::Array[::T.any(::String, ::Symbol)]) }
                   def alarm_state_events(*args); end
 
-                  sig { returns(T.any(String, Symbol)) }
+                  sig { returns(::T.any(::String, ::Symbol)) }
                   def alarm_state_name; end
 
-                  sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+                  sig { params(args: ::T.untyped).returns(T::Array[::StateMachines::Transition]) }
                   def alarm_state_paths(*args); end
 
-                  sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+                  sig { params(args: ::T.untyped).returns(T::Array[::StateMachines::Transition]) }
                   def alarm_state_transitions(*args); end
 
-                  sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
+                  sig { params(event: ::T.any(::String, ::Symbol), args: ::T.untyped).returns(T::Boolean) }
                   def fire_alarm_state_event(event, *args); end
 
-                  sig { returns(String) }
+                  sig { returns(::String) }
                   def human_alarm_state_name; end
                 end
               RBI
@@ -228,7 +228,7 @@ class Vehicle
               RUBY
 
               expected = indented(<<~RBI, 4)
-                sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
+                sig { params(args: ::T.untyped).returns(T::Array[::StateMachines::Transition]) }
                 def state_paths(*args); end
               RBI
 
@@ -261,16 +261,16 @@ class Vehicle
               RUBY
 
               expected = indented(<<~RBI, 4)
-                sig { params(states: T.any(String, Symbol)).returns(T.untyped) }
+                sig { params(states: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                 def with_state(*states); end
 
-                sig { params(states: T.any(String, Symbol)).returns(T.untyped) }
+                sig { params(states: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                 def with_states(*states); end
 
-                sig { params(states: T.any(String, Symbol)).returns(T.untyped) }
+                sig { params(states: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                 def without_state(*states); end
 
-                sig { params(states: T.any(String, Symbol)).returns(T.untyped) }
+                sig { params(states: ::T.any(::String, ::Symbol)).returns(::T.untyped) }
                 def without_states(*states); end
               RBI
 
@@ -297,13 +297,13 @@ class Vehicle
               RUBY
 
               expected = indented(<<~RBI, 4)
-                sig { returns(T.nilable(Symbol)) }
+                sig { returns(::T.nilable(::Symbol)) }
                 def state_event; end
 
-                sig { params(value: T.any(String, Symbol)).returns(T.any(String, Symbol)) }
+                sig { params(value: ::T.any(::String, ::Symbol)).returns(::T.any(::String, ::Symbol)) }
                 def state_event=(value); end
 
-                sig { returns(T.nilable(::StateMachines::Transition)) }
+                sig { returns(::T.nilable(::StateMachines::Transition)) }
                 def state_event_transition; end
 
                 sig { params(value: ::StateMachines::Transition).returns(::StateMachines::Transition) }
diff --git a/spec/tapioca/dsl/compilers/url_helpers_spec.rb b/spec/tapioca/dsl/compilers/url_helpers_spec.rb
index c060e4029..4ac85f1ec 100644
--- a/spec/tapioca/dsl/compilers/url_helpers_spec.rb
+++ b/spec/tapioca/dsl/compilers/url_helpers_spec.rb
@@ -247,13 +247,13 @@ module GeneratedPathHelpersModule
                   include ::ActionDispatch::Routing::UrlFor
                   include ::ActionDispatch::Routing::PolymorphicRoutes
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def edit_index_path(*args); end
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def index_path(*args); end
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def new_index_path(*args); end
                 end
               RBI
@@ -277,13 +277,13 @@ module GeneratedUrlHelpersModule
                   include ::ActionDispatch::Routing::UrlFor
                   include ::ActionDispatch::Routing::PolymorphicRoutes
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def edit_index_url(*args); end
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def index_url(*args); end
 
-                  sig { params(args: T.untyped).returns(String) }
+                  sig { params(args: ::T.untyped).returns(::String) }
                   def new_index_url(*args); end
                 end
               RBI
diff --git a/spec/tapioca/dsl/helpers/graphql_type_helper_spec.rb b/spec/tapioca/dsl/helpers/graphql_type_helper_spec.rb
index c8b19583e..584381eca 100644
--- a/spec/tapioca/dsl/helpers/graphql_type_helper_spec.rb
+++ b/spec/tapioca/dsl/helpers/graphql_type_helper_spec.rb
@@ -16,180 +16,180 @@ def before_setup
         it "generates the expected sorbet type expression when using type GraphQL::Types::Boolean" do
           type = GraphQL::Types::Boolean
           assert_equal(
-            "T.nilable(T::Boolean)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(T::Boolean)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Boolean)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(T::Boolean)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[T::Boolean])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[T::Boolean])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "T::Boolean",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::String" do
           type = GraphQL::Types::String
           assert_equal(
-            "T.nilable(::String)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::String)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::String)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::String)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::String])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::String])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::String",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::Float" do
           type = GraphQL::Types::Float
           assert_equal(
-            "T.nilable(::Float)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::Float)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::Float)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::Float)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::Float])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::Float])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::Float",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::ID" do
           type = GraphQL::Types::ID
           assert_equal(
-            "T.nilable(::String)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::String)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::String)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::String)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::String])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::String])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::String",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::Int" do
           type = GraphQL::Types::Int
           assert_equal(
-            "T.nilable(::Integer)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::Integer)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::Integer)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::Integer)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::Integer])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::Integer])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::Integer",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::BigInt" do
           type = GraphQL::Types::BigInt
           assert_equal(
-            "T.nilable(::Integer)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::Integer)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::Integer)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::Integer)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::Integer])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::Integer])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::Integer",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::ISO8601Date" do
           type = GraphQL::Types::ISO8601Date
           assert_equal(
-            "T.nilable(::Date)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::Date)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::Date)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::Date)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::Date])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::Date])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::Date",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::ISO8601DateTime" do
           type = GraphQL::Types::ISO8601DateTime
           assert_equal(
-            "T.nilable(::Time)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(::Time)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(::Time)",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(::Time)",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[::Time])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[::Time])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
             "::Time",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
 
         it "generates the expected sorbet type expression when using type GraphQL::Types::JSON" do
           type = GraphQL::Types::JSON
           assert_equal(
-            "T.nilable(T::Hash[::String, T.untyped])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type),
+            "::T.nilable(T::Hash[::String, ::T.untyped])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(type).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Hash[::String, T.untyped])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)),
+            "::T.nilable(T::Hash[::String, ::T.untyped])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::Wrapper.new(type)).to_rbi,
           )
           assert_equal(
-            "T.nilable(T::Array[T::Hash[::String, T.untyped]])",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)),
+            "::T.nilable(T::Array[T::Hash[::String, ::T.untyped]])",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::List.new(type)).to_rbi,
           )
           assert_equal(
-            "T::Hash[::String, T.untyped]",
-            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)),
+            "T::Hash[::String, ::T.untyped]",
+            Tapioca::Dsl::Helpers::GraphqlTypeHelper.type_for(GraphQL::Schema::NonNull.new(type)).to_rbi,
           )
         end
       end
diff --git a/spec/tapioca/rbi_builder_spec.rb b/spec/tapioca/rbi_builder_spec.rb
index 761e6725f..a5406d649 100644
--- a/spec/tapioca/rbi_builder_spec.rb
+++ b/spec/tapioca/rbi_builder_spec.rb
@@ -15,7 +15,7 @@ class BuilderSpec < Minitest::HooksSpec
         rbi.create_extend("E")
         rbi.create_mixes_in_class_methods("F")
         rbi.create_type_variable("G", type: "type_member")
-        rbi.create_type_variable("H", type: "type_template", variance: :in, fixed: "Foo")
+        rbi.create_type_variable("H", type: "type_template", variance: :in, fixed: RBI::Type.simple("Foo"))
         rbi.create_method("foo")
 
         assert_equal(<<~RBI, rbi.string)