diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index b35fab1..269fe58 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -34,7 +34,9 @@ jobs:
         bundle install --jobs 4 --retry 3
 
     - name: Run test with Rails ${{ matrix.rails_version }}
-      run: bundle exec rake
+      run: |
+        bundle exec rake
+        bundle exec srb tc
 
     - name: Publish Test Coverage
       uses: paambaati/codeclimate-action@v2.6.0
diff --git a/Gemfile b/Gemfile
index 1f11b6d..1ec243f 100644
--- a/Gemfile
+++ b/Gemfile
@@ -2,3 +2,5 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in tapping_device.gemspec
 gemspec
+
+gem 'sorbet'
diff --git a/Gemfile.lock b/Gemfile.lock
index fb0914e..2dffab3 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -6,6 +6,7 @@ PATH
       activesupport
       pastel
       pry
+      sorbet-runtime
 
 GEM
   remote: https://rubygems.org/
@@ -55,6 +56,10 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
+    sorbet (0.5.5891)
+      sorbet-static (= 0.5.5891)
+    sorbet-runtime (0.5.5891)
+    sorbet-static (0.5.5891-universal-darwin-14)
     sqlite3 (1.4.1)
     thread_safe (0.3.6)
     tty-color (0.5.2)
@@ -71,6 +76,7 @@ DEPENDENCIES
   rake (~> 13.0)
   rspec (~> 3.0)
   simplecov (= 0.17.1)
+  sorbet
   sqlite3 (>= 1.3.6)
   tapping_device!
 
diff --git a/lib/tapping_device.rb b/lib/tapping_device.rb
index 58ba0cc..9166877 100644
--- a/lib/tapping_device.rb
+++ b/lib/tapping_device.rb
@@ -1,7 +1,10 @@
+# typed: true
+require 'sorbet-runtime'
 require "active_record"
 require "active_support/core_ext/module/introspection"
 require "pry" # for using Method#source
 
+require "tapping_device/types/call_site"
 require "tapping_device/version"
 require "tapping_device/manageable"
 require "tapping_device/payload"
@@ -17,9 +20,10 @@
 require "tapping_device/trackers/mutation_tracker"
 
 class TappingDevice
+  extend T::Sig
 
-  CALLER_START_POINT = 3
-  C_CALLER_START_POINT = 2
+  CALLER_START_POINT = 6
+  C_CALLER_START_POINT = 5
 
   attr_reader :options, :calls, :trace_point, :target
 
@@ -31,33 +35,39 @@ class TappingDevice
   include Configurable
   include Output::Helpers
 
+  sig{params(options: Hash, block: T.nilable(Proc)).void}
   def initialize(options = {}, &block)
-    @block = block
-    @output_block = nil
-    @options = process_options(options.dup)
-    @calls = []
-    @disabled = false
-    @with_condition = nil
+    @block = T.let(block, T.nilable(Proc))
+    @output_block = T.let(nil, T.nilable(Proc))
+    @options = T.let(process_options(options.dup), T::Hash[Symbol, T.untyped])
+    @calls = T.let([], T::Array[Payload])
+    @disabled = T.let(false, T::Boolean)
+    @with_condition = T.let(nil, T.nilable(Proc))
     TappingDevice.devices << self
   end
 
+  sig{params(block: T.nilable(Proc)).void}
   def with(&block)
     @with_condition = block
   end
 
+  sig{params(block: T.nilable(Proc)).void}
   def set_block(&block)
     @block = block
   end
 
+  sig{void}
   def stop!
     @disabled = true
     TappingDevice.delete_device(self)
   end
 
+  sig{params(block: T.nilable(Proc)).void}
   def stop_when(&block)
     @stop_when = block
   end
 
+  sig{returns(TappingDevice)}
   def create_child_device
     new_device = self.class.new(@options.merge(root_device: root_device), &@block)
     new_device.stop_when(&@stop_when)
@@ -66,21 +76,24 @@ def create_child_device
     new_device
   end
 
+  sig{returns(TappingDevice)}
   def root_device
     options[:root_device]
   end
 
+  sig{returns(T::Array[TappingDevice])}
   def descendants
     options[:descendants]
   end
 
+  sig{params(object: T.untyped).returns(TappingDevice)}
   def track(object)
     @target = object
     validate_target!
 
     MethodHijacker.new(@target).hijack_methods! if options[:hijack_attr_methods]
 
-    @trace_point = build_minimum_trace_point(event_type: options[:event_type]) do |payload|
+    @trace_point = build_minimum_trace_point(Array(options[:event_type])) do |payload|
       record_call!(payload)
 
       stop_if_condition_fulfilled!(payload)
@@ -93,16 +106,19 @@ def track(object)
 
   private
 
-  def build_minimum_trace_point(event_type:)
-    TracePoint.new(*event_type) do |tp|
+  sig{params(event_types: T::Array[Symbol]).returns(TracePoint)}
+  def build_minimum_trace_point(event_types)
+    # sorbet doesn't accept splat arguments
+    # see https://sorbet.org/docs/error-reference#7019
+    T.unsafe(TracePoint).new(*event_types) do |tp|
       next unless filter_condition_satisfied?(tp)
 
-      filepath, line_number = get_call_location(tp)
-      payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
+      call_site = get_call_location(tp)
+      payload = build_payload(tp: tp, call_site: call_site)
 
       unless @options[:force_recording]
         next if is_tapping_device_call?(tp)
-        next if should_be_skipped_by_paths?(filepath)
+        next if should_be_skipped_by_paths?(call_site.filepath)
         next unless with_condition_satisfied?(payload)
         next if payload.is_private_call? && @options[:ignore_private]
         next if !payload.is_private_call? && @options[:only_private]
@@ -112,18 +128,22 @@ def build_minimum_trace_point(event_type:)
     end
   end
 
+  sig{void}
   def validate_target!; end
 
+  sig {params(tp: TracePoint).returns(T::Boolean)}
   def filter_condition_satisfied?(tp)
     false
   end
 
   # this needs to be placed upfront so we can exclude noise before doing more work
+  sig {params(filepath: String).returns(T::Boolean)}
   def should_be_skipped_by_paths?(filepath)
     options[:exclude_by_paths].any? { |pattern| pattern.match?(filepath) } ||
       (options[:filter_by_paths].present? && !options[:filter_by_paths].any? { |pattern| pattern.match?(filepath) })
   end
 
+  sig {params(tp: TracePoint).returns(T::Boolean)}
   def is_tapping_device_call?(tp)
     if tp.defined_class == TappingDevice::Trackable || tp.defined_class == TappingDevice
       return true
@@ -136,11 +156,13 @@ def is_tapping_device_call?(tp)
     end
   end
 
+  sig {params(payload: Payload).returns(T::Boolean)}
   def with_condition_satisfied?(payload)
     @with_condition.blank? || @with_condition.call(payload)
   end
 
-  def build_payload(tp:, filepath:, line_number:)
+  sig {params(tp: TracePoint, call_site: Types::CallSite).returns(Payload)}
+  def build_payload(tp:, call_site:)
     Payload.init({
       target: @target,
       receiver: tp.self,
@@ -148,8 +170,8 @@ def build_payload(tp:, filepath:, line_number:)
       method_object: get_method_object_from(tp.self, tp.callee_id),
       arguments: collect_arguments(tp),
       return_value: (tp.return_value rescue nil),
-      filepath: filepath,
-      line_number: line_number,
+      filepath: call_site.filepath,
+      line_number: call_site.line_number,
       defined_class: tp.defined_class,
       trace: get_traces(tp),
       is_private_call?: tp.defined_class.private_method_defined?(tp.callee_id),
@@ -158,6 +180,7 @@ def build_payload(tp:, filepath:, line_number:)
     })
   end
 
+  sig {params(target: T.untyped, method_name: Symbol).returns(T.nilable(Method))}
   def get_method_object_from(target, method_name)
     Object.instance_method(:method).bind(target).call(method_name)
   rescue NameError
@@ -166,10 +189,15 @@ def get_method_object_from(target, method_name)
     nil
   end
 
+  sig {params(tp: TracePoint, padding: Integer).returns(Types::CallSite)}
   def get_call_location(tp, padding: 0)
-    caller(get_trace_index(tp) + padding).first.split(":")[0..1]
+    traces = caller(get_trace_index(tp) + padding) || []
+    target_trace = traces.first || ""
+    filepath, line_number = target_trace.split(":")
+    Types::CallSite.new(filepath: filepath || "", line_number: line_number || "")
   end
 
+  sig {params(tp: TracePoint).returns(Integer)}
   def get_trace_index(tp)
     if tp.event == :c_call
       C_CALLER_START_POINT
@@ -178,15 +206,17 @@ def get_trace_index(tp)
     end
   end
 
+  sig {params(tp: TracePoint).returns(T::Array[String])}
   def get_traces(tp)
     if with_trace_to = options[:with_trace_to]
       trace_index = get_trace_index(tp)
-      caller[trace_index..(trace_index + with_trace_to)]
+      Array(caller[trace_index..(trace_index + with_trace_to)])
     else
       []
     end
   end
 
+  sig {params(tp: TracePoint).returns(T::Hash[Symbol, T.untyped])}
   def collect_arguments(tp)
     parameters =
       if RUBY_VERSION.to_f >= 2.6
@@ -200,6 +230,7 @@ def collect_arguments(tp)
     end
   end
 
+  sig {params(options: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped])}
   def process_options(options)
     options[:filter_by_paths] ||= config[:filter_by_paths]
     options[:exclude_by_paths] ||= config[:exclude_by_paths]
@@ -214,22 +245,30 @@ def process_options(options)
 
     options[:descendants] ||= []
     options[:root_device] ||= self
+
+    options[:exclude_by_paths] << /sorbet-runtime/
     options
   end
 
+  sig {params(tp: TracePoint).returns(T::Boolean)}
   def is_from_target?(tp)
     comparsion = tp.self
     is_the_same_record?(comparsion) || target.__id__ == comparsion.__id__
   end
 
+  sig {params(comparsion: T.untyped).returns(T::Boolean)}
   def is_the_same_record?(comparsion)
     return false unless options[:track_as_records]
+
     if target.is_a?(ActiveRecord::Base) && comparsion.is_a?(target.class)
       primary_key = target.class.primary_key
       target.send(primary_key) && target.send(primary_key) == comparsion.send(primary_key)
+    else
+      false
     end
   end
 
+  sig {params(payload: Payload).void}
   def record_call!(payload)
     return if @disabled
 
@@ -242,10 +281,12 @@ def record_call!(payload)
     end
   end
 
+  sig {params(payload: Payload).void}
   def write_output!(payload)
     @output_writer.write!(payload)
   end
 
+  sig {params(payload: Payload).void}
   def stop_if_condition_fulfilled!(payload)
     if @stop_when&.call(payload)
       stop!
@@ -253,6 +294,7 @@ def stop_if_condition_fulfilled!(payload)
     end
   end
 
+  sig {returns(T::Hash[Symbol, T.untyped])}
   def config
     TappingDevice.config
   end
diff --git a/lib/tapping_device/configurable.rb b/lib/tapping_device/configurable.rb
index dfea1f6..004595f 100644
--- a/lib/tapping_device/configurable.rb
+++ b/lib/tapping_device/configurable.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "active_support/configurable"
 require "active_support/concern"
 
diff --git a/lib/tapping_device/exceptions.rb b/lib/tapping_device/exceptions.rb
index caac6f6..f80dfd5 100644
--- a/lib/tapping_device/exceptions.rb
+++ b/lib/tapping_device/exceptions.rb
@@ -1,3 +1,4 @@
+# typed: true
 class TappingDevice
   class Exception < StandardError
   end
diff --git a/lib/tapping_device/manageable.rb b/lib/tapping_device/manageable.rb
index 3aad7cb..a87c60d 100644
--- a/lib/tapping_device/manageable.rb
+++ b/lib/tapping_device/manageable.rb
@@ -1,3 +1,4 @@
+# typed: true
 class TappingDevice
   module Manageable
 
diff --git a/lib/tapping_device/method_hijacker.rb b/lib/tapping_device/method_hijacker.rb
index a381d24..9fb346c 100644
--- a/lib/tapping_device/method_hijacker.rb
+++ b/lib/tapping_device/method_hijacker.rb
@@ -1,3 +1,4 @@
+# typed: true
 class TappingDevice
   class MethodHijacker
     attr_reader :target
diff --git a/lib/tapping_device/output.rb b/lib/tapping_device/output.rb
index 5ed35ec..d1aff05 100644
--- a/lib/tapping_device/output.rb
+++ b/lib/tapping_device/output.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "tapping_device/output/payload"
 require "tapping_device/output/writer"
 require "tapping_device/output/stdout_writer"
diff --git a/lib/tapping_device/output/file_writer.rb b/lib/tapping_device/output/file_writer.rb
index 9de8d99..403f61a 100644
--- a/lib/tapping_device/output/file_writer.rb
+++ b/lib/tapping_device/output/file_writer.rb
@@ -1,6 +1,8 @@
+# typed: true
 class TappingDevice
   module Output
     class FileWriter < Writer
+      sig {params(options: Hash, output_block: Proc).void}
       def initialize(options, output_block)
         @path = options[:log_file]
 
@@ -9,6 +11,7 @@ def initialize(options, output_block)
         super
       end
 
+      sig {params(payload: TappingDevice::Payload).void}
       def write!(payload)
         output = generate_output(payload)
 
diff --git a/lib/tapping_device/output/payload.rb b/lib/tapping_device/output/payload.rb
index e21729e..75ea5b6 100644
--- a/lib/tapping_device/output/payload.rb
+++ b/lib/tapping_device/output/payload.rb
@@ -1,9 +1,10 @@
+# typed: true
 require "pastel"
 
 class TappingDevice
   module Output
-    class Payload < Payload
-      UNDEFINED = "[undefined]"
+    class Payload < TappingDevice::Payload
+      UNDEFINED_MARK = "[undefined]"
       PRIVATE_MARK = " (private)"
 
       PASTEL = Pastel.new
@@ -127,8 +128,8 @@ def generate_string_result(obj, inspect)
           array_to_string(obj, inspect)
         when Hash
           hash_to_string(obj, inspect)
-        when UNDEFINED
-          UNDEFINED
+        when UNDEFINED_MARK
+          UNDEFINED_MARK
         when String
           "\"#{obj}\""
         when nil
diff --git a/lib/tapping_device/output/stdout_writer.rb b/lib/tapping_device/output/stdout_writer.rb
index fc3474f..0e54d24 100644
--- a/lib/tapping_device/output/stdout_writer.rb
+++ b/lib/tapping_device/output/stdout_writer.rb
@@ -1,6 +1,8 @@
+# typed: true
 class TappingDevice
   module Output
     class StdoutWriter < Writer
+      sig {params(payload: TappingDevice::Payload).void}
       def write!(payload)
         puts(generate_output(payload))
       end
diff --git a/lib/tapping_device/output/writer.rb b/lib/tapping_device/output/writer.rb
index e91b2ec..467bba5 100644
--- a/lib/tapping_device/output/writer.rb
+++ b/lib/tapping_device/output/writer.rb
@@ -1,17 +1,23 @@
+# typed: false
 class TappingDevice
   module Output
     class Writer
+      extend T::Sig
+
+      sig {params(options: Hash, output_block: Proc).void}
       def initialize(options, output_block)
         @options = options
         @output_block = output_block
       end
 
+      sig {params(payload: TappingDevice::Payload).void}
       def write!(payload)
         raise NotImplementedError
       end
 
       private
 
+      sig {params(payload: TappingDevice::Payload).returns(String)}
       def generate_output(payload)
         @output_block.call(Output::Payload.init(payload), @options)
       end
diff --git a/lib/tapping_device/payload.rb b/lib/tapping_device/payload.rb
index 8111ad1..106c499 100644
--- a/lib/tapping_device/payload.rb
+++ b/lib/tapping_device/payload.rb
@@ -1,3 +1,4 @@
+# typed: true
 class TappingDevice
   class Payload < Hash
     ATTRS = [
diff --git a/lib/tapping_device/trackable.rb b/lib/tapping_device/trackable.rb
index ffdd2fb..45a1df0 100644
--- a/lib/tapping_device/trackable.rb
+++ b/lib/tapping_device/trackable.rb
@@ -1,3 +1,4 @@
+# typed: true
 class TappingDevice
   module Trackable
     def tap_init!(object, options = {}, &block)
diff --git a/lib/tapping_device/trackers/association_call_tracker.rb b/lib/tapping_device/trackers/association_call_tracker.rb
index 79c803c..56c0f6b 100644
--- a/lib/tapping_device/trackers/association_call_tracker.rb
+++ b/lib/tapping_device/trackers/association_call_tracker.rb
@@ -1,10 +1,15 @@
+# typed: true
 class TappingDevice
   module Trackers
     class AssociactionCallTracker < TappingDevice
+      extend T::Sig
+
+      sig{void}
       def validate_target!
         raise NotAnActiveRecordInstanceError.new(target) unless target.is_a?(ActiveRecord::Base)
       end
 
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def filter_condition_satisfied?(tp)
         return false unless is_from_target?(tp)
 
diff --git a/lib/tapping_device/trackers/initialization_tracker.rb b/lib/tapping_device/trackers/initialization_tracker.rb
index 5fbf142..22f9b34 100644
--- a/lib/tapping_device/trackers/initialization_tracker.rb
+++ b/lib/tapping_device/trackers/initialization_tracker.rb
@@ -1,6 +1,9 @@
+# typed: true
 class TappingDevice
   module Trackers
     class InitializationTracker < TappingDevice
+      extend T::Sig
+
       def initialize(options = {}, &block)
         super
         event_type = @options[:event_type]
@@ -9,13 +12,15 @@ def initialize(options = {}, &block)
         @options[:event_type] = [event_type, "c_#{event_type}"]
       end
 
+      sig{params(object: T.untyped).returns(TappingDevice)}
       def track(object)
         super
         @is_active_record_model = target.ancestors.include?(ActiveRecord::Base)
         self
       end
 
-      def build_payload(tp:, filepath:, line_number:)
+      sig {params(tp: TracePoint, call_site: Types::CallSite).returns(Payload)}
+      def build_payload(tp:, call_site:)
         payload = super
 
         return payload if @is_active_record_model
@@ -25,10 +30,12 @@ def build_payload(tp:, filepath:, line_number:)
         payload
       end
 
+      sig{void}
       def validate_target!
         raise NotAClassError.new(target) unless target.is_a?(Class)
       end
 
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def filter_condition_satisfied?(tp)
         receiver = tp.self
         method_name = tp.callee_id
diff --git a/lib/tapping_device/trackers/method_call_tracker.rb b/lib/tapping_device/trackers/method_call_tracker.rb
index 6e1689c..182fd6b 100644
--- a/lib/tapping_device/trackers/method_call_tracker.rb
+++ b/lib/tapping_device/trackers/method_call_tracker.rb
@@ -1,6 +1,10 @@
+# typed: true
 class TappingDevice
   module Trackers
     class MethodCallTracker < TappingDevice
+      extend T::Sig
+
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def filter_condition_satisfied?(tp)
         is_from_target?(tp)
       end
diff --git a/lib/tapping_device/trackers/mutation_tracker.rb b/lib/tapping_device/trackers/mutation_tracker.rb
index 5a5eb87..ee2214e 100644
--- a/lib/tapping_device/trackers/mutation_tracker.rb
+++ b/lib/tapping_device/trackers/mutation_tracker.rb
@@ -1,18 +1,23 @@
+# typed: true
 class TappingDevice
   module Trackers
     class MutationTracker < TappingDevice
+      extend T::Sig
+
       def initialize(options, &block)
         options[:hijack_attr_methods] = true
         super
         @snapshot_stack = []
       end
 
+      sig{params(object: T.untyped).returns(TappingDevice)}
       def track(object)
         super
         insert_snapshot_taking_trace_point
         self
       end
 
+      sig{void}
       def stop!
         super
         @ivar_snapshot_trace_point.disable
@@ -22,14 +27,16 @@ def stop!
 
       # we need to snapshot instance variables at the beginning of every method call
       # so we can get a correct state for the later comparison
+      sig{void}
       def insert_snapshot_taking_trace_point
-        @ivar_snapshot_trace_point = build_minimum_trace_point(event_type: :call) do
+        @ivar_snapshot_trace_point = build_minimum_trace_point([:call]) do
           snapshot_instance_variables
         end
 
         @ivar_snapshot_trace_point.enable unless TappingDevice.suspend_new
       end
 
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def filter_condition_satisfied?(tp)
         return false unless is_from_target?(tp)
 
@@ -43,7 +50,8 @@ def filter_condition_satisfied?(tp)
         end
       end
 
-      def build_payload(tp:, filepath:, line_number:)
+      sig {params(tp: TracePoint, call_site: Types::CallSite).returns(Payload)}
+      def build_payload(tp:, call_site:)
         payload = super
 
         if change_capturing_event?(tp)
@@ -53,17 +61,18 @@ def build_payload(tp:, filepath:, line_number:)
         payload
       end
 
+      sig{returns(Hash)}
       def capture_ivar_changes
         changes = {}
 
         additional_keys = @latest_instance_variables.keys - @instance_variables_snapshot.keys
         additional_keys.each do |key|
-          changes[key] = {before: Output::Payload::UNDEFINED, after: @latest_instance_variables[key]}
+          changes[key] = {before: Output::Payload::UNDEFINED_MARK, after: @latest_instance_variables[key]}
         end
 
         removed_keys = @instance_variables_snapshot.keys - @latest_instance_variables.keys
         removed_keys.each do |key|
-          changes[key] = {before: @instance_variables_snapshot[key], after: Output::Payload::UNDEFINED}
+          changes[key] = {before: @instance_variables_snapshot[key], after: Output::Payload::UNDEFINED_MARK}
         end
 
         remained_keys = @latest_instance_variables.keys - additional_keys
@@ -85,10 +94,12 @@ def target_instance_variables
         end
       end
 
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def snapshot_capturing_event?(tp)
         tp.event == :call
       end
 
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def change_capturing_event?(tp)
         !snapshot_capturing_event?(tp)
       end
diff --git a/lib/tapping_device/trackers/passed_tracker.rb b/lib/tapping_device/trackers/passed_tracker.rb
index e0d98f6..39e082c 100644
--- a/lib/tapping_device/trackers/passed_tracker.rb
+++ b/lib/tapping_device/trackers/passed_tracker.rb
@@ -1,7 +1,11 @@
+# typed: true
 class TappingDevice
   module Trackers
     # PassedTracker tracks calls that use the target object as an argument
     class PassedTracker < TappingDevice
+      extend T::Sig
+
+      sig {params(tp: TracePoint).returns(T::Boolean)}
       def filter_condition_satisfied?(tp)
         collect_arguments(tp).values.any? do |value|
           # during comparison, Ruby might perform data type conversion like calling `to_sym` on the value
diff --git a/lib/tapping_device/types/call_site.rb b/lib/tapping_device/types/call_site.rb
new file mode 100644
index 0000000..fd66ccf
--- /dev/null
+++ b/lib/tapping_device/types/call_site.rb
@@ -0,0 +1,8 @@
+class TappingDevice
+  module Types
+    class CallSite < T::Struct
+      const :filepath, String
+      const :line_number, String
+    end
+  end
+end
diff --git a/lib/tapping_device/version.rb b/lib/tapping_device/version.rb
index bd26687..35bc061 100644
--- a/lib/tapping_device/version.rb
+++ b/lib/tapping_device/version.rb
@@ -1,3 +1,4 @@
+# typed: strict
 class TappingDevice
   VERSION = "0.5.6"
 end
diff --git a/sorbet/config b/sorbet/config
new file mode 100644
index 0000000..7fb7a8e
--- /dev/null
+++ b/sorbet/config
@@ -0,0 +1,2 @@
+--dir
+.
diff --git a/sorbet/rbi/gems/activemodel.rbi b/sorbet/rbi/gems/activemodel.rbi
new file mode 100644
index 0000000..89e4b60
--- /dev/null
+++ b/sorbet/rbi/gems/activemodel.rbi
@@ -0,0 +1,748 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activemodel/all/activemodel.rbi
+#
+# activemodel-6.0.3.2
+
+module ActiveModel
+  def self.eager_load!; end
+  def self.gem_version; end
+  def self.version; end
+  extend ActiveSupport::Autoload
+end
+module ActiveModel::VERSION
+end
+module ActiveModel::Serializers
+  extend ActiveSupport::Autoload
+end
+class ActiveModel::Attribute
+  def ==(other); end
+  def _original_value_for_database; end
+  def assigned?; end
+  def came_from_user?; end
+  def changed?; end
+  def changed_from_assignment?; end
+  def changed_in_place?; end
+  def encode_with(coder); end
+  def eql?(other); end
+  def forgetting_assignment; end
+  def has_been_read?; end
+  def hash; end
+  def init_with(coder); end
+  def initialize(name, value_before_type_cast, type, original_attribute = nil); end
+  def initialize_dup(other); end
+  def initialized?; end
+  def name; end
+  def original_attribute; end
+  def original_value; end
+  def original_value_for_database; end
+  def self.from_database(name, value, type); end
+  def self.from_user(name, value, type, original_attribute = nil); end
+  def self.null(name); end
+  def self.uninitialized(name, type); end
+  def self.with_cast_value(name, value, type); end
+  def type; end
+  def type_cast(*arg0); end
+  def value; end
+  def value_before_type_cast; end
+  def value_for_database; end
+  def with_cast_value(value); end
+  def with_type(type); end
+  def with_value_from_database(value); end
+  def with_value_from_user(value); end
+end
+class ActiveModel::Attribute::FromDatabase < ActiveModel::Attribute
+  def _original_value_for_database; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::FromUser < ActiveModel::Attribute
+  def came_from_user?; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::WithCastValue < ActiveModel::Attribute
+  def changed_in_place?; end
+  def type_cast(value); end
+end
+class ActiveModel::Attribute::Null < ActiveModel::Attribute
+  def initialize(name); end
+  def type_cast(*arg0); end
+  def with_cast_value(value); end
+  def with_type(type); end
+  def with_value_from_database(value); end
+  def with_value_from_user(value); end
+end
+class ActiveModel::Attribute::Uninitialized < ActiveModel::Attribute
+  def forgetting_assignment; end
+  def initialize(name, type); end
+  def initialized?; end
+  def original_value; end
+  def value; end
+  def value_for_database; end
+  def with_type(type); end
+end
+class ActiveModel::AttributeSet
+  def ==(other); end
+  def [](name); end
+  def []=(name, value); end
+  def accessed; end
+  def attributes; end
+  def deep_dup; end
+  def each_value(*args, &block); end
+  def except(*args, &block); end
+  def fetch(*args, &block); end
+  def fetch_value(name, &block); end
+  def freeze; end
+  def initialize(attributes); end
+  def initialize_clone(_); end
+  def initialize_dup(_); end
+  def initialized_attributes; end
+  def key?(name); end
+  def keys; end
+  def map(&block); end
+  def reset(key); end
+  def to_h; end
+  def to_hash; end
+  def values_before_type_cast; end
+  def write_cast_value(name, value); end
+  def write_from_database(name, value); end
+  def write_from_user(name, value); end
+end
+class ActiveModel::AttributeSet::Builder
+  def build_from_database(values = nil, additional_types = nil); end
+  def default_attributes; end
+  def initialize(types, default_attributes = nil); end
+  def types; end
+end
+class ActiveModel::LazyAttributeHash
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def additional_types; end
+  def assign_default_value(name); end
+  def deep_dup; end
+  def default_attributes; end
+  def delegate_hash; end
+  def each_key(*args, &block); end
+  def each_value(*args, &block); end
+  def except(*args, &block); end
+  def fetch(*args, &block); end
+  def initialize(types, values, additional_types, default_attributes, delegate_hash = nil); end
+  def initialize_dup(_); end
+  def key?(key); end
+  def marshal_dump; end
+  def marshal_load(values); end
+  def materialize; end
+  def select; end
+  def transform_values(*args, &block); end
+  def types; end
+  def values; end
+end
+class ActiveModel::AttributeSet::YAMLEncoder
+  def decode(coder); end
+  def default_types; end
+  def encode(attribute_set, coder); end
+  def initialize(default_types); end
+end
+class ActiveModel::MissingAttributeError < NoMethodError
+end
+module ActiveModel::AttributeMethods
+  def _read_attribute(attr); end
+  def attribute_method?(attr_name); end
+  def attribute_missing(match, *args, &block); end
+  def matched_attribute_method(method_name); end
+  def method_missing(method, *args, &block); end
+  def missing_attribute(attr_name, stack); end
+  def respond_to?(method, include_private_methods = nil); end
+  def respond_to_without_attributes?(*arg0); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::AttributeMethods::ClassMethods
+  def alias_attribute(new_name, old_name); end
+  def attribute_alias(name); end
+  def attribute_alias?(new_name); end
+  def attribute_method_affix(*affixes); end
+  def attribute_method_matchers_cache; end
+  def attribute_method_matchers_matching(method_name); end
+  def attribute_method_prefix(*prefixes); end
+  def attribute_method_suffix(*suffixes); end
+  def define_attribute_method(attr_name); end
+  def define_attribute_methods(*attr_names); end
+  def define_proxy_call(include_private, mod, name, target, *extra); end
+  def generated_attribute_methods; end
+  def instance_method_already_implemented?(method_name); end
+  def undefine_attribute_methods; end
+end
+class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
+  def initialize(options = nil); end
+  def match(method_name); end
+  def method_name(attr_name); end
+  def plain?; end
+  def prefix; end
+  def suffix; end
+  def target; end
+end
+class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher::AttributeMethodMatch < Struct
+  def attr_name; end
+  def attr_name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def target; end
+  def target=(_); end
+end
+module ActiveModel::AttributeMethods::AttrNames
+  def self.define_attribute_accessor_method(mod, attr_name, writer: nil); end
+end
+class ActiveModel::Errors
+  def [](attribute); end
+  def add(attribute, message = nil, options = nil); end
+  def added?(attribute, message = nil, options = nil); end
+  def apply_default_array(hash); end
+  def as_json(options = nil); end
+  def blank?; end
+  def clear; end
+  def copy!(other); end
+  def count; end
+  def delete(key); end
+  def details; end
+  def each; end
+  def empty?; end
+  def full_message(attribute, message); end
+  def full_messages; end
+  def full_messages_for(attribute); end
+  def generate_message(attribute, type = nil, options = nil); end
+  def has_key?(attribute); end
+  def include?(attribute); end
+  def init_with(coder); end
+  def initialize(base); end
+  def initialize_dup(other); end
+  def key?(attribute); end
+  def keys; end
+  def marshal_dump; end
+  def marshal_load(array); end
+  def merge!(other); end
+  def messages; end
+  def normalize_detail(message, options); end
+  def normalize_message(attribute, message, options); end
+  def of_kind?(attribute, message = nil); end
+  def self.i18n_customize_full_message; end
+  def self.i18n_customize_full_message=(arg0); end
+  def size; end
+  def slice!(*keys); end
+  def to_a; end
+  def to_hash(full_messages = nil); end
+  def to_xml(options = nil); end
+  def values; end
+  def without_default_proc(hash); end
+  include Enumerable
+end
+class ActiveModel::StrictValidationFailed < StandardError
+end
+class ActiveModel::RangeError < RangeError
+end
+class ActiveModel::UnknownAttributeError < NoMethodError
+  def attribute; end
+  def initialize(record, attribute); end
+  def record; end
+end
+module ActiveModel::Callbacks
+  def _define_after_model_callback(klass, callback); end
+  def _define_around_model_callback(klass, callback); end
+  def _define_before_model_callback(klass, callback); end
+  def define_model_callbacks(*callbacks); end
+  def self.extended(base); end
+end
+class ActiveModel::Attribute::UserProvidedDefault < ActiveModel::Attribute::FromUser
+  def initialize(name, value, type, database_default); end
+  def marshal_dump; end
+  def marshal_load(values); end
+  def user_provided_value; end
+  def value_before_type_cast; end
+  def with_type(type); end
+end
+class ActiveModel::Name
+  def !~(*args, &block); end
+  def <=>(*args, &block); end
+  def ==(arg); end
+  def ===(arg); end
+  def =~(*args, &block); end
+  def _singularize(string); end
+  def as_json(*args, &block); end
+  def cache_key; end
+  def collection; end
+  def element; end
+  def eql?(*args, &block); end
+  def human(options = nil); end
+  def i18n_key; end
+  def initialize(klass, namespace = nil, name = nil); end
+  def match?(*args, &block); end
+  def name; end
+  def param_key; end
+  def plural; end
+  def route_key; end
+  def singular; end
+  def singular_route_key; end
+  def to_s(*args, &block); end
+  def to_str(*args, &block); end
+  include Comparable
+end
+module ActiveModel::Naming
+  def model_name; end
+  def self.extended(base); end
+  def self.model_name_from_record_or_class(record_or_class); end
+  def self.param_key(record_or_class); end
+  def self.plural(record_or_class); end
+  def self.route_key(record_or_class); end
+  def self.singular(record_or_class); end
+  def self.singular_route_key(record_or_class); end
+  def self.uncountable?(record_or_class); end
+end
+module ActiveModel::Translation
+  def human_attribute_name(attribute, options = nil); end
+  def i18n_scope; end
+  def lookup_ancestors; end
+  include ActiveModel::Naming
+end
+module ActiveModel::Type
+  def self.default_value; end
+  def self.lookup(*args, **kwargs); end
+  def self.register(type_name, klass = nil, **options, &block); end
+  def self.registry; end
+  def self.registry=(arg0); end
+end
+module ActiveModel::Type::Helpers
+end
+class ActiveModel::Type::Helpers::AcceptsMultiparameterTime < Module
+  def initialize(defaults: nil); end
+end
+module ActiveModel::Type::Helpers::Numeric
+  def cast(value); end
+  def changed?(old_value, _new_value, new_value_before_type_cast); end
+  def non_numeric_string?(value); end
+  def number_to_non_number?(old_value, new_value_before_type_cast); end
+  def serialize(value); end
+end
+module ActiveModel::Type::Helpers::Mutable
+  def cast(value); end
+  def changed_in_place?(raw_old_value, new_value); end
+end
+module ActiveModel::Type::Helpers::TimeValue
+  def apply_seconds_precision(value); end
+  def fast_string_to_time(string); end
+  def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil); end
+  def serialize(value); end
+  def type_cast_for_schema(value); end
+  def user_input_in_time_zone(value); end
+end
+module ActiveModel::Type::Helpers::Timezone
+  def default_timezone; end
+  def is_utc?; end
+end
+class ActiveModel::Type::Value
+  def ==(other); end
+  def assert_valid_value(*arg0); end
+  def binary?; end
+  def cast(value); end
+  def cast_value(value); end
+  def changed?(old_value, new_value, _new_value_before_type_cast); end
+  def changed_in_place?(raw_old_value, new_value); end
+  def deserialize(value); end
+  def eql?(other); end
+  def force_equality?(_value); end
+  def hash; end
+  def initialize(precision: nil, limit: nil, scale: nil); end
+  def limit; end
+  def map(value); end
+  def precision; end
+  def scale; end
+  def serialize(value); end
+  def type; end
+  def type_cast_for_schema(value); end
+  def value_constructed_by_mass_assignment?(_value); end
+end
+class ActiveModel::Type::Integer < ActiveModel::Type::Value
+  def _limit; end
+  def cast_value(value); end
+  def deserialize(value); end
+  def ensure_in_range(value); end
+  def initialize(*arg0, **arg1); end
+  def max_value; end
+  def min_value; end
+  def range; end
+  def serialize(value); end
+  def type; end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::BigInteger < ActiveModel::Type::Integer
+  def max_value; end
+end
+class ActiveModel::Type::Binary < ActiveModel::Type::Value
+  def binary?; end
+  def cast(value); end
+  def changed_in_place?(raw_old_value, value); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::Binary::Data
+  def ==(other); end
+  def hex; end
+  def initialize(value); end
+  def to_s; end
+  def to_str; end
+end
+class ActiveModel::Type::Boolean < ActiveModel::Type::Value
+  def cast_value(value); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::Date < ActiveModel::Type::Value
+  def cast_value(value); end
+  def fallback_string_to_date(string); end
+  def fast_string_to_date(string); end
+  def new_date(year, mon, mday); end
+  def type; end
+  def type_cast_for_schema(value); end
+  def value_from_multiparameter_assignment(*arg0); end
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_1
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_1
+  def assert_valid_value(value); end
+  def cast(value); end
+  def serialize(value); end
+  def value_constructed_by_mass_assignment?(value); end
+  def value_from_multiparameter_assignment(values_hash); end
+end
+class ActiveModel::Type::DateTime < ActiveModel::Type::Value
+  def cast_value(value); end
+  def fallback_string_to_time(string); end
+  def microseconds(time); end
+  def type; end
+  def value_from_multiparameter_assignment(values_hash); end
+  include ActiveModel::Type::Helpers::TimeValue
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_2
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_2
+  def assert_valid_value(value); end
+  def cast(value); end
+  def serialize(value); end
+  def value_constructed_by_mass_assignment?(value); end
+  def value_from_multiparameter_assignment(values_hash); end
+end
+class ActiveModel::Type::Decimal < ActiveModel::Type::Value
+  def apply_scale(value); end
+  def cast_value(value); end
+  def convert_float_to_big_decimal(value); end
+  def float_precision; end
+  def type; end
+  def type_cast_for_schema(value); end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::Float < ActiveModel::Type::Value
+  def cast_value(value); end
+  def type; end
+  def type_cast_for_schema(value); end
+  include ActiveModel::Type::Helpers::Numeric
+end
+class ActiveModel::Type::ImmutableString < ActiveModel::Type::Value
+  def cast_value(value); end
+  def serialize(value); end
+  def type; end
+end
+class ActiveModel::Type::String < ActiveModel::Type::ImmutableString
+  def cast_value(value); end
+  def changed_in_place?(raw_old_value, new_value); end
+end
+class ActiveModel::Type::Time < ActiveModel::Type::Value
+  def cast_value(value); end
+  def type; end
+  def user_input_in_time_zone(value); end
+  include ActiveModel::Type::Helpers::TimeValue
+  include ActiveModel::Type::Helpers::Timezone
+  include Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_3
+end
+module Anonymous_ActiveModel_Type_Helpers_AcceptsMultiparameterTime_3
+  def assert_valid_value(value); end
+  def cast(value); end
+  def serialize(value); end
+  def value_constructed_by_mass_assignment?(value); end
+  def value_from_multiparameter_assignment(values_hash); end
+end
+class ActiveModel::Type::Registry
+  def find_registration(symbol, *args); end
+  def initialize; end
+  def lookup(symbol, *args, **kwargs); end
+  def register(type_name, klass = nil, **options, &block); end
+  def registration_klass; end
+  def registrations; end
+end
+class ActiveModel::Type::Registration
+  def block; end
+  def call(_registry, *args, **kwargs); end
+  def initialize(name, block, **arg2); end
+  def matches?(type_name, *args, **kwargs); end
+  def name; end
+end
+class ActiveModel::ForbiddenAttributesError < StandardError
+end
+module ActiveModel::ForbiddenAttributesProtection
+  def sanitize_for_mass_assignment(attributes); end
+  def sanitize_forbidden_attributes(attributes); end
+end
+module ActiveModel::AttributeAssignment
+  def _assign_attribute(k, v); end
+  def _assign_attributes(attributes); end
+  def assign_attributes(new_attributes); end
+  def attributes=(new_attributes); end
+  include ActiveModel::ForbiddenAttributesProtection
+end
+module ActiveModel::Conversion
+  def to_key; end
+  def to_model; end
+  def to_param; end
+  def to_partial_path; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Conversion::ClassMethods
+  def _to_partial_path; end
+end
+module ActiveModel::Validations
+  def errors; end
+  def initialize_dup(other); end
+  def invalid?(context = nil); end
+  def raise_validation_error; end
+  def read_attribute_for_validation(*arg0); end
+  def run_validations!; end
+  def valid?(context = nil); end
+  def validate!(context = nil); end
+  def validate(context = nil); end
+  def validates_with(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::ClassMethods
+  def _parse_validates_options(options); end
+  def _validates_default_keys; end
+  def attribute_method?(attribute); end
+  def clear_validators!; end
+  def inherited(base); end
+  def validate(*args, &block); end
+  def validates!(*attributes); end
+  def validates(*attributes); end
+  def validates_each(*attr_names, &block); end
+  def validates_with(*args, &block); end
+  def validators; end
+  def validators_on(*attributes); end
+end
+module ActiveModel::Validations::Clusivity
+  def check_validity!; end
+  def delimiter; end
+  def include?(record, value); end
+  def inclusion_method(enumerable); end
+end
+class ActiveModel::Validator
+  def initialize(options = nil); end
+  def kind; end
+  def options; end
+  def self.kind; end
+  def validate(record); end
+end
+class ActiveModel::EachValidator < ActiveModel::Validator
+  def attributes; end
+  def check_validity!; end
+  def initialize(options); end
+  def validate(record); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::BlockValidator < ActiveModel::EachValidator
+  def initialize(options, &block); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::InclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+module ActiveModel::Validations::HelperMethods
+  def _merge_attributes(attr_names); end
+  def validates_absence_of(*attr_names); end
+  def validates_acceptance_of(*attr_names); end
+  def validates_confirmation_of(*attr_names); end
+  def validates_exclusion_of(*attr_names); end
+  def validates_format_of(*attr_names); end
+  def validates_inclusion_of(*attr_names); end
+  def validates_length_of(*attr_names); end
+  def validates_numericality_of(*attr_names); end
+  def validates_presence_of(*attr_names); end
+  def validates_size_of(*attr_names); end
+end
+class ActiveModel::Validations::AbsenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::NumericalityValidator < ActiveModel::EachValidator
+  def allow_only_integer?(record); end
+  def check_validity!; end
+  def filtered_options(value); end
+  def is_hexadecimal_literal?(raw_value); end
+  def is_integer?(raw_value); end
+  def is_number?(raw_value); end
+  def parse_as_number(raw_value); end
+  def record_attribute_changed_in_place?(record, attr_name); end
+  def validate_each(record, attr_name, value); end
+end
+module ActiveModel::Validations::Callbacks
+  def run_validations!; end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::Validations::Callbacks::ClassMethods
+  def after_validation(*args, &block); end
+  def before_validation(*args, &block); end
+end
+class ActiveModel::Validations::ExclusionValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value); end
+  include ActiveModel::Validations::Clusivity
+end
+class ActiveModel::Validations::ConfirmationValidator < ActiveModel::EachValidator
+  def confirmation_value_equal?(record, attribute, value, confirmed); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::FormatValidator < ActiveModel::EachValidator
+  def check_options_validity(name); end
+  def check_validity!; end
+  def option_call(record, name); end
+  def record_error(record, attribute, name, value); end
+  def regexp_using_multiline_anchors?(regexp); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::PresenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attr_name, value); end
+end
+class ActiveModel::Validations::LengthValidator < ActiveModel::EachValidator
+  def check_validity!; end
+  def initialize(options); end
+  def skip_nil_check?(key); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator < ActiveModel::EachValidator
+  def acceptable_option?(value); end
+  def initialize(options); end
+  def setup!(klass); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
+  def ==(other); end
+  def attributes; end
+  def define_on(klass); end
+  def included(klass); end
+  def initialize(attributes); end
+  def matches?(method_name); end
+end
+class ActiveModel::Validations::WithValidator < ActiveModel::EachValidator
+  def validate_each(record, attr, val); end
+end
+class ActiveModel::ValidationError < StandardError
+  def initialize(model); end
+  def model; end
+end
+class ActiveModel::AttributeMutationTracker
+  def any_changes?; end
+  def attr_names; end
+  def attribute_changed?(attr_name); end
+  def attributes; end
+  def change_to_attribute(attr_name); end
+  def changed?(attr_name, from: nil, to: nil); end
+  def changed_attribute_names; end
+  def changed_in_place?(attr_name); end
+  def changed_values; end
+  def changes; end
+  def fetch_value(attr_name); end
+  def force_change(attr_name); end
+  def forced_changes; end
+  def forget_change(attr_name); end
+  def initialize(attributes, forced_changes = nil); end
+  def original_value(attr_name); end
+end
+class ActiveModel::ForcedMutationTracker < ActiveModel::AttributeMutationTracker
+  def attr_names; end
+  def attribute_changed?(attr_name); end
+  def change_to_attribute(attr_name); end
+  def changed_in_place?(attr_name); end
+  def clone_value(attr_name); end
+  def fetch_value(attr_name); end
+  def finalize_changes; end
+  def finalized_changes; end
+  def force_change(attr_name); end
+  def forget_change(attr_name); end
+  def initialize(attributes, forced_changes = nil); end
+  def original_value(attr_name); end
+end
+class ActiveModel::NullMutationTracker
+  def any_changes?; end
+  def change_to_attribute(attr_name); end
+  def changed?(attr_name, **arg1); end
+  def changed_attribute_names; end
+  def changed_in_place?(attr_name); end
+  def changed_values; end
+  def changes; end
+  def original_value(attr_name); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  extend Singleton::SingletonClassMethods
+  include Singleton
+end
+module ActiveModel::Dirty
+  def attribute_change(attr_name); end
+  def attribute_changed?(attr_name, **options); end
+  def attribute_changed_in_place?(attr_name); end
+  def attribute_previous_change(attr_name); end
+  def attribute_previously_changed?(attr_name); end
+  def attribute_was(attr_name); end
+  def attribute_will_change!(attr_name); end
+  def changed; end
+  def changed?; end
+  def changed_attributes; end
+  def changes; end
+  def changes_applied; end
+  def clear_attribute_change(attr_name); end
+  def clear_attribute_changes(attr_names); end
+  def clear_changes_information; end
+  def forget_attribute_assignments; end
+  def initialize_dup(other); end
+  def mutations_before_last_save; end
+  def mutations_from_database; end
+  def previous_changes; end
+  def restore_attribute!(attr_name); end
+  def restore_attributes(attr_names = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::AttributeMethods
+end
+module ActiveModel::SecurePassword
+  def self.min_cost; end
+  def self.min_cost=(arg0); end
+  extend ActiveSupport::Concern
+end
+module ActiveModel::SecurePassword::ClassMethods
+  def has_secure_password(attribute = nil, validations: nil); end
+end
+class ActiveModel::SecurePassword::InstanceMethodsOnActivation < Module
+  def initialize(attribute); end
+end
+module ActiveModel::Serialization
+  def read_attribute_for_serialization(*arg0); end
+  def serializable_add_includes(options = nil); end
+  def serializable_hash(options = nil); end
+end
+module ActiveModel::Serializers::JSON
+  def as_json(options = nil); end
+  def from_json(json, include_root = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Serialization
+end
diff --git a/sorbet/rbi/gems/activerecord.rbi b/sorbet/rbi/gems/activerecord.rbi
new file mode 100644
index 0000000..b0187f7
--- /dev/null
+++ b/sorbet/rbi/gems/activerecord.rbi
@@ -0,0 +1,5451 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activerecord/all/activerecord.rbi
+#
+# activerecord-6.0.3.2
+
+module Arel
+  def self.arel_node?(value); end
+  def self.fetch_attribute(value); end
+  def self.sql(raw_sql); end
+  def self.star; end
+end
+class Arel::ArelError < StandardError
+end
+class Arel::EmptyJoinError < Arel::ArelError
+end
+module Arel::Crud
+  def compile_delete; end
+  def compile_insert(values); end
+  def compile_update(values, pk); end
+  def create_insert; end
+end
+module Arel::FactoryMethods
+  def coalesce(*exprs); end
+  def create_and(clauses); end
+  def create_false; end
+  def create_join(to, constraint = nil, klass = nil); end
+  def create_on(expr); end
+  def create_string_join(to); end
+  def create_table_alias(relation, name); end
+  def create_true; end
+  def grouping(expr); end
+  def lower(column); end
+end
+module Arel::Expressions
+  def average; end
+  def count(distinct = nil); end
+  def extract(field); end
+  def maximum; end
+  def minimum; end
+  def sum; end
+end
+module Arel::Predications
+  def between(other); end
+  def concat(other); end
+  def does_not_match(other, escape = nil, case_sensitive = nil); end
+  def does_not_match_all(others, escape = nil); end
+  def does_not_match_any(others, escape = nil); end
+  def does_not_match_regexp(other, case_sensitive = nil); end
+  def eq(other); end
+  def eq_all(others); end
+  def eq_any(others); end
+  def grouping_all(method_id, others, *extras); end
+  def grouping_any(method_id, others, *extras); end
+  def gt(right); end
+  def gt_all(others); end
+  def gt_any(others); end
+  def gteq(right); end
+  def gteq_all(others); end
+  def gteq_any(others); end
+  def in(other); end
+  def in_all(others); end
+  def in_any(others); end
+  def infinity?(value); end
+  def is_distinct_from(other); end
+  def is_not_distinct_from(other); end
+  def lt(right); end
+  def lt_all(others); end
+  def lt_any(others); end
+  def lteq(right); end
+  def lteq_all(others); end
+  def lteq_any(others); end
+  def matches(other, escape = nil, case_sensitive = nil); end
+  def matches_all(others, escape = nil, case_sensitive = nil); end
+  def matches_any(others, escape = nil, case_sensitive = nil); end
+  def matches_regexp(other, case_sensitive = nil); end
+  def not_between(other); end
+  def not_eq(other); end
+  def not_eq_all(others); end
+  def not_eq_any(others); end
+  def not_in(other); end
+  def not_in_all(others); end
+  def not_in_any(others); end
+  def open_ended?(value); end
+  def quoted_array(others); end
+  def quoted_node(other); end
+  def unboundable?(value); end
+  def when(right); end
+end
+module Arel::WindowPredications
+  def over(expr = nil); end
+end
+module Arel::Math
+  def &(other); end
+  def *(other); end
+  def +(other); end
+  def -(other); end
+  def /(other); end
+  def <<(other); end
+  def >>(other); end
+  def ^(other); end
+  def |(other); end
+  def ~; end
+end
+module Arel::AliasPredication
+  def as(other); end
+end
+module Arel::OrderPredications
+  def asc; end
+  def desc; end
+end
+class Arel::Table
+  def ==(other); end
+  def [](name); end
+  def able_to_type_cast?; end
+  def alias(name = nil); end
+  def eql?(other); end
+  def from; end
+  def group(*columns); end
+  def hash; end
+  def having(expr); end
+  def initialize(name, as: nil, type_caster: nil); end
+  def join(relation, klass = nil); end
+  def name; end
+  def name=(arg0); end
+  def order(*expr); end
+  def outer_join(relation); end
+  def project(*things); end
+  def self.engine; end
+  def self.engine=(arg0); end
+  def skip(amount); end
+  def table_alias; end
+  def table_alias=(arg0); end
+  def table_name; end
+  def take(amount); end
+  def type_cast_for_database(attribute_name, value); end
+  def type_caster; end
+  def where(condition); end
+  include Arel::Crud
+  include Arel::FactoryMethods
+end
+module Arel::Attributes
+  def self.for(column); end
+end
+class Anonymous_Struct_4 < Struct
+  def name; end
+  def name=(_); end
+  def relation; end
+  def relation=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Arel::Attributes::Attribute < Anonymous_Struct_4
+  def able_to_type_cast?; end
+  def lower; end
+  def type_cast_for_database(value); end
+  include Arel::AliasPredication
+  include Arel::Expressions
+  include Arel::Math
+  include Arel::OrderPredications
+  include Arel::Predications
+end
+class Arel::Attributes::String < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Time < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Boolean < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Decimal < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Float < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Integer < Arel::Attributes::Attribute
+end
+class Arel::Attributes::Undefined < Arel::Attributes::Attribute
+end
+module Arel::Visitors
+end
+class Arel::Visitors::Visitor
+  def accept(object, collector = nil); end
+  def dispatch; end
+  def get_dispatch_cache; end
+  def initialize; end
+  def self.dispatch_cache; end
+  def visit(object, collector = nil); end
+end
+class Arel::Visitors::DepthFirst < Arel::Visitors::Visitor
+  def binary(o); end
+  def function(o); end
+  def get_dispatch_cache; end
+  def initialize(block = nil); end
+  def nary(o); end
+  def terminal(o); end
+  def unary(o); end
+  def visit(o, _ = nil); end
+  def visit_ActiveSupport_Multibyte_Chars(o); end
+  def visit_ActiveSupport_StringInquirer(o); end
+  def visit_Arel_Attribute(o); end
+  def visit_Arel_Attributes_Attribute(o); end
+  def visit_Arel_Attributes_Boolean(o); end
+  def visit_Arel_Attributes_Decimal(o); end
+  def visit_Arel_Attributes_Float(o); end
+  def visit_Arel_Attributes_Integer(o); end
+  def visit_Arel_Attributes_String(o); end
+  def visit_Arel_Attributes_Time(o); end
+  def visit_Arel_Nodes_And(o); end
+  def visit_Arel_Nodes_As(o); end
+  def visit_Arel_Nodes_Ascending(o); end
+  def visit_Arel_Nodes_Assignment(o); end
+  def visit_Arel_Nodes_Avg(o); end
+  def visit_Arel_Nodes_Between(o); end
+  def visit_Arel_Nodes_BindParam(o); end
+  def visit_Arel_Nodes_Case(o); end
+  def visit_Arel_Nodes_Comment(o); end
+  def visit_Arel_Nodes_Concat(o); end
+  def visit_Arel_Nodes_Count(o); end
+  def visit_Arel_Nodes_Cube(o); end
+  def visit_Arel_Nodes_DeleteStatement(o); end
+  def visit_Arel_Nodes_Descending(o); end
+  def visit_Arel_Nodes_DoesNotMatch(o); end
+  def visit_Arel_Nodes_Else(o); end
+  def visit_Arel_Nodes_Equality(o); end
+  def visit_Arel_Nodes_Exists(o); end
+  def visit_Arel_Nodes_False(o); end
+  def visit_Arel_Nodes_FullOuterJoin(o); end
+  def visit_Arel_Nodes_GreaterThan(o); end
+  def visit_Arel_Nodes_GreaterThanOrEqual(o); end
+  def visit_Arel_Nodes_Group(o); end
+  def visit_Arel_Nodes_Grouping(o); end
+  def visit_Arel_Nodes_GroupingElement(o); end
+  def visit_Arel_Nodes_GroupingSet(o); end
+  def visit_Arel_Nodes_Having(o); end
+  def visit_Arel_Nodes_In(o); end
+  def visit_Arel_Nodes_InfixOperation(o); end
+  def visit_Arel_Nodes_InnerJoin(o); end
+  def visit_Arel_Nodes_InsertStatement(o); end
+  def visit_Arel_Nodes_IsDistinctFrom(o); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o); end
+  def visit_Arel_Nodes_JoinSource(o); end
+  def visit_Arel_Nodes_Lateral(o); end
+  def visit_Arel_Nodes_LessThan(o); end
+  def visit_Arel_Nodes_LessThanOrEqual(o); end
+  def visit_Arel_Nodes_Limit(o); end
+  def visit_Arel_Nodes_Lock(o); end
+  def visit_Arel_Nodes_Matches(o); end
+  def visit_Arel_Nodes_Max(o); end
+  def visit_Arel_Nodes_Min(o); end
+  def visit_Arel_Nodes_NamedFunction(o); end
+  def visit_Arel_Nodes_Node(o); end
+  def visit_Arel_Nodes_Not(o); end
+  def visit_Arel_Nodes_NotEqual(o); end
+  def visit_Arel_Nodes_NotIn(o); end
+  def visit_Arel_Nodes_NotRegexp(o); end
+  def visit_Arel_Nodes_Offset(o); end
+  def visit_Arel_Nodes_On(o); end
+  def visit_Arel_Nodes_OptimizerHints(o); end
+  def visit_Arel_Nodes_Or(o); end
+  def visit_Arel_Nodes_Ordering(o); end
+  def visit_Arel_Nodes_OuterJoin(o); end
+  def visit_Arel_Nodes_Regexp(o); end
+  def visit_Arel_Nodes_RightOuterJoin(o); end
+  def visit_Arel_Nodes_RollUp(o); end
+  def visit_Arel_Nodes_SelectCore(o); end
+  def visit_Arel_Nodes_SelectStatement(o); end
+  def visit_Arel_Nodes_SqlLiteral(o); end
+  def visit_Arel_Nodes_StringJoin(o); end
+  def visit_Arel_Nodes_Sum(o); end
+  def visit_Arel_Nodes_TableAlias(o); end
+  def visit_Arel_Nodes_True(o); end
+  def visit_Arel_Nodes_UnqualifiedColumn(o); end
+  def visit_Arel_Nodes_UpdateStatement(o); end
+  def visit_Arel_Nodes_ValuesList(o); end
+  def visit_Arel_Nodes_When(o); end
+  def visit_Arel_Nodes_Window(o); end
+  def visit_Arel_Table(o); end
+  def visit_Array(o); end
+  def visit_BigDecimal(o); end
+  def visit_Class(o); end
+  def visit_Date(o); end
+  def visit_DateTime(o); end
+  def visit_FalseClass(o); end
+  def visit_Float(o); end
+  def visit_Hash(o); end
+  def visit_Integer(o); end
+  def visit_NilClass(o); end
+  def visit_Set(o); end
+  def visit_String(o); end
+  def visit_Symbol(o); end
+  def visit_Time(o); end
+  def visit_TrueClass(o); end
+end
+class Arel::Visitors::UnsupportedVisitError < StandardError
+  def initialize(object); end
+end
+class Arel::Visitors::ToSql < Arel::Visitors::Visitor
+  def aggregate(name, o, collector); end
+  def build_subselect(key, o); end
+  def collect_in_clause(left, right, collector); end
+  def collect_nodes_for(nodes, collector, spacer, connector = nil); end
+  def collect_not_in_clause(left, right, collector); end
+  def collect_optimizer_hints(o, collector); end
+  def compile(node, collector = nil); end
+  def has_join_sources?(o); end
+  def has_limit_or_offset_or_orders?(o); end
+  def infix_value(o, collector, value); end
+  def infix_value_with_paren(o, collector, value, suppress_parens = nil); end
+  def initialize(connection); end
+  def inject_join(list, collector, join_str); end
+  def is_distinct_from(o, collector); end
+  def literal(o, collector); end
+  def maybe_visit(thing, collector); end
+  def prepare_delete_statement(o); end
+  def prepare_update_statement(o); end
+  def quote(value); end
+  def quote_column_name(name); end
+  def quote_table_name(name); end
+  def quoted(o, a); end
+  def sanitize_as_sql_comment(value); end
+  def unboundable?(value); end
+  def unsupported(o, collector); end
+  def visit_ActiveSupport_Multibyte_Chars(o, collector); end
+  def visit_ActiveSupport_StringInquirer(o, collector); end
+  def visit_Arel_Attributes_Attribute(o, collector); end
+  def visit_Arel_Attributes_Boolean(o, collector); end
+  def visit_Arel_Attributes_Decimal(o, collector); end
+  def visit_Arel_Attributes_Float(o, collector); end
+  def visit_Arel_Attributes_Integer(o, collector); end
+  def visit_Arel_Attributes_String(o, collector); end
+  def visit_Arel_Attributes_Time(o, collector); end
+  def visit_Arel_Nodes_Addition(o, collector); end
+  def visit_Arel_Nodes_And(o, collector); end
+  def visit_Arel_Nodes_As(o, collector); end
+  def visit_Arel_Nodes_Ascending(o, collector); end
+  def visit_Arel_Nodes_Assignment(o, collector); end
+  def visit_Arel_Nodes_Avg(o, collector); end
+  def visit_Arel_Nodes_Between(o, collector); end
+  def visit_Arel_Nodes_Bin(o, collector); end
+  def visit_Arel_Nodes_BindParam(o, collector); end
+  def visit_Arel_Nodes_Case(o, collector); end
+  def visit_Arel_Nodes_Casted(o, collector); end
+  def visit_Arel_Nodes_Comment(o, collector); end
+  def visit_Arel_Nodes_Count(o, collector); end
+  def visit_Arel_Nodes_CurrentRow(o, collector); end
+  def visit_Arel_Nodes_DeleteStatement(o, collector); end
+  def visit_Arel_Nodes_Descending(o, collector); end
+  def visit_Arel_Nodes_Distinct(o, collector); end
+  def visit_Arel_Nodes_DistinctOn(o, collector); end
+  def visit_Arel_Nodes_Division(o, collector); end
+  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
+  def visit_Arel_Nodes_Else(o, collector); end
+  def visit_Arel_Nodes_Equality(o, collector); end
+  def visit_Arel_Nodes_Except(o, collector); end
+  def visit_Arel_Nodes_Exists(o, collector); end
+  def visit_Arel_Nodes_Extract(o, collector); end
+  def visit_Arel_Nodes_False(o, collector); end
+  def visit_Arel_Nodes_Following(o, collector); end
+  def visit_Arel_Nodes_FullOuterJoin(o, collector); end
+  def visit_Arel_Nodes_GreaterThan(o, collector); end
+  def visit_Arel_Nodes_GreaterThanOrEqual(o, collector); end
+  def visit_Arel_Nodes_Group(o, collector); end
+  def visit_Arel_Nodes_Grouping(o, collector); end
+  def visit_Arel_Nodes_In(o, collector); end
+  def visit_Arel_Nodes_InfixOperation(o, collector); end
+  def visit_Arel_Nodes_InnerJoin(o, collector); end
+  def visit_Arel_Nodes_InsertStatement(o, collector); end
+  def visit_Arel_Nodes_Intersect(o, collector); end
+  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_JoinSource(o, collector); end
+  def visit_Arel_Nodes_LessThan(o, collector); end
+  def visit_Arel_Nodes_LessThanOrEqual(o, collector); end
+  def visit_Arel_Nodes_Limit(o, collector); end
+  def visit_Arel_Nodes_Lock(o, collector); end
+  def visit_Arel_Nodes_Matches(o, collector); end
+  def visit_Arel_Nodes_Max(o, collector); end
+  def visit_Arel_Nodes_Min(o, collector); end
+  def visit_Arel_Nodes_Multiplication(o, collector); end
+  def visit_Arel_Nodes_NamedFunction(o, collector); end
+  def visit_Arel_Nodes_NamedWindow(o, collector); end
+  def visit_Arel_Nodes_Not(o, collector); end
+  def visit_Arel_Nodes_NotEqual(o, collector); end
+  def visit_Arel_Nodes_NotIn(o, collector); end
+  def visit_Arel_Nodes_NotRegexp(o, collector); end
+  def visit_Arel_Nodes_Offset(o, collector); end
+  def visit_Arel_Nodes_On(o, collector); end
+  def visit_Arel_Nodes_OptimizerHints(o, collector); end
+  def visit_Arel_Nodes_Or(o, collector); end
+  def visit_Arel_Nodes_OuterJoin(o, collector); end
+  def visit_Arel_Nodes_Over(o, collector); end
+  def visit_Arel_Nodes_Preceding(o, collector); end
+  def visit_Arel_Nodes_Quoted(o, collector); end
+  def visit_Arel_Nodes_Range(o, collector); end
+  def visit_Arel_Nodes_Regexp(o, collector); end
+  def visit_Arel_Nodes_RightOuterJoin(o, collector); end
+  def visit_Arel_Nodes_Rows(o, collector); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+  def visit_Arel_Nodes_SelectOptions(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Nodes_SqlLiteral(o, collector); end
+  def visit_Arel_Nodes_StringJoin(o, collector); end
+  def visit_Arel_Nodes_Subtraction(o, collector); end
+  def visit_Arel_Nodes_Sum(o, collector); end
+  def visit_Arel_Nodes_TableAlias(o, collector); end
+  def visit_Arel_Nodes_True(o, collector); end
+  def visit_Arel_Nodes_UnaryOperation(o, collector); end
+  def visit_Arel_Nodes_Union(o, collector); end
+  def visit_Arel_Nodes_UnionAll(o, collector); end
+  def visit_Arel_Nodes_UnqualifiedColumn(o, collector); end
+  def visit_Arel_Nodes_UpdateStatement(o, collector); end
+  def visit_Arel_Nodes_ValuesList(o, collector); end
+  def visit_Arel_Nodes_When(o, collector); end
+  def visit_Arel_Nodes_Window(o, collector); end
+  def visit_Arel_Nodes_With(o, collector); end
+  def visit_Arel_Nodes_WithRecursive(o, collector); end
+  def visit_Arel_SelectManager(o, collector); end
+  def visit_Arel_Table(o, collector); end
+  def visit_Array(o, collector); end
+  def visit_BigDecimal(o, collector); end
+  def visit_Class(o, collector); end
+  def visit_Date(o, collector); end
+  def visit_DateTime(o, collector); end
+  def visit_FalseClass(o, collector); end
+  def visit_Float(o, collector); end
+  def visit_Hash(o, collector); end
+  def visit_Integer(o, collector); end
+  def visit_NilClass(o, collector); end
+  def visit_Set(o, collector); end
+  def visit_String(o, collector); end
+  def visit_Symbol(o, collector); end
+  def visit_Time(o, collector); end
+  def visit_TrueClass(o, collector); end
+end
+class Arel::Visitors::SQLite < Arel::Visitors::ToSql
+  def visit_Arel_Nodes_False(o, collector); end
+  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_Lock(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Nodes_True(o, collector); end
+end
+class Arel::Visitors::PostgreSQL < Arel::Visitors::ToSql
+  def grouping_array_or_grouping_element(o, collector); end
+  def grouping_parentheses(o, collector); end
+  def visit_Arel_Nodes_BindParam(o, collector); end
+  def visit_Arel_Nodes_Cube(o, collector); end
+  def visit_Arel_Nodes_DistinctOn(o, collector); end
+  def visit_Arel_Nodes_DoesNotMatch(o, collector); end
+  def visit_Arel_Nodes_GroupingElement(o, collector); end
+  def visit_Arel_Nodes_GroupingSet(o, collector); end
+  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_Lateral(o, collector); end
+  def visit_Arel_Nodes_Matches(o, collector); end
+  def visit_Arel_Nodes_NotRegexp(o, collector); end
+  def visit_Arel_Nodes_Regexp(o, collector); end
+  def visit_Arel_Nodes_RollUp(o, collector); end
+end
+class Arel::Visitors::MySQL < Arel::Visitors::ToSql
+  def build_subselect(key, o); end
+  def prepare_delete_statement(o); end
+  def prepare_update_statement(o); end
+  def visit_Arel_Nodes_Bin(o, collector); end
+  def visit_Arel_Nodes_Concat(o, collector); end
+  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Nodes_UnqualifiedColumn(o, collector); end
+end
+class Arel::Visitors::MSSQL < Arel::Visitors::ToSql
+  def collect_optimizer_hints(o, collector); end
+  def determine_order_by(orders, x); end
+  def find_left_table_pk(o); end
+  def find_primary_key(o); end
+  def get_offset_limit_clause(o); end
+  def initialize(*arg0); end
+  def row_num_literal(order_by); end
+  def select_count?(x); end
+  def visit_Arel_Nodes_DeleteStatement(o, collector); end
+  def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
+  def visit_Arel_Nodes_OptimizerHints(o, collector); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Visitors_MSSQL_RowNumber(o, collector); end
+end
+class Arel::Visitors::MSSQL::RowNumber < Struct
+  def children; end
+  def children=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Arel::Visitors::Oracle < Arel::Visitors::ToSql
+  def is_distinct_from(o, collector); end
+  def order_hacks(o); end
+  def split_order_string(string); end
+  def visit_Arel_Nodes_BindParam(o, collector); end
+  def visit_Arel_Nodes_Except(o, collector); end
+  def visit_Arel_Nodes_Limit(o, collector); end
+  def visit_Arel_Nodes_Offset(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Nodes_UpdateStatement(o, collector); end
+end
+class Arel::Visitors::Oracle12 < Arel::Visitors::ToSql
+  def is_distinct_from(o, collector); end
+  def visit_Arel_Nodes_BindParam(o, collector); end
+  def visit_Arel_Nodes_Except(o, collector); end
+  def visit_Arel_Nodes_Limit(o, collector); end
+  def visit_Arel_Nodes_Offset(o, collector); end
+  def visit_Arel_Nodes_SelectOptions(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+  def visit_Arel_Nodes_UpdateStatement(o, collector); end
+end
+class Arel::Visitors::WhereSql < Arel::Visitors::ToSql
+  def initialize(inner_visitor, *args, &block); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+end
+class Arel::Visitors::Dot < Arel::Visitors::Visitor
+  def accept(object, collector); end
+  def binary(o); end
+  def edge(name); end
+  def extract(o); end
+  def function(o); end
+  def initialize; end
+  def named_window(o); end
+  def nary(o); end
+  def quote(string); end
+  def to_dot; end
+  def unary(o); end
+  def visit(o); end
+  def visit_Arel_Attribute(o); end
+  def visit_Arel_Attributes_Attribute(o); end
+  def visit_Arel_Attributes_Boolean(o); end
+  def visit_Arel_Attributes_Float(o); end
+  def visit_Arel_Attributes_Integer(o); end
+  def visit_Arel_Attributes_String(o); end
+  def visit_Arel_Attributes_Time(o); end
+  def visit_Arel_Nodes_And(o); end
+  def visit_Arel_Nodes_As(o); end
+  def visit_Arel_Nodes_Assignment(o); end
+  def visit_Arel_Nodes_Avg(o); end
+  def visit_Arel_Nodes_Between(o); end
+  def visit_Arel_Nodes_BindParam(o); end
+  def visit_Arel_Nodes_Casted(o); end
+  def visit_Arel_Nodes_Comment(o); end
+  def visit_Arel_Nodes_Concat(o); end
+  def visit_Arel_Nodes_Count(o); end
+  def visit_Arel_Nodes_Cube(o); end
+  def visit_Arel_Nodes_DeleteStatement(o); end
+  def visit_Arel_Nodes_DoesNotMatch(o); end
+  def visit_Arel_Nodes_Equality(o); end
+  def visit_Arel_Nodes_Exists(o); end
+  def visit_Arel_Nodes_Extract(o); end
+  def visit_Arel_Nodes_Following(o); end
+  def visit_Arel_Nodes_FullOuterJoin(o); end
+  def visit_Arel_Nodes_GreaterThan(o); end
+  def visit_Arel_Nodes_GreaterThanOrEqual(o); end
+  def visit_Arel_Nodes_Group(o); end
+  def visit_Arel_Nodes_Grouping(o); end
+  def visit_Arel_Nodes_GroupingElement(o); end
+  def visit_Arel_Nodes_GroupingSet(o); end
+  def visit_Arel_Nodes_Having(o); end
+  def visit_Arel_Nodes_In(o); end
+  def visit_Arel_Nodes_InnerJoin(o); end
+  def visit_Arel_Nodes_InsertStatement(o); end
+  def visit_Arel_Nodes_IsDistinctFrom(o); end
+  def visit_Arel_Nodes_IsNotDistinctFrom(o); end
+  def visit_Arel_Nodes_JoinSource(o); end
+  def visit_Arel_Nodes_LessThan(o); end
+  def visit_Arel_Nodes_LessThanOrEqual(o); end
+  def visit_Arel_Nodes_Limit(o); end
+  def visit_Arel_Nodes_Matches(o); end
+  def visit_Arel_Nodes_Max(o); end
+  def visit_Arel_Nodes_Min(o); end
+  def visit_Arel_Nodes_NamedFunction(o); end
+  def visit_Arel_Nodes_NamedWindow(o); end
+  def visit_Arel_Nodes_Not(o); end
+  def visit_Arel_Nodes_NotEqual(o); end
+  def visit_Arel_Nodes_NotIn(o); end
+  def visit_Arel_Nodes_Offset(o); end
+  def visit_Arel_Nodes_On(o); end
+  def visit_Arel_Nodes_OptimizerHints(o); end
+  def visit_Arel_Nodes_Or(o); end
+  def visit_Arel_Nodes_Ordering(o); end
+  def visit_Arel_Nodes_OuterJoin(o); end
+  def visit_Arel_Nodes_Over(o); end
+  def visit_Arel_Nodes_Preceding(o); end
+  def visit_Arel_Nodes_Range(o); end
+  def visit_Arel_Nodes_RightOuterJoin(o); end
+  def visit_Arel_Nodes_RollUp(o); end
+  def visit_Arel_Nodes_Rows(o); end
+  def visit_Arel_Nodes_SelectCore(o); end
+  def visit_Arel_Nodes_SelectStatement(o); end
+  def visit_Arel_Nodes_SqlLiteral(o); end
+  def visit_Arel_Nodes_StringJoin(o); end
+  def visit_Arel_Nodes_Sum(o); end
+  def visit_Arel_Nodes_TableAlias(o); end
+  def visit_Arel_Nodes_UnqualifiedColumn(o); end
+  def visit_Arel_Nodes_UpdateStatement(o); end
+  def visit_Arel_Nodes_ValuesList(o); end
+  def visit_Arel_Nodes_Window(o); end
+  def visit_Arel_Table(o); end
+  def visit_Array(o); end
+  def visit_BigDecimal(o); end
+  def visit_Date(o); end
+  def visit_DateTime(o); end
+  def visit_FalseClass(o); end
+  def visit_Float(o); end
+  def visit_Hash(o); end
+  def visit_Integer(o); end
+  def visit_NilClass(o); end
+  def visit_Set(o); end
+  def visit_String(o); end
+  def visit_Symbol(o); end
+  def visit_Time(o); end
+  def visit_TrueClass(o); end
+  def visit_edge(o, method); end
+  def window(o); end
+  def with_node(node); end
+end
+class Arel::Visitors::Dot::Node
+  def fields; end
+  def fields=(arg0); end
+  def id; end
+  def id=(arg0); end
+  def initialize(name, id, fields = nil); end
+  def name; end
+  def name=(arg0); end
+end
+class Anonymous_Struct_5 < Struct
+  def from; end
+  def from=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def to; end
+  def to=(_); end
+end
+class Arel::Visitors::Dot::Edge < Anonymous_Struct_5
+end
+class Arel::Visitors::IBM_DB < Arel::Visitors::ToSql
+  def collect_optimizer_hints(o, collector); end
+  def is_distinct_from(o, collector); end
+  def visit_Arel_Nodes_Limit(o, collector); end
+  def visit_Arel_Nodes_OptimizerHints(o, collector); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+end
+class Arel::Visitors::Informix < Arel::Visitors::ToSql
+  def visit_Arel_Nodes_Limit(o, collector); end
+  def visit_Arel_Nodes_Offset(o, collector); end
+  def visit_Arel_Nodes_OptimizerHints(o, collector); end
+  def visit_Arel_Nodes_SelectCore(o, collector); end
+  def visit_Arel_Nodes_SelectStatement(o, collector); end
+end
+module Arel::Collectors
+end
+class Arel::Collectors::PlainString
+  def <<(str); end
+  def initialize; end
+  def value; end
+end
+class Arel::Collectors::SQLString < Arel::Collectors::PlainString
+  def add_bind(bind); end
+  def initialize(*arg0); end
+end
+class Arel::TreeManager
+  def ast; end
+  def initialize; end
+  def initialize_copy(other); end
+  def to_dot; end
+  def to_sql(engine = nil); end
+  def where(expr); end
+  include Arel::FactoryMethods
+end
+module Arel::TreeManager::StatementMethods
+  def key; end
+  def key=(key); end
+  def offset(offset); end
+  def order(*expr); end
+  def take(limit); end
+  def where(expr); end
+  def wheres=(exprs); end
+end
+class Arel::InsertManager < Arel::TreeManager
+  def columns; end
+  def create_values(values); end
+  def create_values_list(rows); end
+  def initialize; end
+  def insert(fields); end
+  def into(table); end
+  def select(select); end
+  def values=(val); end
+end
+class Arel::SelectManager < Arel::TreeManager
+  def as(other); end
+  def collapse(exprs); end
+  def comment(*values); end
+  def constraints; end
+  def distinct(value = nil); end
+  def distinct_on(value); end
+  def except(other); end
+  def exists; end
+  def from(table); end
+  def froms; end
+  def group(*columns); end
+  def having(expr); end
+  def initialize(table = nil); end
+  def initialize_copy(other); end
+  def intersect(other); end
+  def join(relation, klass = nil); end
+  def join_sources; end
+  def lateral(table_name = nil); end
+  def limit; end
+  def limit=(limit); end
+  def lock(locking = nil); end
+  def locked; end
+  def minus(other); end
+  def offset; end
+  def offset=(amount); end
+  def on(*exprs); end
+  def optimizer_hints(*hints); end
+  def order(*expr); end
+  def orders; end
+  def outer_join(relation); end
+  def project(*projections); end
+  def projections; end
+  def projections=(projections); end
+  def skip(amount); end
+  def source; end
+  def take(limit); end
+  def taken; end
+  def union(operation, other = nil); end
+  def where_sql(engine = nil); end
+  def window(name); end
+  def with(*subqueries); end
+  include Arel::Crud
+end
+class Arel::UpdateManager < Arel::TreeManager
+  def initialize; end
+  def set(values); end
+  def table(table); end
+  include Arel::TreeManager::StatementMethods
+end
+class Arel::DeleteManager < Arel::TreeManager
+  def from(relation); end
+  def initialize; end
+  include Arel::TreeManager::StatementMethods
+end
+module Arel::Nodes
+  def self.build_quoted(other, attribute = nil); end
+end
+class Arel::Nodes::Node
+  def and(right); end
+  def each(&block); end
+  def not; end
+  def or(right); end
+  def to_sql(engine = nil); end
+  include Arel::FactoryMethods
+  include Enumerable
+end
+class Arel::Nodes::NodeExpression < Arel::Nodes::Node
+  include Arel::AliasPredication
+  include Arel::Expressions
+  include Arel::Math
+  include Arel::OrderPredications
+  include Arel::Predications
+end
+class Arel::Nodes::SelectStatement < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def cores; end
+  def eql?(other); end
+  def hash; end
+  def initialize(cores = nil); end
+  def initialize_copy(other); end
+  def limit; end
+  def limit=(arg0); end
+  def lock; end
+  def lock=(arg0); end
+  def offset; end
+  def offset=(arg0); end
+  def orders; end
+  def orders=(arg0); end
+  def with; end
+  def with=(arg0); end
+end
+class Arel::Nodes::SelectCore < Arel::Nodes::Node
+  def ==(other); end
+  def comment; end
+  def comment=(arg0); end
+  def eql?(other); end
+  def from; end
+  def from=(value); end
+  def froms; end
+  def froms=(value); end
+  def groups; end
+  def groups=(arg0); end
+  def hash; end
+  def havings; end
+  def havings=(arg0); end
+  def initialize; end
+  def initialize_copy(other); end
+  def optimizer_hints; end
+  def optimizer_hints=(arg0); end
+  def projections; end
+  def projections=(arg0); end
+  def set_quantifier; end
+  def set_quantifier=(arg0); end
+  def source; end
+  def source=(arg0); end
+  def wheres; end
+  def wheres=(arg0); end
+  def windows; end
+  def windows=(arg0); end
+end
+class Arel::Nodes::InsertStatement < Arel::Nodes::Node
+  def ==(other); end
+  def columns; end
+  def columns=(arg0); end
+  def eql?(other); end
+  def hash; end
+  def initialize; end
+  def initialize_copy(other); end
+  def relation; end
+  def relation=(arg0); end
+  def select; end
+  def select=(arg0); end
+  def values; end
+  def values=(arg0); end
+end
+class Arel::Nodes::UpdateStatement < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize; end
+  def initialize_copy(other); end
+  def key; end
+  def key=(arg0); end
+  def limit; end
+  def limit=(arg0); end
+  def offset; end
+  def offset=(arg0); end
+  def orders; end
+  def orders=(arg0); end
+  def relation; end
+  def relation=(arg0); end
+  def values; end
+  def values=(arg0); end
+  def wheres; end
+  def wheres=(arg0); end
+end
+class Arel::Nodes::BindParam < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def infinite?; end
+  def initialize(value); end
+  def nil?; end
+  def unboundable?; end
+  def value; end
+end
+class Arel::Nodes::Distinct < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+end
+class Arel::Nodes::True < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+end
+class Arel::Nodes::False < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+end
+class Arel::Nodes::Unary < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def eql?(other); end
+  def expr; end
+  def expr=(arg0); end
+  def hash; end
+  def initialize(expr); end
+  def value; end
+end
+class Arel::Nodes::Bin < Arel::Nodes::Unary
+end
+class Arel::Nodes::Cube < Arel::Nodes::Unary
+end
+class Arel::Nodes::DistinctOn < Arel::Nodes::Unary
+end
+class Arel::Nodes::Group < Arel::Nodes::Unary
+end
+class Arel::Nodes::GroupingElement < Arel::Nodes::Unary
+end
+class Arel::Nodes::GroupingSet < Arel::Nodes::Unary
+end
+class Arel::Nodes::Lateral < Arel::Nodes::Unary
+end
+class Arel::Nodes::Limit < Arel::Nodes::Unary
+end
+class Arel::Nodes::Lock < Arel::Nodes::Unary
+end
+class Arel::Nodes::Not < Arel::Nodes::Unary
+end
+class Arel::Nodes::Offset < Arel::Nodes::Unary
+end
+class Arel::Nodes::On < Arel::Nodes::Unary
+end
+class Arel::Nodes::OptimizerHints < Arel::Nodes::Unary
+end
+class Arel::Nodes::Ordering < Arel::Nodes::Unary
+end
+class Arel::Nodes::RollUp < Arel::Nodes::Unary
+end
+class Arel::Nodes::Grouping < Arel::Nodes::Unary
+end
+class Arel::Nodes::Ascending < Arel::Nodes::Ordering
+  def ascending?; end
+  def descending?; end
+  def direction; end
+  def reverse; end
+end
+class Arel::Nodes::Descending < Arel::Nodes::Ordering
+  def ascending?; end
+  def descending?; end
+  def direction; end
+  def reverse; end
+end
+class Arel::Nodes::UnqualifiedColumn < Arel::Nodes::Unary
+  def attribute; end
+  def attribute=(arg0); end
+  def column; end
+  def name; end
+  def relation; end
+end
+class Arel::Nodes::With < Arel::Nodes::Unary
+  def children; end
+end
+class Arel::Nodes::WithRecursive < Arel::Nodes::With
+end
+class Arel::Nodes::Binary < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(left, right); end
+  def initialize_copy(other); end
+  def left; end
+  def left=(arg0); end
+  def right; end
+  def right=(arg0); end
+end
+class Arel::Nodes::As < Arel::Nodes::Binary
+end
+class Arel::Nodes::Assignment < Arel::Nodes::Binary
+end
+class Arel::Nodes::Between < Arel::Nodes::Binary
+end
+class Arel::Nodes::GreaterThan < Arel::Nodes::Binary
+end
+class Arel::Nodes::GreaterThanOrEqual < Arel::Nodes::Binary
+end
+class Arel::Nodes::Join < Arel::Nodes::Binary
+end
+class Arel::Nodes::LessThan < Arel::Nodes::Binary
+end
+class Arel::Nodes::LessThanOrEqual < Arel::Nodes::Binary
+end
+class Arel::Nodes::NotEqual < Arel::Nodes::Binary
+end
+class Arel::Nodes::NotIn < Arel::Nodes::Binary
+end
+class Arel::Nodes::Or < Arel::Nodes::Binary
+end
+class Arel::Nodes::Union < Arel::Nodes::Binary
+end
+class Arel::Nodes::UnionAll < Arel::Nodes::Binary
+end
+class Arel::Nodes::Intersect < Arel::Nodes::Binary
+end
+class Arel::Nodes::Except < Arel::Nodes::Binary
+end
+class Arel::Nodes::Equality < Arel::Nodes::Binary
+  def operand1; end
+  def operand2; end
+  def operator; end
+end
+class Arel::Nodes::IsDistinctFrom < Arel::Nodes::Equality
+end
+class Arel::Nodes::IsNotDistinctFrom < Arel::Nodes::Equality
+end
+class Arel::Nodes::In < Arel::Nodes::Equality
+end
+class Arel::Nodes::JoinSource < Arel::Nodes::Binary
+  def empty?; end
+  def initialize(single_source, joinop = nil); end
+end
+class Arel::Nodes::DeleteStatement < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(relation = nil, wheres = nil); end
+  def initialize_copy(other); end
+  def key; end
+  def key=(arg0); end
+  def left; end
+  def left=(arg0); end
+  def limit; end
+  def limit=(arg0); end
+  def offset; end
+  def offset=(arg0); end
+  def orders; end
+  def orders=(arg0); end
+  def relation; end
+  def relation=(arg0); end
+  def right; end
+  def right=(arg0); end
+  def wheres; end
+  def wheres=(arg0); end
+end
+class Arel::Nodes::TableAlias < Arel::Nodes::Binary
+  def [](name); end
+  def able_to_type_cast?; end
+  def name; end
+  def relation; end
+  def table_alias; end
+  def table_name; end
+  def type_cast_for_database(*args); end
+end
+class Arel::Nodes::InfixOperation < Arel::Nodes::Binary
+  def initialize(operator, left, right); end
+  def operator; end
+  include Arel::AliasPredication
+  include Arel::Expressions
+  include Arel::Math
+  include Arel::OrderPredications
+  include Arel::Predications
+end
+class Arel::Nodes::Multiplication < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::Division < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::Addition < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::Subtraction < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::Concat < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::BitwiseAnd < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::BitwiseOr < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::BitwiseXor < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::BitwiseShiftLeft < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::BitwiseShiftRight < Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+class Arel::Nodes::UnaryOperation < Arel::Nodes::Unary
+  def initialize(operator, operand); end
+  def operator; end
+end
+class Arel::Nodes::BitwiseNot < Arel::Nodes::UnaryOperation
+  def initialize(operand); end
+end
+class Arel::Nodes::Over < Arel::Nodes::Binary
+  def initialize(left, right = nil); end
+  def operator; end
+  include Arel::AliasPredication
+end
+class Arel::Nodes::Matches < Arel::Nodes::Binary
+  def case_sensitive; end
+  def case_sensitive=(arg0); end
+  def escape; end
+  def initialize(left, right, escape = nil, case_sensitive = nil); end
+end
+class Arel::Nodes::DoesNotMatch < Arel::Nodes::Matches
+end
+class Arel::Nodes::Regexp < Arel::Nodes::Binary
+  def case_sensitive; end
+  def case_sensitive=(arg0); end
+  def initialize(left, right, case_sensitive = nil); end
+end
+class Arel::Nodes::NotRegexp < Arel::Nodes::Regexp
+end
+class Arel::Nodes::And < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def children; end
+  def eql?(other); end
+  def hash; end
+  def initialize(children); end
+  def left; end
+  def right; end
+end
+class Arel::Nodes::Function < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def alias; end
+  def alias=(arg0); end
+  def as(aliaz); end
+  def distinct; end
+  def distinct=(arg0); end
+  def eql?(other); end
+  def expressions; end
+  def expressions=(arg0); end
+  def hash; end
+  def initialize(expr, aliaz = nil); end
+  include Arel::WindowPredications
+end
+class Arel::Nodes::Sum < Arel::Nodes::Function
+end
+class Arel::Nodes::Exists < Arel::Nodes::Function
+end
+class Arel::Nodes::Max < Arel::Nodes::Function
+end
+class Arel::Nodes::Min < Arel::Nodes::Function
+end
+class Arel::Nodes::Avg < Arel::Nodes::Function
+end
+class Arel::Nodes::Count < Arel::Nodes::Function
+  def initialize(expr, distinct = nil, aliaz = nil); end
+end
+class Arel::Nodes::Extract < Arel::Nodes::Unary
+  def ==(other); end
+  def eql?(other); end
+  def field; end
+  def field=(arg0); end
+  def hash; end
+  def initialize(expr, field); end
+end
+class Arel::Nodes::ValuesList < Arel::Nodes::Unary
+  def rows; end
+end
+class Arel::Nodes::NamedFunction < Arel::Nodes::Function
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(name, expr, aliaz = nil); end
+  def name; end
+  def name=(arg0); end
+end
+class Arel::Nodes::Window < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def frame(expr); end
+  def framing; end
+  def framing=(arg0); end
+  def hash; end
+  def initialize; end
+  def initialize_copy(other); end
+  def order(*expr); end
+  def orders; end
+  def orders=(arg0); end
+  def partition(*expr); end
+  def partitions; end
+  def partitions=(arg0); end
+  def range(expr = nil); end
+  def rows(expr = nil); end
+end
+class Arel::Nodes::NamedWindow < Arel::Nodes::Window
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(name); end
+  def initialize_copy(other); end
+  def name; end
+  def name=(arg0); end
+end
+class Arel::Nodes::Rows < Arel::Nodes::Unary
+  def initialize(expr = nil); end
+end
+class Arel::Nodes::Range < Arel::Nodes::Unary
+  def initialize(expr = nil); end
+end
+class Arel::Nodes::CurrentRow < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+end
+class Arel::Nodes::Preceding < Arel::Nodes::Unary
+  def initialize(expr = nil); end
+end
+class Arel::Nodes::Following < Arel::Nodes::Unary
+  def initialize(expr = nil); end
+end
+class Arel::Nodes::Case < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def case; end
+  def case=(arg0); end
+  def conditions; end
+  def conditions=(arg0); end
+  def default; end
+  def default=(arg0); end
+  def else(expression); end
+  def eql?(other); end
+  def hash; end
+  def initialize(expression = nil, default = nil); end
+  def initialize_copy(other); end
+  def then(expression); end
+  def when(condition, expression = nil); end
+end
+class Arel::Nodes::When < Arel::Nodes::Binary
+end
+class Arel::Nodes::Else < Arel::Nodes::Unary
+end
+class Arel::Nodes::FullOuterJoin < Arel::Nodes::Join
+end
+class Arel::Nodes::InnerJoin < Arel::Nodes::Join
+end
+class Arel::Nodes::OuterJoin < Arel::Nodes::Join
+end
+class Arel::Nodes::RightOuterJoin < Arel::Nodes::Join
+end
+class Arel::Nodes::StringJoin < Arel::Nodes::Join
+  def initialize(left, right = nil); end
+end
+class Arel::Nodes::Comment < Arel::Nodes::Node
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(values); end
+  def initialize_copy(other); end
+  def values; end
+end
+class Arel::Nodes::SqlLiteral < String
+  def encode_with(coder); end
+  include Arel::AliasPredication
+  include Arel::Expressions
+  include Arel::OrderPredications
+  include Arel::Predications
+end
+class Arel::Nodes::Casted < Arel::Nodes::NodeExpression
+  def ==(other); end
+  def attribute; end
+  def eql?(other); end
+  def hash; end
+  def initialize(val, attribute); end
+  def nil?; end
+  def val; end
+end
+class Arel::Nodes::Quoted < Arel::Nodes::Unary
+  def infinite?; end
+  def nil?; end
+  def val; end
+end
+module ActiveRecord
+  def self.eager_load!; end
+  def self.gem_version; end
+  def self.version; end
+  extend ActiveSupport::Autoload
+end
+module ActiveRecord::VERSION
+end
+module ActiveRecord::AttributeMethods
+  def [](attr_name); end
+  def []=(attr_name, value); end
+  def accessed_fields; end
+  def attribute_for_inspect(attr_name); end
+  def attribute_method?(attr_name); end
+  def attribute_names; end
+  def attribute_present?(attribute); end
+  def attributes; end
+  def attributes_for_create(attribute_names); end
+  def attributes_for_update(attribute_names); end
+  def attributes_with_values(attribute_names); end
+  def format_for_inspect(value); end
+  def has_attribute?(attr_name); end
+  def pk_attribute?(name); end
+  def readonly_attribute?(name); end
+  def respond_to?(name, include_private = nil); end
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+  include ActiveModel::AttributeMethods
+end
+class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < Module
+  def lock; end
+  def locked?; end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+  include Mutex_m
+end
+module ActiveRecord::AttributeMethods::ClassMethods
+  def attribute_method?(attribute); end
+  def attribute_names; end
+  def class_method_defined_within?(name, klass, superklass = nil); end
+  def column_for_attribute(name); end
+  def dangerous_attribute_method?(name); end
+  def dangerous_class_method?(method_name); end
+  def define_attribute_methods; end
+  def has_attribute?(attr_name); end
+  def inherited(child_class); end
+  def initialize_generated_modules; end
+  def instance_method_already_implemented?(method_name); end
+  def method_defined_within?(name, klass, superklass = nil); end
+  def undefine_attribute_methods; end
+end
+module ActiveRecord::ConnectionAdapters
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Autoload
+end
+module ActiveRecord::ConnectionAdapters::DetermineIfPreparableVisitor
+  def accept(object, collector); end
+  def preparable; end
+  def preparable=(arg0); end
+  def visit_Arel_Nodes_In(o, collector); end
+  def visit_Arel_Nodes_NotIn(o, collector); end
+  def visit_Arel_Nodes_SqlLiteral(o, collector); end
+end
+class ActiveRecord::ConnectionAdapters::SchemaCache
+  def add(table_name); end
+  def clear!; end
+  def clear_data_source_cache!(name); end
+  def columns(table_name); end
+  def columns_hash(table_name); end
+  def columns_hash?(table_name); end
+  def connection; end
+  def connection=(arg0); end
+  def data_source_exists?(name); end
+  def data_sources(name); end
+  def database_version; end
+  def encode_with(coder); end
+  def indexes(table_name); end
+  def init_with(coder); end
+  def initialize(conn); end
+  def initialize_dup(other); end
+  def marshal_dump; end
+  def marshal_load(array); end
+  def prepare_data_sources; end
+  def primary_keys(table_name); end
+  def size; end
+  def version; end
+end
+class ActiveRecord::ConnectionAdapters::SqlTypeMetadata
+  def ==(other); end
+  def eql?(other); end
+  def hash; end
+  def initialize(sql_type: nil, type: nil, limit: nil, precision: nil, scale: nil); end
+  def limit; end
+  def precision; end
+  def scale; end
+  def sql_type; end
+  def type; end
+end
+class ActiveRecord::SchemaDumper
+  def define_params; end
+  def dump(stream); end
+  def extensions(stream); end
+  def fk_ignore_pattern; end
+  def fk_ignore_pattern=(obj); end
+  def foreign_keys(table, stream); end
+  def format_colspec(colspec); end
+  def format_index_parts(options); end
+  def format_options(options); end
+  def formatted_version; end
+  def header(stream); end
+  def ignore_tables; end
+  def ignore_tables=(obj); end
+  def ignored?(table_name); end
+  def index_parts(index); end
+  def indexes(table, stream); end
+  def indexes_in_create(table, stream); end
+  def initialize(connection, options = nil); end
+  def remove_prefix_and_suffix(table); end
+  def self.dump(connection = nil, stream = nil, config = nil); end
+  def self.fk_ignore_pattern; end
+  def self.fk_ignore_pattern=(obj); end
+  def self.generate_options(config); end
+  def self.ignore_tables; end
+  def self.ignore_tables=(obj); end
+  def self.new(*arg0); end
+  def table(table, stream); end
+  def table_name; end
+  def table_name=(arg0); end
+  def tables(stream); end
+  def trailer(stream); end
+end
+class ActiveRecord::ConnectionAdapters::SchemaDumper < ActiveRecord::SchemaDumper
+  def column_spec(column); end
+  def column_spec_for_primary_key(column); end
+  def default_primary_key?(column); end
+  def explicit_primary_key_default?(column); end
+  def prepare_column_options(column); end
+  def schema_collation(column); end
+  def schema_default(column); end
+  def schema_expression(column); end
+  def schema_limit(column); end
+  def schema_precision(column); end
+  def schema_scale(column); end
+  def schema_type(column); end
+  def schema_type_with_virtual(column); end
+  def self.create(connection, options); end
+end
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  def __callbacks; end
+  def __callbacks?; end
+  def _checkin_callbacks; end
+  def _checkout_callbacks; end
+  def _run_checkin_callbacks(&block); end
+  def _run_checkout_callbacks(&block); end
+  def active?; end
+  def adapter_name; end
+  def advisory_locks_enabled?; end
+  def arel_visitor; end
+  def build_insert_sql(insert); end
+  def build_statement_pool; end
+  def can_perform_case_insensitive_comparison_for?(column); end
+  def case_insensitive_comparison(attribute, value); end
+  def case_sensitive_comparison(attribute, value); end
+  def check_version; end
+  def clear_cache!; end
+  def close; end
+  def collector; end
+  def column_for(table_name, column_name); end
+  def column_for_attribute(attribute); end
+  def column_name_for_operation(operation, node); end
+  def database_version; end
+  def default_index_type?(index); end
+  def default_uniqueness_comparison(attribute, value, klass); end
+  def delete(*arg0); end
+  def disable_extension(name); end
+  def disable_referential_integrity; end
+  def discard!; end
+  def disconnect!; end
+  def enable_extension(name); end
+  def exec_insert_all(*arg0); end
+  def expire; end
+  def extensions; end
+  def extract_limit(sql_type); end
+  def extract_precision(sql_type); end
+  def extract_scale(sql_type); end
+  def get_advisory_lock(lock_id); end
+  def get_database_version; end
+  def in_use?; end
+  def index_algorithms; end
+  def initialize(connection, logger = nil, config = nil); end
+  def initialize_type_map(m = nil); end
+  def insert(*arg0); end
+  def lease; end
+  def lock; end
+  def log(sql, name = nil, binds = nil, type_casted_binds = nil, statement_name = nil); end
+  def logger; end
+  def migration_context; end
+  def migrations_paths; end
+  def owner; end
+  def pool; end
+  def pool=(arg0); end
+  def prefetch_primary_key?(table_name = nil); end
+  def prepared_statements; end
+  def prepared_statements_disabled_cache; end
+  def preventing_writes?; end
+  def raw_connection; end
+  def reconnect!; end
+  def register_class_with_limit(mapping, key, klass); end
+  def register_class_with_precision(mapping, key, klass); end
+  def release_advisory_lock(lock_id); end
+  def reload_type_map; end
+  def replica?; end
+  def requires_reloading?; end
+  def reset!; end
+  def rollback_db_transaction(*arg0); end
+  def rollback_to_savepoint(*arg0); end
+  def schema_cache; end
+  def schema_cache=(cache); end
+  def schema_migration; end
+  def seconds_idle; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._checkin_callbacks; end
+  def self._checkin_callbacks=(value); end
+  def self._checkout_callbacks; end
+  def self._checkout_callbacks=(value); end
+  def self.build_read_query_regexp(*parts); end
+  def self.database_exists?(config); end
+  def self.quoted_column_names; end
+  def self.quoted_table_names; end
+  def self.type_cast_config_to_boolean(config); end
+  def self.type_cast_config_to_integer(config); end
+  def steal!; end
+  def supports_advisory_locks?; end
+  def supports_bulk_alter?; end
+  def supports_comments?; end
+  def supports_comments_in_create?; end
+  def supports_common_table_expressions?; end
+  def supports_datetime_with_precision?; end
+  def supports_ddl_transactions?; end
+  def supports_explain?; end
+  def supports_expression_index?; end
+  def supports_extensions?; end
+  def supports_foreign_keys?; end
+  def supports_foreign_keys_in_create?(*args, &block); end
+  def supports_foreign_tables?; end
+  def supports_index_sort_order?; end
+  def supports_indexes_in_create?; end
+  def supports_insert_conflict_target?; end
+  def supports_insert_on_duplicate_skip?; end
+  def supports_insert_on_duplicate_update?; end
+  def supports_insert_returning?; end
+  def supports_json?; end
+  def supports_lazy_transactions?; end
+  def supports_materialized_views?; end
+  def supports_multi_insert?(*args, &block); end
+  def supports_optimizer_hints?; end
+  def supports_partial_index?; end
+  def supports_partitioned_indexes?; end
+  def supports_savepoints?; end
+  def supports_transaction_isolation?; end
+  def supports_validate_constraints?; end
+  def supports_views?; end
+  def supports_virtual_columns?; end
+  def translate_exception(exception, message:, sql:, binds:); end
+  def translate_exception_class(e, sql, binds); end
+  def truncate(*arg0); end
+  def truncate_tables(*arg0); end
+  def type_map; end
+  def unprepared_statement; end
+  def update(*arg0); end
+  def valid_type?(type); end
+  def verify!; end
+  def visitor; end
+  def without_prepared_statement?(binds); end
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  include ActiveRecord::ConnectionAdapters::DatabaseLimits
+  include ActiveRecord::ConnectionAdapters::QueryCache
+  include ActiveRecord::ConnectionAdapters::Quoting
+  include ActiveRecord::ConnectionAdapters::Savepoints
+  include ActiveSupport::Callbacks
+end
+class ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+  def accept(o); end
+  def action_sql(action, dependency); end
+  def add_column_options!(sql, options); end
+  def add_table_options!(create_sql, options); end
+  def column_options(o); end
+  def foreign_key_in_create(from_table, to_table, options); end
+  def foreign_key_options(*args, &block); end
+  def initialize(conn); end
+  def options_include_default?(*args, &block); end
+  def quote_column_name(*args, &block); end
+  def quote_default_expression(*args, &block); end
+  def quote_table_name(*args, &block); end
+  def supports_foreign_keys?(*args, &block); end
+  def supports_indexes_in_create?(*args, &block); end
+  def table_modifier_in_create(o); end
+  def table_options(o); end
+  def to_sql(sql); end
+  def type_to_sql(*args, &block); end
+  def visit_AddColumnDefinition(o); end
+  def visit_AddForeignKey(o); end
+  def visit_AlterTable(o); end
+  def visit_ColumnDefinition(o); end
+  def visit_DropForeignKey(name); end
+  def visit_ForeignKeyDefinition(o); end
+  def visit_PrimaryKeyDefinition(o); end
+  def visit_TableDefinition(o); end
+end
+class Arel::Collectors::Bind
+  def <<(str); end
+  def add_bind(bind); end
+  def initialize; end
+  def value; end
+end
+class Arel::Collectors::Composite
+  def <<(str); end
+  def add_bind(bind, &block); end
+  def initialize(left, right); end
+  def left; end
+  def right; end
+  def value; end
+end
+class Arel::Collectors::SubstituteBinds
+  def <<(str); end
+  def add_bind(bind); end
+  def delegate; end
+  def initialize(quoter, delegate_collector); end
+  def quoter; end
+  def value; end
+end
+module ActiveRecord::ConnectionAdapters::Quoting
+  def _quote(value); end
+  def _type_cast(value); end
+  def column_name_matcher; end
+  def column_name_with_order_matcher; end
+  def id_value_for_database(value); end
+  def lookup_cast_type(sql_type); end
+  def lookup_cast_type_from_column(column); end
+  def quote(value); end
+  def quote_column_name(column_name); end
+  def quote_default_expression(value, column); end
+  def quote_string(s); end
+  def quote_table_name(table_name); end
+  def quote_table_name_for_assignment(table, attr); end
+  def quoted_binary(value); end
+  def quoted_date(value); end
+  def quoted_false; end
+  def quoted_time(value); end
+  def quoted_true; end
+  def sanitize_as_sql_comment(value); end
+  def type_cast(value, column = nil); end
+  def type_cast_from_column(column, value); end
+  def type_casted_binds(binds); end
+  def unquoted_false; end
+  def unquoted_true; end
+end
+module ActiveRecord::ConnectionAdapters::DatabaseStatements
+  def add_transaction_record(record); end
+  def arel_from_relation(relation); end
+  def begin_db_transaction; end
+  def begin_isolated_db_transaction(isolation); end
+  def begin_transaction(*args, &block); end
+  def build_fixture_sql(fixtures, table_name); end
+  def build_fixture_statements(fixture_set); end
+  def build_truncate_statement(table_name); end
+  def build_truncate_statements(table_names); end
+  def cacheable_query(klass, arel); end
+  def combine_multi_statements(total_sql); end
+  def commit_db_transaction; end
+  def commit_transaction(*args, &block); end
+  def create(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = nil); end
+  def current_transaction(*args, &block); end
+  def default_insert_value(column); end
+  def default_sequence_name(table, column); end
+  def delete(arel, name = nil, binds = nil); end
+  def disable_lazy_transactions!(*args, &block); end
+  def empty_insert_statement_value(primary_key = nil); end
+  def enable_lazy_transactions!(*args, &block); end
+  def exec_delete(sql, name = nil, binds = nil); end
+  def exec_insert(sql, name = nil, binds = nil, pk = nil, sequence_name = nil); end
+  def exec_insert_all(sql, name); end
+  def exec_query(sql, name = nil, binds = nil, prepare: nil); end
+  def exec_rollback_db_transaction; end
+  def exec_update(sql, name = nil, binds = nil); end
+  def execute(sql, name = nil); end
+  def execute_batch(statements, name = nil); end
+  def initialize; end
+  def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = nil); end
+  def insert_fixture(fixture, table_name); end
+  def insert_fixtures_set(fixture_set, tables_to_delete = nil); end
+  def last_inserted_id(result); end
+  def materialize_transactions(*args, &block); end
+  def open_transactions(*args, &block); end
+  def query(sql, name = nil); end
+  def query_value(sql, name = nil); end
+  def query_values(sql, name = nil); end
+  def reset_sequence!(table, column, sequence = nil); end
+  def reset_transaction; end
+  def rollback_db_transaction; end
+  def rollback_to_savepoint(name = nil); end
+  def rollback_transaction(*args, &block); end
+  def sanitize_limit(limit); end
+  def select(sql, name = nil, binds = nil); end
+  def select_all(arel, name = nil, binds = nil, preparable: nil); end
+  def select_one(arel, name = nil, binds = nil); end
+  def select_prepared(sql, name = nil, binds = nil); end
+  def select_rows(arel, name = nil, binds = nil); end
+  def select_value(arel, name = nil, binds = nil); end
+  def select_values(arel, name = nil, binds = nil); end
+  def single_value_from_rows(rows); end
+  def sql_for_insert(sql, pk, binds); end
+  def to_sql(arel_or_sql_string, binds = nil); end
+  def to_sql_and_binds(arel_or_sql_string, binds = nil); end
+  def transaction(requires_new: nil, isolation: nil, joinable: nil); end
+  def transaction_isolation_levels; end
+  def transaction_manager; end
+  def transaction_open?; end
+  def transaction_state; end
+  def truncate(table_name, name = nil); end
+  def truncate_tables(*table_names); end
+  def update(arel, name = nil, binds = nil); end
+  def with_multi_statements; end
+  def with_yaml_fallback(value); end
+  def within_new_transaction(*args, &block); end
+  def write_query?(sql); end
+end
+class ActiveRecord::ActiveRecordError < StandardError
+end
+class ActiveRecord::SubclassNotFound < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::AssociationTypeMismatch < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::SerializationTypeMismatch < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::AdapterNotSpecified < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::AdapterNotFound < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::ConnectionNotEstablished < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::ReadOnlyError < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::RecordNotFound < ActiveRecord::ActiveRecordError
+  def id; end
+  def initialize(message = nil, model = nil, primary_key = nil, id = nil); end
+  def model; end
+  def primary_key; end
+end
+class ActiveRecord::RecordNotSaved < ActiveRecord::ActiveRecordError
+  def initialize(message = nil, record = nil); end
+  def record; end
+end
+class ActiveRecord::RecordNotDestroyed < ActiveRecord::ActiveRecordError
+  def initialize(message = nil, record = nil); end
+  def record; end
+end
+class ActiveRecord::StatementInvalid < ActiveRecord::ActiveRecordError
+  def binds; end
+  def initialize(message = nil, sql: nil, binds: nil); end
+  def sql; end
+end
+class ActiveRecord::WrappedDatabaseException < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::RecordNotUnique < ActiveRecord::WrappedDatabaseException
+end
+class ActiveRecord::InvalidForeignKey < ActiveRecord::WrappedDatabaseException
+end
+class ActiveRecord::MismatchedForeignKey < ActiveRecord::StatementInvalid
+  def initialize(message: nil, sql: nil, binds: nil, table: nil, foreign_key: nil, target_table: nil, primary_key: nil, primary_key_column: nil); end
+end
+class ActiveRecord::NotNullViolation < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::ValueTooLong < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::RangeError < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::PreparedStatementInvalid < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::NoDatabaseError < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::PreparedStatementCacheExpired < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::StaleObjectError < ActiveRecord::ActiveRecordError
+  def attempted_action; end
+  def initialize(record = nil, attempted_action = nil); end
+  def record; end
+end
+class ActiveRecord::ConfigurationError < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::ReadOnlyRecord < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::Rollback < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::DangerousAttributeError < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::AttributeAssignmentError < ActiveRecord::ActiveRecordError
+  def attribute; end
+  def exception; end
+  def initialize(message = nil, exception = nil, attribute = nil); end
+end
+class ActiveRecord::MultiparameterAssignmentErrors < ActiveRecord::ActiveRecordError
+  def errors; end
+  def initialize(errors = nil); end
+end
+class ActiveRecord::UnknownPrimaryKey < ActiveRecord::ActiveRecordError
+  def initialize(model = nil, description = nil); end
+  def model; end
+end
+class ActiveRecord::ImmutableRelation < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::TransactionIsolationError < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::TransactionRollbackError < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::SerializationFailure < ActiveRecord::TransactionRollbackError
+end
+class ActiveRecord::Deadlocked < ActiveRecord::TransactionRollbackError
+end
+class ActiveRecord::IrreversibleOrderError < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::LockWaitTimeout < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::StatementTimeout < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::QueryCanceled < ActiveRecord::StatementInvalid
+end
+class ActiveRecord::UnknownAttributeReference < ActiveRecord::ActiveRecordError
+end
+class ActiveRecord::MigrationError < ActiveRecord::ActiveRecordError
+  def initialize(message = nil); end
+end
+class ActiveRecord::IrreversibleMigration < ActiveRecord::MigrationError
+end
+class ActiveRecord::DuplicateMigrationVersionError < ActiveRecord::MigrationError
+  def initialize(version = nil); end
+end
+class ActiveRecord::DuplicateMigrationNameError < ActiveRecord::MigrationError
+  def initialize(name = nil); end
+end
+class ActiveRecord::UnknownMigrationVersionError < ActiveRecord::MigrationError
+  def initialize(version = nil); end
+end
+class ActiveRecord::IllegalMigrationNameError < ActiveRecord::MigrationError
+  def initialize(name = nil); end
+end
+class ActiveRecord::PendingMigrationError < ActiveRecord::MigrationError
+  def _actions; end
+  def _actions=(val); end
+  def _actions?; end
+  def initialize(message = nil); end
+  def self._actions; end
+  def self._actions=(val); end
+  def self._actions?; end
+  extend ActiveSupport::ActionableError::ClassMethods
+  include ActiveSupport::ActionableError
+end
+class ActiveRecord::ConcurrentMigrationError < ActiveRecord::MigrationError
+  def initialize(message = nil); end
+end
+class ActiveRecord::NoEnvironmentInSchemaError < ActiveRecord::MigrationError
+  def initialize; end
+end
+class ActiveRecord::ProtectedEnvironmentError < ActiveRecord::ActiveRecordError
+  def initialize(env = nil); end
+end
+class ActiveRecord::EnvironmentMismatchError < ActiveRecord::ActiveRecordError
+  def initialize(current: nil, stored: nil); end
+end
+class ActiveRecord::Migration
+  def announce(message); end
+  def command_recorder; end
+  def connection; end
+  def copy(destination, sources, options = nil); end
+  def disable_ddl_transaction; end
+  def down; end
+  def exec_migration(conn, direction); end
+  def execute_block; end
+  def initialize(name = nil, version = nil); end
+  def method_missing(method, *arguments, &block); end
+  def migrate(direction); end
+  def name; end
+  def name=(arg0); end
+  def next_migration_number(number); end
+  def proper_table_name(name, options = nil); end
+  def reversible; end
+  def revert(*migration_classes); end
+  def reverting?; end
+  def run(*migration_classes); end
+  def say(message, subitem = nil); end
+  def say_with_time(message); end
+  def self.[](version); end
+  def self.check_pending!(connection = nil); end
+  def self.current_version; end
+  def self.delegate; end
+  def self.delegate=(arg0); end
+  def self.disable_ddl_transaction!; end
+  def self.disable_ddl_transaction; end
+  def self.disable_ddl_transaction=(arg0); end
+  def self.inherited(subclass); end
+  def self.load_schema_if_pending!; end
+  def self.maintain_test_schema!; end
+  def self.method_missing(name, *args, &block); end
+  def self.migrate(direction); end
+  def self.nearest_delegate; end
+  def self.verbose; end
+  def self.verbose=(obj); end
+  def suppress_messages; end
+  def table_name_options(config = nil); end
+  def up; end
+  def up_only; end
+  def verbose; end
+  def verbose=(obj); end
+  def version; end
+  def version=(arg0); end
+  def write(text = nil); end
+end
+class ActiveRecord::Migration::Current < ActiveRecord::Migration
+end
+class ActiveRecord::Migration::CheckPending
+  def call(env); end
+  def connection; end
+  def initialize(app); end
+end
+class ActiveRecord::Migration::ReversibleBlockHelper < Struct
+  def down; end
+  def reverting; end
+  def reverting=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def up; end
+end
+class ActiveRecord::MigrationProxy < Struct
+  def announce(*args, &block); end
+  def basename; end
+  def disable_ddl_transaction(*args, &block); end
+  def filename; end
+  def filename=(_); end
+  def initialize(name, version, filename, scope); end
+  def load_migration; end
+  def migrate(*args, &block); end
+  def migration; end
+  def mtime; end
+  def name; end
+  def name=(_); end
+  def scope; end
+  def scope=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def version; end
+  def version=(_); end
+  def write(*args, &block); end
+end
+class ActiveRecord::NullMigration < ActiveRecord::MigrationProxy
+  def initialize; end
+  def mtime; end
+end
+class ActiveRecord::MigrationContext
+  def any_migrations?; end
+  def current_environment; end
+  def current_version; end
+  def down(target_version = nil); end
+  def forward(steps = nil); end
+  def get_all_versions; end
+  def initialize(migrations_paths, schema_migration); end
+  def last_migration; end
+  def last_stored_environment; end
+  def migrate(target_version = nil, &block); end
+  def migration_files; end
+  def migrations; end
+  def migrations_paths; end
+  def migrations_status; end
+  def move(direction, steps); end
+  def needs_migration?; end
+  def open; end
+  def parse_migration_filename(filename); end
+  def protected_environment?; end
+  def rollback(steps = nil); end
+  def run(direction, target_version); end
+  def schema_migration; end
+  def up(target_version = nil); end
+end
+class ActiveRecord::Migrator
+  def current; end
+  def current_migration; end
+  def current_version; end
+  def ddl_transaction(migration); end
+  def down?; end
+  def execute_migration_in_transaction(migration, direction); end
+  def finish; end
+  def generate_migrator_advisory_lock_id; end
+  def initialize(direction, migrations, schema_migration, target_version = nil); end
+  def invalid_target?; end
+  def load_migrated; end
+  def migrate; end
+  def migrate_without_lock; end
+  def migrated; end
+  def migrations; end
+  def pending_migrations; end
+  def ran?(migration); end
+  def record_environment; end
+  def record_version_state_after_migrating(version); end
+  def run; end
+  def run_without_lock; end
+  def runnable; end
+  def self.current_version; end
+  def self.migrations_paths; end
+  def self.migrations_paths=(arg0); end
+  def start; end
+  def target; end
+  def up?; end
+  def use_advisory_lock?; end
+  def use_transaction?(migration); end
+  def validate(migrations); end
+  def with_advisory_lock; end
+end
+module ActiveRecord::Migration::JoinTable
+  def find_join_table_name(table_1, table_2, options = nil); end
+  def join_table_name(table_1, table_2); end
+end
+module ActiveRecord::ConnectionAdapters::SchemaStatements
+  def add_belongs_to(table_name, ref_name, **options); end
+  def add_column(table_name, column_name, type, **options); end
+  def add_column_for_alter(table_name, column_name, type, **options); end
+  def add_foreign_key(from_table, to_table, **options); end
+  def add_index(table_name, column_name, options = nil); end
+  def add_index_options(table_name, column_name, comment: nil, **options); end
+  def add_index_sort_order(quoted_columns, **options); end
+  def add_options_for_index_columns(quoted_columns, **options); end
+  def add_reference(table_name, ref_name, **options); end
+  def add_timestamps(table_name, **options); end
+  def add_timestamps_for_alter(table_name, **options); end
+  def assume_migrated_upto_version(version, migrations_paths = nil); end
+  def bulk_change_table(table_name, operations); end
+  def can_remove_index_by_name?(options); end
+  def change_column(table_name, column_name, type, options = nil); end
+  def change_column_comment(table_name, column_name, comment_or_changes); end
+  def change_column_default(table_name, column_name, default_or_changes); end
+  def change_column_null(table_name, column_name, null, default = nil); end
+  def change_table(table_name, **options); end
+  def change_table_comment(table_name, comment_or_changes); end
+  def column_exists?(table_name, column_name, type = nil, **options); end
+  def column_options_keys; end
+  def columns(table_name); end
+  def columns_for_distinct(columns, orders); end
+  def create_alter_table(name); end
+  def create_join_table(table_1, table_2, column_options: nil, **options); end
+  def create_schema_dumper(options); end
+  def create_table(table_name, **options); end
+  def create_table_definition(*args, **options); end
+  def data_source_exists?(name); end
+  def data_source_sql(name = nil, type: nil); end
+  def data_sources; end
+  def drop_join_table(table_1, table_2, **options); end
+  def drop_table(table_name, **options); end
+  def dump_schema_information; end
+  def extract_foreign_key_action(specifier); end
+  def extract_new_comment_value(default_or_changes); end
+  def extract_new_default_value(default_or_changes); end
+  def fetch_type_metadata(sql_type); end
+  def foreign_key_column_for(table_name); end
+  def foreign_key_exists?(from_table, to_table = nil, **options); end
+  def foreign_key_for!(from_table, to_table: nil, **options); end
+  def foreign_key_for(from_table, **options); end
+  def foreign_key_name(table_name, options); end
+  def foreign_key_options(from_table, to_table, options); end
+  def foreign_keys(table_name); end
+  def index_column_names(column_names); end
+  def index_exists?(table_name, column_name, options = nil); end
+  def index_name(table_name, options); end
+  def index_name_exists?(table_name, index_name); end
+  def index_name_for_remove(table_name, options = nil); end
+  def index_name_options(column_names); end
+  def indexes(table_name); end
+  def insert_versions_sql(versions); end
+  def internal_string_options_for_primary_key; end
+  def native_database_types; end
+  def options_for_index_columns(options); end
+  def options_include_default?(options); end
+  def primary_key(table_name); end
+  def quoted_columns_for_index(column_names, **options); end
+  def quoted_scope(name = nil, type: nil); end
+  def remove_belongs_to(table_name, ref_name, foreign_key: nil, polymorphic: nil, **options); end
+  def remove_column(table_name, column_name, type = nil, **options); end
+  def remove_column_for_alter(table_name, column_name, type = nil, **options); end
+  def remove_columns(table_name, *column_names); end
+  def remove_columns_for_alter(table_name, *column_names, **options); end
+  def remove_foreign_key(from_table, to_table = nil, **options); end
+  def remove_index(table_name, options = nil); end
+  def remove_reference(table_name, ref_name, foreign_key: nil, polymorphic: nil, **options); end
+  def remove_timestamps(table_name, **options); end
+  def remove_timestamps_for_alter(table_name, **options); end
+  def rename_column(table_name, column_name, new_column_name); end
+  def rename_column_indexes(table_name, column_name, new_column_name); end
+  def rename_index(table_name, old_name, new_name); end
+  def rename_table(table_name, new_name); end
+  def rename_table_indexes(table_name, new_name); end
+  def schema_creation; end
+  def strip_table_name_prefix_and_suffix(table_name); end
+  def table_alias_for(table_name); end
+  def table_comment(table_name); end
+  def table_exists?(table_name); end
+  def table_options(table_name); end
+  def tables; end
+  def type_to_sql(type, limit: nil, precision: nil, scale: nil, **arg4); end
+  def update_table_definition(table_name, base); end
+  def validate_index_length!(table_name, new_name, internal = nil); end
+  def view_exists?(view_name); end
+  def views; end
+  include ActiveRecord::Migration::JoinTable
+end
+module ActiveRecord::ConnectionAdapters::DatabaseLimits
+  def allowed_index_name_length; end
+  def bind_params_length; end
+  def column_name_length(*args, &block); end
+  def columns_per_multicolumn_index(*args, &block); end
+  def columns_per_table(*args, &block); end
+  def in_clause_length; end
+  def index_name_length; end
+  def indexes_per_table(*args, &block); end
+  def joins_per_query(*args, &block); end
+  def max_identifier_length; end
+  def sql_query_length(*args, &block); end
+  def table_alias_length; end
+  def table_name_length(*args, &block); end
+end
+module ActiveRecord::ConnectionAdapters::QueryCache
+  def cache; end
+  def cache_notification_info(sql, name, binds); end
+  def cache_sql(sql, name, binds); end
+  def clear_query_cache; end
+  def configure_query_cache!; end
+  def disable_query_cache!; end
+  def enable_query_cache!; end
+  def initialize(*arg0); end
+  def locked?(arel); end
+  def query_cache; end
+  def query_cache_enabled; end
+  def select_all(arel, name = nil, binds = nil, preparable: nil); end
+  def self.dirties_query_cache(base, *method_names); end
+  def self.included(base); end
+  def uncached; end
+end
+module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
+  def disable_query_cache!; end
+  def enable_query_cache!; end
+  def initialize(*arg0); end
+  def query_cache_enabled; end
+end
+module ActiveRecord::ConnectionAdapters::Savepoints
+  def create_savepoint(name = nil); end
+  def current_savepoint_name; end
+  def exec_rollback_to_savepoint(name = nil); end
+  def release_savepoint(name = nil); end
+end
+class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
+  def <=>(version_string); end
+  def full_version_string; end
+  def initialize(version_string, full_version_string = nil); end
+  def to_s; end
+  include Comparable
+end
+module ActiveRecord::Scoping
+  def initialize_internals_callback; end
+  def populate_with_current_scope_attributes; end
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Scoping::ClassMethods
+  def current_scope(skip_inherited_scope = nil); end
+  def current_scope=(scope); end
+  def scope_attributes; end
+  def scope_attributes?; end
+end
+class ActiveRecord::Scoping::ScopeRegistry
+  def initialize; end
+  def raise_invalid_scope_type!(scope_type); end
+  def set_value_for(scope_type, model, value); end
+  def value_for(scope_type, model, skip_inherited_scope = nil); end
+  extend ActiveSupport::PerThreadRegistry
+end
+module ActiveRecord::Coders
+end
+module ActiveRecord::Locking
+  extend ActiveSupport::Autoload
+end
+module ActiveRecord::Middleware
+  extend ActiveSupport::Autoload
+end
+module ActiveRecord::Tasks
+  extend ActiveSupport::Autoload
+end
+module ActiveRecord::AttributeDecorators
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeDecorators::ClassMethods
+  def decorate_attribute_type(column_name, decorator_name, &block); end
+  def decorate_matching_attribute_types(matcher, decorator_name, &block); end
+  def load_schema!; end
+end
+class ActiveRecord::AttributeDecorators::TypeDecorator
+  def apply(name, type); end
+  def clear(*args, &block); end
+  def decorators_for(name, type); end
+  def initialize(decorations = nil); end
+  def matching(name, type); end
+  def merge(*args); end
+end
+module ActiveRecord::DefineCallbacks
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::DefineCallbacks::ClassMethods
+  include ActiveModel::Callbacks
+end
+class ActiveRecord::LogSubscriber < ActiveSupport::LogSubscriber
+  def self.backtrace_cleaner; end
+  def self.backtrace_cleaner=(val); end
+  def self.backtrace_cleaner?; end
+  def self.reset_runtime; end
+  def self.runtime; end
+  def self.runtime=(value); end
+end
+class ActiveRecord::ExplainRegistry
+  def collect; end
+  def collect=(arg0); end
+  def collect?; end
+  def initialize; end
+  def queries; end
+  def queries=(arg0); end
+  def reset; end
+  extend ActiveSupport::PerThreadRegistry
+end
+class ActiveRecord::ExplainSubscriber
+  def finish(name, id, payload); end
+  def ignore_payload?(payload); end
+  def start(name, id, payload); end
+end
+module ActiveRecord::Delegation
+  def &(*args, &block); end
+  def +(*args, &block); end
+  def -(*args, &block); end
+  def [](*args, &block); end
+  def as_json(*args, &block); end
+  def compact(*args, &block); end
+  def connection(*args, &block); end
+  def each(*args, &block); end
+  def encode_with(*args, &block); end
+  def in_groups(*args, &block); end
+  def in_groups_of(*args, &block); end
+  def index(*args, &block); end
+  def join(*args, &block); end
+  def length(*args, &block); end
+  def primary_key(*args, &block); end
+  def respond_to_missing?(method, _); end
+  def reverse(*args, &block); end
+  def rindex(*args, &block); end
+  def rotate(*args, &block); end
+  def sample(*args, &block); end
+  def shuffle(*args, &block); end
+  def slice(*args, &block); end
+  def split(*args, &block); end
+  def to_formatted_s(*args, &block); end
+  def to_sentence(*args, &block); end
+  def to_xml(*args, &block); end
+  def |(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Delegation::DelegateCache
+  def generate_relation_method(method); end
+  def generated_relation_methods; end
+  def include_relation_methods(delegate); end
+  def inherited(child_class); end
+  def initialize_relation_delegate_cache; end
+  def relation_delegate_class(klass); end
+end
+class ActiveRecord::Delegation::GeneratedRelationMethods < Module
+  def generate_method(method); end
+  def lock; end
+  def locked?; end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+  include Mutex_m
+end
+module ActiveRecord::Delegation::ClassSpecificRelation
+  def method_missing(method, *args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  def name; end
+end
+module ActiveRecord::Delegation::ClassMethods
+  def create(klass, *args, **kwargs); end
+  def relation_class_for(klass); end
+end
+module ActiveRecord::Attributes
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Attributes::ClassMethods
+  def attribute(name, cast_type = nil, **options); end
+  def define_attribute(name, cast_type, default: nil, user_provided_default: nil); end
+  def define_default_attribute(name, value, type, from_user:); end
+  def load_schema!; end
+end
+module ActiveRecord::TypeCaster
+end
+class ActiveRecord::TypeCaster::Map
+  def initialize(types); end
+  def type_cast_for_database(attr_name, value); end
+  def types; end
+end
+class ActiveRecord::TypeCaster::Connection
+  def connection(*args, &block); end
+  def initialize(klass, table_name); end
+  def table_name; end
+  def type_cast_for_database(attr_name, value); end
+  def type_for_attribute(attr_name); end
+end
+class ActiveRecord::DatabaseConfigurations
+  def [](env = nil); end
+  def any?(*args, &block); end
+  def blank?; end
+  def build_configs(configs); end
+  def build_db_config_from_hash(env_name, spec_name, config); end
+  def build_db_config_from_raw_config(env_name, spec_name, config); end
+  def build_db_config_from_string(env_name, spec_name, config); end
+  def configs_for(env_name: nil, spec_name: nil, include_replicas: nil); end
+  def configurations; end
+  def default_hash(env = nil); end
+  def each; end
+  def empty?; end
+  def env_with_configs(env = nil); end
+  def environment_url_config(env, spec_name, config); end
+  def environment_value_for(spec_name); end
+  def find_db_config(env); end
+  def first; end
+  def initialize(configurations = nil); end
+  def merge_db_environment_variables(current_env, configs); end
+  def method_missing(method, *args, &blk); end
+  def throw_getter_deprecation(method); end
+  def throw_setter_deprecation(method); end
+  def to_h; end
+  def walk_configs(env_name, config); end
+end
+class ActiveRecord::DatabaseConfigurations::DatabaseConfig
+  def env_name; end
+  def for_current_env?; end
+  def initialize(env_name, spec_name); end
+  def migrations_paths; end
+  def replica?; end
+  def spec_name; end
+  def to_legacy_hash; end
+  def url_config?; end
+end
+class ActiveRecord::DatabaseConfigurations::HashConfig < ActiveRecord::DatabaseConfigurations::DatabaseConfig
+  def config; end
+  def initialize(env_name, spec_name, config); end
+  def migrations_paths; end
+  def replica?; end
+end
+class ActiveRecord::DatabaseConfigurations::UrlConfig < ActiveRecord::DatabaseConfigurations::DatabaseConfig
+  def build_config(original_config, url); end
+  def build_url_hash(url); end
+  def config; end
+  def initialize(env_name, spec_name, url, config = nil); end
+  def migrations_paths; end
+  def replica?; end
+  def url; end
+  def url_config?; end
+end
+class ActiveRecord::DatabaseConfigurations::InvalidConfigurationError < StandardError
+end
+module ActiveRecord::ConnectionHandling
+  def clear_active_connections!(*args, &block); end
+  def clear_all_connections!(*args, &block); end
+  def clear_cache!; end
+  def clear_query_caches_for_current_thread; end
+  def clear_reloadable_connections!(*args, &block); end
+  def connected?; end
+  def connected_to(database: nil, role: nil, prevent_writes: nil, &blk); end
+  def connected_to?(role:); end
+  def connection; end
+  def connection_config; end
+  def connection_pool; end
+  def connection_specification_name; end
+  def connection_specification_name=(arg0); end
+  def connects_to(database: nil); end
+  def current_role; end
+  def establish_connection(config_or_env = nil); end
+  def flush_idle_connections!(*args, &block); end
+  def lookup_connection_handler(handler_key); end
+  def primary_class?; end
+  def remove_connection(name = nil); end
+  def resolve_config_for_connection(config_or_env); end
+  def retrieve_connection; end
+  def sqlite3_connection(config); end
+  def swap_connection_handler(handler, &blk); end
+  def with_handler(handler_key, &blk); end
+end
+class ActiveRecord::QueryCache
+  def self.complete(pools); end
+  def self.install_executor_hooks(executor = nil); end
+  def self.run; end
+end
+module ActiveRecord::QueryCache::ClassMethods
+  def cache(&block); end
+  def uncached(&block); end
+end
+module ActiveRecord::Querying
+  def annotate(*args, &block); end
+  def any?(*args, &block); end
+  def average(*args, &block); end
+  def calculate(*args, &block); end
+  def count(*args, &block); end
+  def count_by_sql(sql); end
+  def create_or_find_by!(*args, &block); end
+  def create_or_find_by(*args, &block); end
+  def create_with(*args, &block); end
+  def delete_all(*args, &block); end
+  def delete_by(*args, &block); end
+  def destroy_all(*args, &block); end
+  def destroy_by(*args, &block); end
+  def distinct(*args, &block); end
+  def eager_load(*args, &block); end
+  def except(*args, &block); end
+  def exists?(*args, &block); end
+  def extending(*args, &block); end
+  def extract_associated(*args, &block); end
+  def fifth!(*args, &block); end
+  def fifth(*args, &block); end
+  def find(*args, &block); end
+  def find_by!(*args, &block); end
+  def find_by(*args, &block); end
+  def find_by_sql(sql, binds = nil, preparable: nil, &block); end
+  def find_each(*args, &block); end
+  def find_in_batches(*args, &block); end
+  def find_or_create_by!(*args, &block); end
+  def find_or_create_by(*args, &block); end
+  def find_or_initialize_by(*args, &block); end
+  def first!(*args, &block); end
+  def first(*args, &block); end
+  def first_or_create!(*args, &block); end
+  def first_or_create(*args, &block); end
+  def first_or_initialize(*args, &block); end
+  def forty_two!(*args, &block); end
+  def forty_two(*args, &block); end
+  def fourth!(*args, &block); end
+  def fourth(*args, &block); end
+  def from(*args, &block); end
+  def group(*args, &block); end
+  def having(*args, &block); end
+  def ids(*args, &block); end
+  def in_batches(*args, &block); end
+  def includes(*args, &block); end
+  def joins(*args, &block); end
+  def last!(*args, &block); end
+  def last(*args, &block); end
+  def left_joins(*args, &block); end
+  def left_outer_joins(*args, &block); end
+  def limit(*args, &block); end
+  def lock(*args, &block); end
+  def many?(*args, &block); end
+  def maximum(*args, &block); end
+  def merge(*args, &block); end
+  def minimum(*args, &block); end
+  def none(*args, &block); end
+  def none?(*args, &block); end
+  def offset(*args, &block); end
+  def one?(*args, &block); end
+  def only(*args, &block); end
+  def optimizer_hints(*args, &block); end
+  def or(*args, &block); end
+  def order(*args, &block); end
+  def pick(*args, &block); end
+  def pluck(*args, &block); end
+  def preload(*args, &block); end
+  def readonly(*args, &block); end
+  def references(*args, &block); end
+  def reorder(*args, &block); end
+  def reselect(*args, &block); end
+  def rewhere(*args, &block); end
+  def second!(*args, &block); end
+  def second(*args, &block); end
+  def second_to_last!(*args, &block); end
+  def second_to_last(*args, &block); end
+  def select(*args, &block); end
+  def sum(*args, &block); end
+  def take!(*args, &block); end
+  def take(*args, &block); end
+  def third!(*args, &block); end
+  def third(*args, &block); end
+  def third_to_last!(*args, &block); end
+  def third_to_last(*args, &block); end
+  def touch_all(*args, &block); end
+  def unscope(*args, &block); end
+  def update_all(*args, &block); end
+  def where(*args, &block); end
+end
+module ActiveRecord::Translation
+  def i18n_scope; end
+  def lookup_ancestors; end
+  include ActiveModel::Translation
+end
+module ActiveRecord::DynamicMatchers
+  def method_missing(name, *arguments, &block); end
+  def respond_to_missing?(name, _); end
+end
+class ActiveRecord::DynamicMatchers::Method
+  def attribute_names; end
+  def attributes_hash; end
+  def body; end
+  def define; end
+  def finder; end
+  def initialize(model, method_name); end
+  def model; end
+  def name; end
+  def self.match(model, name); end
+  def self.matchers; end
+  def self.pattern; end
+  def self.prefix; end
+  def self.suffix; end
+  def signature; end
+  def valid?; end
+end
+class ActiveRecord::DynamicMatchers::FindBy < ActiveRecord::DynamicMatchers::Method
+  def finder; end
+  def self.prefix; end
+end
+class ActiveRecord::DynamicMatchers::FindByBang < ActiveRecord::DynamicMatchers::Method
+  def finder; end
+  def self.prefix; end
+  def self.suffix; end
+end
+module ActiveRecord::Explain
+  def collecting_queries_for_explain; end
+  def exec_explain(queries); end
+  def render_bind(attr); end
+end
+module ActiveRecord::Type
+  def self.add_modifier(*args, &block); end
+  def self.current_adapter_name; end
+  def self.default_value; end
+  def self.lookup(*args, adapter: nil, **kwargs); end
+  def self.register(type_name, klass = nil, **options, &block); end
+  def self.registry; end
+  def self.registry=(arg0); end
+end
+module ActiveRecord::Type::Internal
+end
+module ActiveRecord::Type::Internal::Timezone
+  def default_timezone; end
+  def is_utc?; end
+end
+class ActiveRecord::Type::Date < ActiveModel::Type::Date
+  include ActiveRecord::Type::Internal::Timezone
+end
+class ActiveRecord::Type::DateTime < ActiveModel::Type::DateTime
+  include ActiveRecord::Type::Internal::Timezone
+end
+class ActiveRecord::Type::DecimalWithoutScale < ActiveModel::Type::BigInteger
+  def type; end
+  def type_cast_for_schema(value); end
+end
+class ActiveRecord::Type::Json < ActiveModel::Type::Value
+  def accessor; end
+  def changed_in_place?(raw_old_value, new_value); end
+  def deserialize(value); end
+  def serialize(value); end
+  def type; end
+  include ActiveModel::Type::Helpers::Mutable
+end
+class ActiveRecord::Type::Time < ActiveModel::Type::Time
+  def serialize(value); end
+  include ActiveRecord::Type::Internal::Timezone
+end
+class ActiveRecord::Type::Time::Value < Anonymous_Delegator_6
+end
+class ActiveRecord::Type::Text < ActiveModel::Type::String
+  def type; end
+end
+class ActiveRecord::Type::UnsignedInteger < ActiveModel::Type::Integer
+  def max_value; end
+  def min_value; end
+end
+class ActiveRecord::Type::Serialized < Anonymous_Delegator_7
+  def accessor; end
+  def assert_valid_value(value); end
+  def changed_in_place?(raw_old_value, value); end
+  def coder; end
+  def default_value?(value); end
+  def deserialize(value); end
+  def encoded(value); end
+  def force_equality?(value); end
+  def initialize(subtype, coder); end
+  def inspect; end
+  def serialize(value); end
+  def subtype; end
+  include ActiveModel::Type::Helpers::Mutable
+end
+class ActiveRecord::Type::AdapterSpecificRegistry < ActiveModel::Type::Registry
+  def add_modifier(options, klass, **args); end
+  def find_registration(symbol, *args, **kwargs); end
+  def registration_klass; end
+end
+class ActiveRecord::Type::Registration
+  def <=>(other); end
+  def adapter; end
+  def block; end
+  def call(_registry, *args, adapter: nil, **kwargs); end
+  def conflicts_with?(other); end
+  def has_adapter_conflict?(other); end
+  def initialize(name, block, adapter: nil, override: nil); end
+  def matches?(type_name, *args, **kwargs); end
+  def matches_adapter?(adapter: nil, **arg1); end
+  def name; end
+  def override; end
+  def priority; end
+  def priority_except_adapter; end
+  def same_priority_except_adapter?(other); end
+end
+class ActiveRecord::Type::DecorationRegistration < ActiveRecord::Type::Registration
+  def call(registry, *args, **kwargs); end
+  def initialize(options, klass, adapter: nil); end
+  def klass; end
+  def matches?(*args, **kwargs); end
+  def matches_options?(**kwargs); end
+  def options; end
+  def priority; end
+end
+class ActiveRecord::TypeConflictError < StandardError
+end
+class ActiveRecord::Type::TypeMap
+  def alias_type(key, target_key); end
+  def clear; end
+  def fetch(lookup_key, *args, &block); end
+  def initialize; end
+  def lookup(lookup_key, *args); end
+  def perform_fetch(lookup_key, *args); end
+  def register_type(key, value = nil, &block); end
+end
+class ActiveRecord::Type::HashLookupTypeMap < ActiveRecord::Type::TypeMap
+  def alias_type(type, alias_type); end
+  def key?(key); end
+  def keys; end
+  def perform_fetch(type, *args, &block); end
+end
+module ActiveRecord::Enum
+  def _enum_methods_module; end
+  def assert_valid_enum_definition_values(values); end
+  def detect_enum_conflict!(enum_name, method_name, klass_method = nil); end
+  def detect_negative_condition!(method_name); end
+  def enum(definitions); end
+  def inherited(base); end
+  def raise_conflict_error(enum_name, method_name, type: nil, source: nil); end
+  def self.extended(base); end
+end
+class ActiveRecord::Enum::EnumType < ActiveModel::Type::Value
+  def assert_valid_value(value); end
+  def cast(value); end
+  def deserialize(value); end
+  def initialize(name, mapping, subtype); end
+  def mapping; end
+  def name; end
+  def serialize(value); end
+  def subtype; end
+  def type(*args, &block); end
+end
+module ActiveRecord::Aggregations
+  def clear_aggregation_cache; end
+  def init_internals; end
+  def initialize_dup(*arg0); end
+  def reload(*arg0); end
+end
+module ActiveRecord::Aggregations::ClassMethods
+  def composed_of(part_id, options = nil); end
+  def reader_method(name, class_name, mapping, allow_nil, constructor); end
+  def writer_method(name, class_name, mapping, allow_nil, converter); end
+end
+module ActiveRecord::Core
+  def <=>(other_object); end
+  def ==(comparison_object); end
+  def blank?; end
+  def connection_handler; end
+  def custom_inspect_method_defined?; end
+  def encode_with(coder); end
+  def eql?(comparison_object); end
+  def freeze; end
+  def frozen?; end
+  def hash; end
+  def init_internals; end
+  def init_with(coder, &block); end
+  def init_with_attributes(attributes, new_record = nil); end
+  def initialize(attributes = nil); end
+  def initialize_dup(other); end
+  def initialize_internals_callback; end
+  def inspect; end
+  def inspection_filter; end
+  def present?; end
+  def pretty_print(pp); end
+  def readonly!; end
+  def readonly?; end
+  def slice(*methods); end
+  def to_ary; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Core::ClassMethods
+  def ===(object); end
+  def _internal?; end
+  def arel_attribute(name, table = nil); end
+  def arel_table; end
+  def cached_find_by_statement(key, &block); end
+  def filter_attributes; end
+  def filter_attributes=(arg0); end
+  def find(*ids); end
+  def find_by!(*args); end
+  def find_by(*args); end
+  def generated_association_methods; end
+  def inherited(child_class); end
+  def initialize_find_by_cache; end
+  def initialize_generated_modules; end
+  def inspect; end
+  def predicate_builder; end
+  def relation; end
+  def table_metadata; end
+  def type_caster; end
+end
+class ActiveRecord::Core::InspectionMask < Anonymous_Delegator_8
+  def pretty_print(pp); end
+end
+class ActiveRecord::ConnectionTimeoutError < ActiveRecord::ConnectionNotEstablished
+end
+class ActiveRecord::ExclusiveConnectionTimeoutError < ActiveRecord::ConnectionTimeoutError
+end
+module ActiveRecord::ConnectionAdapters::AbstractPool
+  def get_schema_cache(connection); end
+  def set_schema_cache(cache); end
+end
+class ActiveRecord::ConnectionAdapters::NullPool
+  def initialize; end
+  include ActiveRecord::ConnectionAdapters::AbstractPool
+end
+class ActiveRecord::ConnectionAdapters::ConnectionPool
+  def acquire_connection(checkout_timeout); end
+  def active_connection?; end
+  def adopt_connection(conn); end
+  def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = nil); end
+  def automatic_reconnect; end
+  def automatic_reconnect=(arg0); end
+  def bulk_make_new_connections(num_new_conns_needed); end
+  def checkin(conn); end
+  def checkout(checkout_timeout = nil); end
+  def checkout_and_verify(c); end
+  def checkout_for_exclusive_access(checkout_timeout); end
+  def checkout_new_connection; end
+  def checkout_timeout; end
+  def checkout_timeout=(arg0); end
+  def clear_reloadable_connections!; end
+  def clear_reloadable_connections(raise_on_acquisition_timeout = nil); end
+  def connected?; end
+  def connection; end
+  def connection_cache_key(thread); end
+  def connections; end
+  def current_thread; end
+  def discard!; end
+  def disconnect!; end
+  def disconnect(raise_on_acquisition_timeout = nil); end
+  def flush!; end
+  def flush(minimum_idle = nil); end
+  def initialize(spec); end
+  def lock_thread=(lock_thread); end
+  def new_connection; end
+  def num_waiting_in_queue; end
+  def reap; end
+  def reaper; end
+  def release(conn, owner_thread = nil); end
+  def release_connection(owner_thread = nil); end
+  def remove(conn); end
+  def remove_connection_from_thread_cache(conn, owner_thread = nil); end
+  def schema_cache; end
+  def schema_cache=(arg0); end
+  def size; end
+  def spec; end
+  def stat; end
+  def try_to_checkout_new_connection; end
+  def with_connection; end
+  def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = nil); end
+  def with_new_connections_blocked; end
+  include ActiveRecord::ConnectionAdapters::AbstractPool
+  include ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
+  include MonitorMixin
+end
+class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
+  def add(element); end
+  def any?; end
+  def any_waiting?; end
+  def can_remove_no_wait?; end
+  def clear; end
+  def delete(element); end
+  def initialize(lock = nil); end
+  def internal_poll(timeout); end
+  def no_wait_poll; end
+  def num_waiting; end
+  def poll(timeout = nil); end
+  def remove; end
+  def synchronize(&block); end
+  def wait_poll(timeout); end
+end
+module ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue
+  def with_a_bias_for(thread); end
+end
+class ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue::BiasedConditionVariable
+  def broadcast; end
+  def broadcast_on_biased; end
+  def initialize(lock, other_cond, preferred_thread); end
+  def signal; end
+  def wait(timeout); end
+end
+class ActiveRecord::ConnectionAdapters::ConnectionPool::ConnectionLeasingQueue < ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
+  def internal_poll(timeout); end
+  include ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue
+end
+class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
+  def frequency; end
+  def initialize(pool, frequency); end
+  def pool; end
+  def run; end
+  def self.register_pool(pool, frequency); end
+  def self.spawn_thread(frequency); end
+end
+class ActiveRecord::ConnectionAdapters::ConnectionHandler
+  def active_connections?; end
+  def clear_active_connections!; end
+  def clear_all_connections!; end
+  def clear_reloadable_connections!; end
+  def connected?(spec_name); end
+  def connection_pool_list; end
+  def connection_pools; end
+  def establish_connection(config); end
+  def flush_idle_connections!; end
+  def initialize; end
+  def owner_to_pool; end
+  def pool_from_any_process_for(spec_name); end
+  def prevent_writes; end
+  def prevent_writes=(prevent_writes); end
+  def remove_connection(spec_name); end
+  def retrieve_connection(spec_name); end
+  def retrieve_connection_pool(spec_name); end
+  def self.create_owner_to_pool; end
+  def self.discard_unowned_pools(pid_map); end
+  def self.unowned_pool_finalizer(pid_map); end
+  def while_preventing_writes(enabled = nil); end
+end
+class ActiveRecord::InsertAll
+  def connection; end
+  def ensure_valid_options_for_connection!; end
+  def execute; end
+  def find_unique_index_for(unique_by); end
+  def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil); end
+  def inserts; end
+  def keys; end
+  def map_key_with_value; end
+  def model; end
+  def on_duplicate; end
+  def primary_keys; end
+  def readonly_columns; end
+  def returning; end
+  def skip_duplicates?; end
+  def to_sql; end
+  def unique_by; end
+  def unique_by_columns; end
+  def unique_indexes; end
+  def updatable_columns; end
+  def update_duplicates?; end
+  def verify_attributes(attributes); end
+end
+class ActiveRecord::InsertAll::Builder
+  def columns_list; end
+  def conflict_target; end
+  def connection; end
+  def extract_types_from_columns_on(table_name, keys:); end
+  def format_columns(columns); end
+  def initialize(insert_all); end
+  def insert_all; end
+  def into; end
+  def keys(*args, &block); end
+  def model; end
+  def quote_columns(columns); end
+  def returning; end
+  def skip_duplicates?(*args, &block); end
+  def updatable_columns; end
+  def update_duplicates?(*args, &block); end
+  def values_list; end
+end
+module ActiveRecord::Persistence
+  def _create_record(attribute_names = nil); end
+  def _delete_row; end
+  def _raise_readonly_record_error; end
+  def _raise_record_not_destroyed; end
+  def _touch_row(attribute_names, time); end
+  def _update_record(attribute_names = nil); end
+  def _update_row(attribute_names, attempted_action = nil); end
+  def becomes!(klass); end
+  def becomes(klass); end
+  def belongs_to_touch_method; end
+  def create_or_update(**arg0, &block); end
+  def decrement!(attribute, by = nil, touch: nil); end
+  def decrement(attribute, by = nil); end
+  def delete; end
+  def destroy!; end
+  def destroy; end
+  def destroy_associations; end
+  def destroy_row; end
+  def destroyed?; end
+  def increment!(attribute, by = nil, touch: nil); end
+  def increment(attribute, by = nil); end
+  def new_record?; end
+  def persisted?; end
+  def reload(options = nil); end
+  def save!(*args, **options, &block); end
+  def save(*args, **options, &block); end
+  def toggle!(attribute); end
+  def toggle(attribute); end
+  def touch(*names, time: nil); end
+  def update!(attributes); end
+  def update(attributes); end
+  def update_attribute(name, value); end
+  def update_attributes!(*args, &block); end
+  def update_attributes(*args, &block); end
+  def update_column(name, value); end
+  def update_columns(attributes); end
+  def verify_readonly_attribute(name); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Persistence::ClassMethods
+  def _delete_record(constraints); end
+  def _insert_record(values); end
+  def _substitute_values(values); end
+  def _update_record(values, constraints); end
+  def create!(attributes = nil, &block); end
+  def create(attributes = nil, &block); end
+  def delete(id_or_array); end
+  def destroy(id); end
+  def discriminate_class_for_record(record); end
+  def insert!(attributes, returning: nil); end
+  def insert(attributes, returning: nil, unique_by: nil); end
+  def insert_all!(attributes, returning: nil); end
+  def insert_all(attributes, returning: nil, unique_by: nil); end
+  def instantiate(attributes, column_types = nil, &block); end
+  def instantiate_instance_of(klass, attributes, column_types = nil, &block); end
+  def update(id = nil, attributes); end
+  def upsert(attributes, returning: nil, unique_by: nil); end
+  def upsert_all(attributes, returning: nil, unique_by: nil); end
+end
+module ActiveRecord::ReadonlyAttributes
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::ReadonlyAttributes::ClassMethods
+  def attr_readonly(*attributes); end
+  def readonly_attributes; end
+end
+module ActiveRecord::ModelSchema
+  def self.derive_join_table_name(first_table, second_table); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::ModelSchema::ClassMethods
+  def _default_attributes; end
+  def attribute_types; end
+  def attributes_builder; end
+  def column_defaults; end
+  def column_names; end
+  def columns; end
+  def columns_hash; end
+  def compute_table_name; end
+  def content_columns; end
+  def full_table_name_prefix; end
+  def full_table_name_suffix; end
+  def ignored_columns; end
+  def ignored_columns=(columns); end
+  def inheritance_column; end
+  def inheritance_column=(value); end
+  def inherited(child_class); end
+  def initialize_load_schema_monitor; end
+  def load_schema!; end
+  def load_schema; end
+  def next_sequence_value; end
+  def prefetch_primary_key?; end
+  def protected_environments; end
+  def protected_environments=(environments); end
+  def quoted_table_name; end
+  def reload_schema_from_cache; end
+  def reset_column_information; end
+  def reset_sequence_name; end
+  def reset_table_name; end
+  def schema_loaded?; end
+  def sequence_name; end
+  def sequence_name=(value); end
+  def symbol_column_to_string(name_symbol); end
+  def table_exists?; end
+  def table_name; end
+  def table_name=(value); end
+  def type_for_attribute(attr_name, &block); end
+  def undecorated_table_name(class_name = nil); end
+  def yaml_encoder; end
+end
+module ActiveRecord::Inheritance
+  def ensure_proper_type; end
+  def initialize_dup(other); end
+  def initialize_internals_callback; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Inheritance::ClassMethods
+  def abstract_class; end
+  def abstract_class=(arg0); end
+  def abstract_class?; end
+  def base_class; end
+  def base_class?; end
+  def compute_type(type_name); end
+  def descends_from_active_record?; end
+  def discriminate_class_for_record(record); end
+  def find_sti_class(type_name); end
+  def finder_needs_type_condition?; end
+  def inherited(subclass); end
+  def new(attributes = nil, &block); end
+  def polymorphic_name; end
+  def sti_name; end
+  def subclass_from_attributes(attrs); end
+  def type_condition(table = nil); end
+  def using_single_table_inheritance?(record); end
+end
+module ActiveRecord::Scoping::Default
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Scoping::Default::ClassMethods
+  def before_remove_const; end
+  def build_default_scope(relation = nil); end
+  def default_scope(scope = nil, &block); end
+  def evaluate_default_scope; end
+  def ignore_default_scope=(ignore); end
+  def ignore_default_scope?; end
+  def scope_attributes?; end
+  def unscoped; end
+end
+module ActiveRecord::Scoping::Named
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Scoping::Named::ClassMethods
+  def all; end
+  def default_extensions; end
+  def default_scoped(scope = nil); end
+  def scope(name, body, &block); end
+  def scope_for_association(scope = nil); end
+  def valid_scope_name?(name); end
+end
+module ActiveRecord::Sanitization
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Sanitization::ClassMethods
+  def disallow_raw_sql!(args, permit: nil); end
+  def quote_bound_value(value, c = nil); end
+  def raise_if_bind_arity_mismatch(statement, expected, provided); end
+  def replace_bind_variable(value, c = nil); end
+  def replace_bind_variables(statement, values); end
+  def replace_named_bind_variables(statement, bind_vars); end
+  def sanitize_sql(condition); end
+  def sanitize_sql_array(ary); end
+  def sanitize_sql_for_assignment(assignments, default_table_name = nil); end
+  def sanitize_sql_for_conditions(condition); end
+  def sanitize_sql_for_order(condition); end
+  def sanitize_sql_hash_for_assignment(attrs, table); end
+  def sanitize_sql_like(string, escape_character = nil); end
+end
+module ActiveRecord::AttributeAssignment
+  def _assign_attributes(attributes); end
+  def assign_multiparameter_attributes(pairs); end
+  def assign_nested_parameter_attributes(pairs); end
+  def execute_callstack_for_multiparameter_attributes(callstack); end
+  def extract_callstack_for_multiparameter_attributes(pairs); end
+  def find_parameter_position(multiparameter_name); end
+  def type_cast_attribute_value(multiparameter_name, value); end
+  include ActiveModel::AttributeAssignment
+end
+module ActiveRecord::Integration
+  def cache_key; end
+  def cache_key_with_version; end
+  def cache_version; end
+  def can_use_fast_cache_version?(timestamp); end
+  def raw_timestamp_to_cache_version(timestamp); end
+  def to_param; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Integration::ClassMethods
+  def collection_cache_key(collection = nil, timestamp_column = nil); end
+  def to_param(method_name = nil); end
+end
+module ActiveRecord::Validations
+  def default_validation_context; end
+  def perform_validations(options = nil); end
+  def raise_validation_error; end
+  def save!(**options); end
+  def save(**options); end
+  def valid?(context = nil); end
+  def validate(context = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+end
+class ActiveRecord::Validations::AssociatedValidator < ActiveModel::EachValidator
+  def valid_object?(record); end
+  def validate_each(record, attribute, value); end
+end
+module ActiveRecord::Validations::ClassMethods
+  def validates_absence_of(*attr_names); end
+  def validates_associated(*attr_names); end
+  def validates_length_of(*attr_names); end
+  def validates_presence_of(*attr_names); end
+  def validates_size_of(*attr_names); end
+  def validates_uniqueness_of(*attr_names); end
+end
+class ActiveRecord::Validations::UniquenessValidator < ActiveModel::EachValidator
+  def build_relation(klass, attribute, value); end
+  def find_finder_class_for(record); end
+  def initialize(options); end
+  def map_enum_attribute(klass, attribute, value); end
+  def scope_relation(record, relation); end
+  def validate_each(record, attribute, value); end
+end
+class ActiveRecord::Validations::PresenceValidator < ActiveModel::Validations::PresenceValidator
+  def validate_each(record, attribute, association_or_value); end
+end
+class ActiveRecord::Validations::AbsenceValidator < ActiveModel::Validations::AbsenceValidator
+  def validate_each(record, attribute, association_or_value); end
+end
+class ActiveRecord::Validations::LengthValidator < ActiveModel::Validations::LengthValidator
+  def validate_each(record, attribute, association_or_value); end
+end
+class ActiveRecord::RecordInvalid < ActiveRecord::ActiveRecordError
+  def initialize(record = nil); end
+  def record; end
+end
+module ActiveRecord::CounterCache
+  def _create_record(attribute_names = nil); end
+  def destroy_row; end
+  def each_counter_cached_associations; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::CounterCache::ClassMethods
+  def decrement_counter(counter_name, id, touch: nil); end
+  def increment_counter(counter_name, id, touch: nil); end
+  def reset_counters(id, *counters, touch: nil); end
+  def update_counters(id, counters); end
+end
+module ActiveRecord::Locking::Optimistic
+  def _create_record(attribute_names = nil); end
+  def _touch_row(attribute_names, time); end
+  def _update_row(attribute_names, attempted_action = nil); end
+  def destroy_row; end
+  def locking_enabled?; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Locking::Optimistic::ClassMethods
+  def inherited(subclass); end
+  def locking_column; end
+  def locking_column=(value); end
+  def locking_enabled?; end
+  def reset_locking_column; end
+  def update_counters(id, counters); end
+end
+class ActiveRecord::Locking::LockingType < Anonymous_Delegator_9
+  def deserialize(value); end
+  def encode_with(coder); end
+  def init_with(coder); end
+  def serialize(value); end
+end
+module ActiveRecord::Locking::Pessimistic
+  def lock!(lock = nil); end
+  def with_lock(lock = nil); end
+end
+module ActiveRecord::AttributeMethods::Read
+  def _read_attribute(attr_name, &block); end
+  def attribute(attr_name, &block); end
+  def read_attribute(attr_name, &block); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeMethods::Read::ClassMethods
+  def define_method_attribute(name); end
+end
+module ActiveRecord::AttributeMethods::Write
+  def _write_attribute(attr_name, value); end
+  def attribute=(attribute_name, value); end
+  def write_attribute(attr_name, value); end
+  def write_attribute_without_type_cast(attr_name, value); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeMethods::Write::ClassMethods
+  def define_method_attribute=(name); end
+end
+module ActiveRecord::AttributeMethods::BeforeTypeCast
+  def attribute_before_type_cast(attribute_name); end
+  def attribute_came_from_user?(attribute_name); end
+  def attributes_before_type_cast; end
+  def read_attribute_before_type_cast(attr_name); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeMethods::Query
+  def attribute?(attribute_name); end
+  def query_attribute(attr_name); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeMethods::PrimaryKey
+  def attribute_method?(attr_name); end
+  def id; end
+  def id=(value); end
+  def id?; end
+  def id_before_type_cast; end
+  def id_in_database; end
+  def id_was; end
+  def to_key; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
+  def dangerous_attribute_method?(method_name); end
+  def get_primary_key(base_name); end
+  def instance_method_already_implemented?(method_name); end
+  def primary_key; end
+  def primary_key=(value); end
+  def quoted_primary_key; end
+  def reset_primary_key; end
+  def suppress_composite_primary_key(pk); end
+end
+module ActiveRecord::AttributeMethods::TimeZoneConversion
+  extend ActiveSupport::Concern
+end
+class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter < Anonymous_Delegator_10
+  def cast(value); end
+  def convert_time_to_time_zone(value); end
+  def deserialize(value); end
+  def map_avoiding_infinite_recursion(value); end
+  def set_time_zone_without_conversion(value); end
+end
+module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
+  def create_time_zone_conversion_attribute?(name, cast_type); end
+  def inherited(subclass); end
+end
+module ActiveRecord::AttributeMethods::Dirty
+  def _create_record(attribute_names = nil); end
+  def _touch_row(attribute_names, time); end
+  def _update_record(attribute_names = nil); end
+  def attribute_before_last_save(attr_name); end
+  def attribute_change_to_be_saved(attr_name); end
+  def attribute_in_database(attr_name); end
+  def attribute_names_for_partial_writes; end
+  def attributes_in_database; end
+  def changed_attribute_names_to_save; end
+  def changes_to_save; end
+  def has_changes_to_save?; end
+  def mutations_before_last_save; end
+  def mutations_from_database; end
+  def reload(*arg0); end
+  def saved_change_to_attribute(attr_name); end
+  def saved_change_to_attribute?(attr_name, **options); end
+  def saved_changes; end
+  def saved_changes?; end
+  def will_save_change_to_attribute?(attr_name, **options); end
+  def write_attribute_without_type_cast(attr_name, value); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Dirty
+end
+module ActiveRecord::Timestamp
+  def _create_record; end
+  def _update_record; end
+  def all_timestamp_attributes_in_model; end
+  def clear_timestamp_attributes; end
+  def create_or_update(touch: nil, **arg1); end
+  def current_time_from_proper_timezone; end
+  def initialize_dup(other); end
+  def max_updated_column_timestamp; end
+  def should_record_timestamps?; end
+  def timestamp_attributes_for_create_in_model; end
+  def timestamp_attributes_for_update_in_model; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Timestamp::ClassMethods
+  def all_timestamp_attributes_in_model; end
+  def current_time_from_proper_timezone; end
+  def reload_schema_from_cache; end
+  def timestamp_attributes_for_create; end
+  def timestamp_attributes_for_create_in_model; end
+  def timestamp_attributes_for_update; end
+  def timestamp_attributes_for_update_in_model; end
+  def touch_attributes_with_time(*names, time: nil); end
+end
+module ActiveRecord::AttributeMethods::Serialization
+  extend ActiveSupport::Concern
+end
+class ActiveRecord::AttributeMethods::Serialization::ColumnNotSerializableError < StandardError
+  def initialize(name, type); end
+end
+module ActiveRecord::AttributeMethods::Serialization::ClassMethods
+  def serialize(attr_name, class_name_or_coder = nil); end
+  def type_incompatible_with_serialize?(type, class_name); end
+end
+module ActiveRecord::Callbacks
+  def _create_record; end
+  def _update_record; end
+  def create_or_update(**arg0); end
+  def destroy; end
+  def increment!(attribute, by = nil, touch: nil); end
+  def touch(*arg0, **arg1); end
+  extend ActiveSupport::Concern
+end
+class ActiveRecord::AssociationNotFoundError < ActiveRecord::ConfigurationError
+  def initialize(record = nil, association_name = nil); end
+end
+class ActiveRecord::InverseOfAssociationNotFoundError < ActiveRecord::ActiveRecordError
+  def initialize(reflection = nil, associated_class = nil); end
+end
+class ActiveRecord::HasManyThroughAssociationNotFoundError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil); end
+end
+class ActiveRecord::HasManyThroughAssociationPolymorphicSourceError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil); end
+end
+class ActiveRecord::HasManyThroughAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil); end
+end
+class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil); end
+end
+class ActiveRecord::HasOneThroughCantAssociateThroughCollection < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil); end
+end
+class ActiveRecord::HasOneAssociationPolymorphicThroughError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil); end
+end
+class ActiveRecord::HasManyThroughSourceAssociationNotFoundError < ActiveRecord::ActiveRecordError
+  def initialize(reflection = nil); end
+end
+class ActiveRecord::HasManyThroughOrderError < ActiveRecord::ActiveRecordError
+  def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil); end
+end
+class ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ActiveRecordError
+  def initialize(owner = nil, reflection = nil); end
+end
+class ActiveRecord::AmbiguousSourceReflectionForThroughAssociation < ActiveRecord::ActiveRecordError
+  def initialize(klass, macro, association_name, options, possible_sources); end
+end
+class ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
+end
+class ActiveRecord::HasOneThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecord::ThroughCantAssociateThroughHasOneOrManyReflection
+end
+class ActiveRecord::ThroughNestedAssociationsAreReadonly < ActiveRecord::ActiveRecordError
+  def initialize(owner = nil, reflection = nil); end
+end
+class ActiveRecord::HasManyThroughNestedAssociationsAreReadonly < ActiveRecord::ThroughNestedAssociationsAreReadonly
+end
+class ActiveRecord::HasOneThroughNestedAssociationsAreReadonly < ActiveRecord::ThroughNestedAssociationsAreReadonly
+end
+class ActiveRecord::EagerLoadPolymorphicError < ActiveRecord::ActiveRecordError
+  def initialize(reflection = nil); end
+end
+class ActiveRecord::DeleteRestrictionError < ActiveRecord::ActiveRecordError
+  def initialize(name = nil); end
+end
+module ActiveRecord::Associations
+  def association(name); end
+  def association_cached?(name); end
+  def association_instance_get(name); end
+  def association_instance_set(name, association); end
+  def clear_association_cache; end
+  def init_internals; end
+  def initialize_dup(*arg0); end
+  def reload(*arg0); end
+  def self.eager_load!; end
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Associations::Builder
+end
+module ActiveRecord::Associations::ClassMethods
+  def belongs_to(name, scope = nil, **options); end
+  def has_and_belongs_to_many(name, scope = nil, **options, &extension); end
+  def has_many(name, scope = nil, **options, &extension); end
+  def has_one(name, scope = nil, **options); end
+end
+module ActiveRecord::AutosaveAssociation
+  def _ensure_no_duplicate_errors; end
+  def after_save_collection_association; end
+  def associated_records_to_validate_or_save(association, new_record, autosave); end
+  def association_foreign_key_changed?(reflection, record, key); end
+  def association_valid?(reflection, record, index = nil); end
+  def before_save_collection_association; end
+  def changed_for_autosave?; end
+  def custom_validation_context?; end
+  def destroyed_by_association; end
+  def destroyed_by_association=(reflection); end
+  def mark_for_destruction; end
+  def marked_for_destruction?; end
+  def nested_records_changed_for_autosave?; end
+  def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end
+  def record_changed?(reflection, record, key); end
+  def reload(options = nil); end
+  def save_belongs_to_association(reflection); end
+  def save_collection_association(reflection); end
+  def save_has_one_association(reflection); end
+  def validate_collection_association(reflection); end
+  def validate_single_association(reflection); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::AutosaveAssociation::AssociationBuilderExtension
+  def self.build(model, reflection); end
+  def self.valid_options; end
+end
+module ActiveRecord::AutosaveAssociation::ClassMethods
+  def add_autosave_association_callbacks(reflection); end
+  def define_autosave_validation_callbacks(reflection); end
+  def define_non_cyclic_method(name, &block); end
+end
+class ActiveRecord::Associations::Builder::Association
+  def self.add_destroy_callbacks(model, reflection); end
+  def self.build(model, name, scope, options, &block); end
+  def self.build_scope(scope); end
+  def self.check_dependent_options(dependent); end
+  def self.create_reflection(model, name, scope, options, &block); end
+  def self.define_accessors(model, reflection); end
+  def self.define_callbacks(model, reflection); end
+  def self.define_extensions(model, name); end
+  def self.define_readers(mixin, name); end
+  def self.define_validations(model, reflection); end
+  def self.define_writers(mixin, name); end
+  def self.extensions; end
+  def self.extensions=(arg0); end
+  def self.macro; end
+  def self.valid_dependent_options; end
+  def self.valid_options(options); end
+  def self.validate_options(options); end
+end
+module ActiveRecord::NestedAttributes
+  def _destroy; end
+  def allow_destroy?(association_name); end
+  def assign_nested_attributes_for_collection_association(association_name, attributes_collection); end
+  def assign_nested_attributes_for_one_to_one_association(association_name, attributes); end
+  def assign_to_or_mark_for_destruction(record, attributes, allow_destroy); end
+  def call_reject_if(association_name, attributes); end
+  def check_record_limit!(limit, attributes_collection); end
+  def has_destroy_flag?(hash); end
+  def raise_nested_attributes_record_not_found!(association_name, record_id); end
+  def reject_new_record?(association_name, attributes); end
+  def will_be_destroyed?(association_name, attributes); end
+  extend ActiveSupport::Concern
+end
+class ActiveRecord::NestedAttributes::TooManyRecords < ActiveRecord::ActiveRecordError
+end
+module ActiveRecord::NestedAttributes::ClassMethods
+  def accepts_nested_attributes_for(*attr_names); end
+  def generate_association_writer(association_name, type); end
+end
+module ActiveRecord::Transactions
+  def _committed_already_called; end
+  def _trigger_destroy_callback; end
+  def _trigger_update_callback; end
+  def add_to_transaction; end
+  def before_committed!; end
+  def clear_transaction_record_state; end
+  def committed!(should_run_callbacks: nil); end
+  def destroy; end
+  def force_clear_transaction_record_state; end
+  def has_transactional_callbacks?; end
+  def remember_transaction_record_state; end
+  def restore_transaction_record_state(force_restore_state = nil); end
+  def rolledback!(force_restore_state: nil, should_run_callbacks: nil); end
+  def save!(*arg0, **arg1); end
+  def save(*arg0, **arg1); end
+  def sync_with_transaction_state; end
+  def touch(*arg0, **arg1); end
+  def transaction(options = nil, &block); end
+  def transaction_include_any_action?(actions); end
+  def trigger_transactional_callbacks?; end
+  def with_transaction_returning_status; end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Transactions::ClassMethods
+  def after_commit(*args, &block); end
+  def after_commit_without_transaction_enrollment(*args, &block); end
+  def after_create_commit(*args, &block); end
+  def after_destroy_commit(*args, &block); end
+  def after_rollback(*args, &block); end
+  def after_rollback_without_transaction_enrollment(*args, &block); end
+  def after_save_commit(*args, &block); end
+  def after_update_commit(*args, &block); end
+  def assert_valid_transaction_action(actions); end
+  def before_commit(*args, &block); end
+  def before_commit_without_transaction_enrollment(*args, &block); end
+  def set_options_for_callbacks!(args, enforced_options = nil); end
+  def transaction(**options, &block); end
+end
+module ActiveRecord::TouchLater
+  def belongs_to_touch_method; end
+  def has_defer_touch_attrs?; end
+  def surreptitiously_touch(attrs); end
+  def touch(*names, time: nil); end
+  def touch_deferred_attributes; end
+  def touch_later(*names, **arg1); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::NoTouching
+  def no_touching?; end
+  def self.applied_to?(klass); end
+  def self.apply_to(klass); end
+  def self.klasses; end
+  def touch(*arg0, **arg1); end
+  def touch_later(*arg0, **arg1); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::NoTouching::ClassMethods
+  def no_touching(&block); end
+end
+module ActiveRecord::Reflection
+  def self.add_aggregate_reflection(ar, name, reflection); end
+  def self.add_reflection(ar, name, reflection); end
+  def self.create(macro, name, scope, options, ar); end
+  def self.reflection_class_for(macro); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Reflection::ClassMethods
+  def _reflect_on_association(association); end
+  def clear_reflections_cache; end
+  def reflect_on_aggregation(aggregation); end
+  def reflect_on_all_aggregations; end
+  def reflect_on_all_associations(macro = nil); end
+  def reflect_on_all_autosave_associations; end
+  def reflect_on_association(association); end
+  def reflections; end
+end
+class ActiveRecord::Reflection::AbstractReflection
+  def actual_source_reflection; end
+  def alias_candidate(name); end
+  def build_association(attributes, &block); end
+  def build_scope(table, predicate_builder = nil); end
+  def chain; end
+  def check_validity_of_inverse!; end
+  def class_name; end
+  def constraints; end
+  def counter_cache_column; end
+  def counter_must_be_updated_by_has_many?; end
+  def get_join_keys(association_klass); end
+  def has_cached_counter?; end
+  def inverse_of; end
+  def inverse_updates_counter_cache?; end
+  def inverse_updates_counter_in_memory?; end
+  def inverse_which_updates_counter_cache; end
+  def join_foreign_key; end
+  def join_keys; end
+  def join_primary_key(*arg0); end
+  def join_scope(table, foreign_table, foreign_klass); end
+  def join_scopes(table, predicate_builder); end
+  def klass_join_scope(table, predicate_builder); end
+  def predicate_builder(table); end
+  def primary_key(klass); end
+  def scopes; end
+  def table_name; end
+  def through_reflection?; end
+end
+class ActiveRecord::Reflection::AbstractReflection::JoinKeys < Struct
+  def foreign_key; end
+  def foreign_key=(_); end
+  def key; end
+  def key=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveRecord::Reflection::MacroReflection < ActiveRecord::Reflection::AbstractReflection
+  def ==(other_aggregation); end
+  def active_record; end
+  def autosave=(autosave); end
+  def compute_class(name); end
+  def derive_class_name; end
+  def initialize(name, scope, options, active_record); end
+  def klass; end
+  def name; end
+  def options; end
+  def plural_name; end
+  def scope; end
+  def scope_for(relation, owner = nil); end
+end
+class ActiveRecord::Reflection::AggregateReflection < ActiveRecord::Reflection::MacroReflection
+  def mapping; end
+end
+class ActiveRecord::Reflection::AssociationReflection < ActiveRecord::Reflection::MacroReflection
+  def active_record_primary_key; end
+  def add_as_polymorphic_through(reflection, seed); end
+  def add_as_source(seed); end
+  def add_as_through(seed); end
+  def association_class; end
+  def association_foreign_key; end
+  def association_primary_key(klass = nil); end
+  def association_scope_cache(conn, owner, &block); end
+  def automatic_inverse_of; end
+  def belongs_to?; end
+  def calculate_constructable(macro, options); end
+  def can_find_inverse_of_automatically?(reflection); end
+  def check_eager_loadable!; end
+  def check_preloadable!; end
+  def check_validity!; end
+  def clear_association_scope_cache; end
+  def collect_join_chain; end
+  def collection?; end
+  def compute_class(name); end
+  def constructable?; end
+  def derive_class_name; end
+  def derive_foreign_key; end
+  def derive_join_table; end
+  def extensions; end
+  def foreign_key; end
+  def foreign_type; end
+  def has_inverse?; end
+  def has_one?; end
+  def has_scope?; end
+  def initialize(name, scope, options, active_record); end
+  def inverse_name; end
+  def join_id_for(owner); end
+  def join_table; end
+  def macro; end
+  def nested?; end
+  def parent_reflection; end
+  def parent_reflection=(arg0); end
+  def polymorphic?; end
+  def polymorphic_inverse_of(associated_class); end
+  def source_reflection; end
+  def through_reflection; end
+  def type; end
+  def valid_inverse_reflection?(reflection); end
+  def validate?; end
+end
+class ActiveRecord::Reflection::HasManyReflection < ActiveRecord::Reflection::AssociationReflection
+  def association_class; end
+  def association_primary_key(klass = nil); end
+  def collection?; end
+  def macro; end
+end
+class ActiveRecord::Reflection::HasOneReflection < ActiveRecord::Reflection::AssociationReflection
+  def association_class; end
+  def calculate_constructable(macro, options); end
+  def has_one?; end
+  def macro; end
+end
+class ActiveRecord::Reflection::BelongsToReflection < ActiveRecord::Reflection::AssociationReflection
+  def association_class; end
+  def belongs_to?; end
+  def calculate_constructable(macro, options); end
+  def can_find_inverse_of_automatically?(_); end
+  def join_foreign_key; end
+  def join_primary_key(klass = nil); end
+  def macro; end
+end
+class ActiveRecord::Reflection::HasAndBelongsToManyReflection < ActiveRecord::Reflection::AssociationReflection
+  def collection?; end
+  def macro; end
+end
+class ActiveRecord::Reflection::ThroughReflection < ActiveRecord::Reflection::AbstractReflection
+  def active_record(*args, &block); end
+  def active_record_primary_key(*args, &block); end
+  def actual_source_reflection; end
+  def add_as_polymorphic_through(reflection, seed); end
+  def add_as_source(seed); end
+  def add_as_through(seed); end
+  def association_class(*args, &block); end
+  def association_foreign_key(*args, &block); end
+  def association_primary_key(klass = nil); end
+  def association_scope_cache(*args, &block); end
+  def autosave=(arg); end
+  def belongs_to?(*args, &block); end
+  def check_eager_loadable!(*args, &block); end
+  def check_preloadable!(*args, &block); end
+  def check_validity!; end
+  def clear_association_scope_cache; end
+  def collect_join_chain; end
+  def collect_join_reflections(seed); end
+  def collection?(*args, &block); end
+  def compute_class(*args, &block); end
+  def constraints; end
+  def constructable?(*args, &block); end
+  def delegate_reflection; end
+  def derive_class_name; end
+  def extensions(*args, &block); end
+  def foreign_key(*args, &block); end
+  def foreign_type(*args, &block); end
+  def get_join_keys(*args, &block); end
+  def has_inverse?(*args, &block); end
+  def has_one?(*args, &block); end
+  def has_scope?; end
+  def initialize(delegate_reflection); end
+  def inverse_name; end
+  def join_id_for(*args, &block); end
+  def join_scopes(table, predicate_builder); end
+  def join_table(*args, &block); end
+  def klass; end
+  def macro(*args, &block); end
+  def name(*args, &block); end
+  def nested?; end
+  def options(*args, &block); end
+  def parent_reflection(*args, &block); end
+  def parent_reflection=(arg); end
+  def plural_name(*args, &block); end
+  def polymorphic?(*args, &block); end
+  def polymorphic_inverse_of(*args, &block); end
+  def scope(*args, &block); end
+  def scope_for(*args, &block); end
+  def scopes; end
+  def source_options; end
+  def source_reflection; end
+  def source_reflection_name; end
+  def source_reflection_names; end
+  def through_options; end
+  def through_reflection; end
+  def through_reflection?; end
+  def type(*args, &block); end
+  def validate?(*args, &block); end
+end
+class ActiveRecord::Reflection::PolymorphicReflection < ActiveRecord::Reflection::AbstractReflection
+  def constraints; end
+  def get_join_keys(*args, &block); end
+  def initialize(reflection, previous_reflection); end
+  def join_scopes(table, predicate_builder); end
+  def klass(*args, &block); end
+  def plural_name(*args, &block); end
+  def scope(*args, &block); end
+  def scope_for(*args, &block); end
+  def source_type_scope; end
+  def type(*args, &block); end
+end
+class ActiveRecord::Reflection::RuntimeReflection < ActiveRecord::Reflection::AbstractReflection
+  def aliased_table; end
+  def all_includes; end
+  def constraints(*args, &block); end
+  def get_join_keys(*args, &block); end
+  def initialize(reflection, association); end
+  def klass; end
+  def scope(*args, &block); end
+  def type(*args, &block); end
+end
+module ActiveRecord::Serialization
+  def serializable_hash(options = nil); end
+  extend ActiveSupport::Concern
+  include ActiveModel::Serializers::JSON
+end
+module ActiveRecord::Store
+  def read_store_attribute(store_attribute, key); end
+  def store_accessor_for(store_attribute); end
+  def write_store_attribute(store_attribute, key, value); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Store::ClassMethods
+  def _store_accessors_module; end
+  def store(store_attribute, options = nil); end
+  def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil); end
+  def stored_attributes; end
+end
+class ActiveRecord::Store::HashAccessor
+  def self.prepare(object, attribute); end
+  def self.read(object, attribute, key); end
+  def self.write(object, attribute, key, value); end
+end
+class ActiveRecord::Store::StringKeyedHashAccessor < ActiveRecord::Store::HashAccessor
+  def self.read(object, attribute, key); end
+  def self.write(object, attribute, key, value); end
+end
+class ActiveRecord::Store::IndifferentHashAccessor < ActiveRecord::Store::HashAccessor
+  def self.prepare(object, store_attribute); end
+end
+class ActiveRecord::Store::IndifferentCoder
+  def dump(obj); end
+  def initialize(attr_name, coder_or_class_name); end
+  def load(yaml); end
+  def self.as_indifferent_hash(obj); end
+end
+module ActiveRecord::SecureToken
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::SecureToken::ClassMethods
+  def generate_unique_secure_token; end
+  def has_secure_token(attribute = nil); end
+end
+module ActiveRecord::Suppressor
+  def save!(*arg0, **arg1); end
+  def save(*arg0, **arg1); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::Suppressor::ClassMethods
+  def suppress(&block); end
+end
+class ActiveRecord::SuppressorRegistry
+  def initialize; end
+  def suppressed; end
+  extend ActiveSupport::PerThreadRegistry
+end
+class ActiveRecord::Base
+  def __callbacks; end
+  def __callbacks?; end
+  def _before_commit_callbacks; end
+  def _before_commit_without_transaction_enrollment_callbacks; end
+  def _commit_callbacks; end
+  def _commit_without_transaction_enrollment_callbacks; end
+  def _create_callbacks; end
+  def _destroy_callbacks; end
+  def _find_callbacks; end
+  def _initialize_callbacks; end
+  def _reflections; end
+  def _reflections?; end
+  def _rollback_callbacks; end
+  def _rollback_without_transaction_enrollment_callbacks; end
+  def _run_before_commit_callbacks(&block); end
+  def _run_before_commit_without_transaction_enrollment_callbacks(&block); end
+  def _run_commit_callbacks(&block); end
+  def _run_commit_without_transaction_enrollment_callbacks(&block); end
+  def _run_create_callbacks(&block); end
+  def _run_destroy_callbacks(&block); end
+  def _run_find_callbacks(&block); end
+  def _run_initialize_callbacks(&block); end
+  def _run_rollback_callbacks(&block); end
+  def _run_rollback_without_transaction_enrollment_callbacks(&block); end
+  def _run_save_callbacks(&block); end
+  def _run_touch_callbacks(&block); end
+  def _run_update_callbacks(&block); end
+  def _run_validate_callbacks(&block); end
+  def _run_validation_callbacks(&block); end
+  def _save_callbacks; end
+  def _touch_callbacks; end
+  def _update_callbacks; end
+  def _validate_callbacks; end
+  def _validation_callbacks; end
+  def _validators; end
+  def _validators?; end
+  def aggregate_reflections; end
+  def aggregate_reflections?; end
+  def allow_unsafe_raw_sql; end
+  def attribute_aliases; end
+  def attribute_aliases?; end
+  def attribute_method_matchers; end
+  def attribute_method_matchers?; end
+  def cache_timestamp_format; end
+  def cache_timestamp_format?; end
+  def cache_versioning; end
+  def cache_versioning?; end
+  def collection_cache_versioning; end
+  def collection_cache_versioning?; end
+  def column_for_attribute(*args, &block); end
+  def default_connection_handler; end
+  def default_connection_handler?; end
+  def default_scope_override; end
+  def default_scopes; end
+  def default_timezone; end
+  def defined_enums; end
+  def defined_enums?; end
+  def dump_schema_after_migration; end
+  def dump_schemas; end
+  def error_on_ignored_order; end
+  def include_root_in_json; end
+  def include_root_in_json?; end
+  def index_nested_attribute_errors; end
+  def lock_optimistically; end
+  def lock_optimistically?; end
+  def logger; end
+  def model_name(*args, &block); end
+  def nested_attributes_options; end
+  def nested_attributes_options?; end
+  def partial_writes; end
+  def partial_writes?; end
+  def pluralize_table_names; end
+  def pluralize_table_names?; end
+  def primary_key_prefix_type; end
+  def record_timestamps; end
+  def record_timestamps=(val); end
+  def record_timestamps?; end
+  def schema_format; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._attr_readonly; end
+  def self._attr_readonly=(val); end
+  def self._attr_readonly?; end
+  def self._before_commit_callbacks; end
+  def self._before_commit_callbacks=(value); end
+  def self._before_commit_without_transaction_enrollment_callbacks; end
+  def self._before_commit_without_transaction_enrollment_callbacks=(value); end
+  def self._commit_callbacks; end
+  def self._commit_callbacks=(value); end
+  def self._commit_without_transaction_enrollment_callbacks; end
+  def self._commit_without_transaction_enrollment_callbacks=(value); end
+  def self._create_callbacks; end
+  def self._create_callbacks=(value); end
+  def self._destroy_callbacks; end
+  def self._destroy_callbacks=(value); end
+  def self._find_callbacks; end
+  def self._find_callbacks=(value); end
+  def self._initialize_callbacks; end
+  def self._initialize_callbacks=(value); end
+  def self._reflections; end
+  def self._reflections=(val); end
+  def self._reflections?; end
+  def self._rollback_callbacks; end
+  def self._rollback_callbacks=(value); end
+  def self._rollback_without_transaction_enrollment_callbacks; end
+  def self._rollback_without_transaction_enrollment_callbacks=(value); end
+  def self._save_callbacks; end
+  def self._save_callbacks=(value); end
+  def self._touch_callbacks; end
+  def self._touch_callbacks=(value); end
+  def self._update_callbacks; end
+  def self._update_callbacks=(value); end
+  def self._validate_callbacks; end
+  def self._validate_callbacks=(value); end
+  def self._validation_callbacks; end
+  def self._validation_callbacks=(value); end
+  def self._validators; end
+  def self._validators=(val); end
+  def self._validators?; end
+  def self.after_create(*args, **options, &block); end
+  def self.after_destroy(*args, **options, &block); end
+  def self.after_find(*args, **options, &block); end
+  def self.after_initialize(*args, **options, &block); end
+  def self.after_save(*args, **options, &block); end
+  def self.after_touch(*args, **options, &block); end
+  def self.after_update(*args, **options, &block); end
+  def self.aggregate_reflections; end
+  def self.aggregate_reflections=(val); end
+  def self.aggregate_reflections?; end
+  def self.allow_unsafe_raw_sql; end
+  def self.allow_unsafe_raw_sql=(obj); end
+  def self.around_create(*args, **options, &block); end
+  def self.around_destroy(*args, **options, &block); end
+  def self.around_save(*args, **options, &block); end
+  def self.around_update(*args, **options, &block); end
+  def self.attribute_aliases; end
+  def self.attribute_aliases=(val); end
+  def self.attribute_aliases?; end
+  def self.attribute_method_matchers; end
+  def self.attribute_method_matchers=(val); end
+  def self.attribute_method_matchers?; end
+  def self.attribute_type_decorations; end
+  def self.attribute_type_decorations=(val); end
+  def self.attribute_type_decorations?; end
+  def self.attributes_to_define_after_schema_loads; end
+  def self.attributes_to_define_after_schema_loads=(val); end
+  def self.attributes_to_define_after_schema_loads?; end
+  def self.before_create(*args, **options, &block); end
+  def self.before_destroy(*args, **options, &block); end
+  def self.before_save(*args, **options, &block); end
+  def self.before_update(*args, **options, &block); end
+  def self.belongs_to_required_by_default; end
+  def self.belongs_to_required_by_default=(obj); end
+  def self.cache_timestamp_format; end
+  def self.cache_timestamp_format=(val); end
+  def self.cache_timestamp_format?; end
+  def self.cache_versioning; end
+  def self.cache_versioning=(val); end
+  def self.cache_versioning?; end
+  def self.collection_cache_versioning; end
+  def self.collection_cache_versioning=(val); end
+  def self.collection_cache_versioning?; end
+  def self.configurations; end
+  def self.configurations=(config); end
+  def self.connection_handler; end
+  def self.connection_handler=(handler); end
+  def self.connection_handlers; end
+  def self.connection_handlers=(obj); end
+  def self.default_connection_handler; end
+  def self.default_connection_handler=(val); end
+  def self.default_connection_handler?; end
+  def self.default_scope_override; end
+  def self.default_scope_override=(val); end
+  def self.default_scopes; end
+  def self.default_scopes=(val); end
+  def self.default_timezone; end
+  def self.default_timezone=(obj); end
+  def self.defined_enums; end
+  def self.defined_enums=(val); end
+  def self.defined_enums?; end
+  def self.dump_schema_after_migration; end
+  def self.dump_schema_after_migration=(obj); end
+  def self.dump_schemas; end
+  def self.dump_schemas=(obj); end
+  def self.error_on_ignored_order; end
+  def self.error_on_ignored_order=(obj); end
+  def self.implicit_order_column; end
+  def self.implicit_order_column=(val); end
+  def self.implicit_order_column?; end
+  def self.include_root_in_json; end
+  def self.include_root_in_json=(val); end
+  def self.include_root_in_json?; end
+  def self.index_nested_attribute_errors; end
+  def self.index_nested_attribute_errors=(obj); end
+  def self.internal_metadata_table_name; end
+  def self.internal_metadata_table_name=(val); end
+  def self.internal_metadata_table_name?; end
+  def self.local_stored_attributes; end
+  def self.local_stored_attributes=(arg0); end
+  def self.lock_optimistically; end
+  def self.lock_optimistically=(val); end
+  def self.lock_optimistically?; end
+  def self.logger; end
+  def self.logger=(obj); end
+  def self.maintain_test_schema; end
+  def self.maintain_test_schema=(obj); end
+  def self.nested_attributes_options; end
+  def self.nested_attributes_options=(val); end
+  def self.nested_attributes_options?; end
+  def self.partial_writes; end
+  def self.partial_writes=(val); end
+  def self.partial_writes?; end
+  def self.pluralize_table_names; end
+  def self.pluralize_table_names=(val); end
+  def self.pluralize_table_names?; end
+  def self.primary_key_prefix_type; end
+  def self.primary_key_prefix_type=(obj); end
+  def self.reading_role; end
+  def self.reading_role=(obj); end
+  def self.record_timestamps; end
+  def self.record_timestamps=(val); end
+  def self.record_timestamps?; end
+  def self.schema_format; end
+  def self.schema_format=(obj); end
+  def self.schema_migrations_table_name; end
+  def self.schema_migrations_table_name=(val); end
+  def self.schema_migrations_table_name?; end
+  def self.skip_time_zone_conversion_for_attributes; end
+  def self.skip_time_zone_conversion_for_attributes=(val); end
+  def self.skip_time_zone_conversion_for_attributes?; end
+  def self.store_full_sti_class; end
+  def self.store_full_sti_class=(val); end
+  def self.store_full_sti_class?; end
+  def self.table_name_prefix; end
+  def self.table_name_prefix=(val); end
+  def self.table_name_prefix?; end
+  def self.table_name_suffix; end
+  def self.table_name_suffix=(val); end
+  def self.table_name_suffix?; end
+  def self.time_zone_aware_attributes; end
+  def self.time_zone_aware_attributes=(obj); end
+  def self.time_zone_aware_types; end
+  def self.time_zone_aware_types=(val); end
+  def self.time_zone_aware_types?; end
+  def self.timestamped_migrations; end
+  def self.timestamped_migrations=(obj); end
+  def self.verbose_query_logs; end
+  def self.verbose_query_logs=(obj); end
+  def self.warn_on_records_fetched_greater_than; end
+  def self.warn_on_records_fetched_greater_than=(obj); end
+  def self.writing_role; end
+  def self.writing_role=(obj); end
+  def skip_time_zone_conversion_for_attributes; end
+  def skip_time_zone_conversion_for_attributes?; end
+  def store_full_sti_class; end
+  def store_full_sti_class?; end
+  def table_name_prefix; end
+  def table_name_prefix?; end
+  def table_name_suffix; end
+  def table_name_suffix?; end
+  def time_zone_aware_attributes; end
+  def time_zone_aware_types; end
+  def time_zone_aware_types?; end
+  def timestamped_migrations; end
+  def type_for_attribute(*args, &block); end
+  def validation_context; end
+  def validation_context=(arg0); end
+  def verbose_query_logs; end
+  def warn_on_records_fetched_greater_than; end
+  extend ActiveModel::AttributeMethods::ClassMethods
+  extend ActiveModel::Callbacks
+  extend ActiveModel::Conversion::ClassMethods
+  extend ActiveModel::Naming
+  extend ActiveModel::Naming
+  extend ActiveModel::Naming
+  extend ActiveModel::SecurePassword::ClassMethods
+  extend ActiveModel::Translation
+  extend ActiveModel::Validations::Callbacks::ClassMethods
+  extend ActiveModel::Validations::ClassMethods
+  extend ActiveModel::Validations::HelperMethods
+  extend ActiveRecord::Aggregations::ClassMethods
+  extend ActiveRecord::Associations::ClassMethods
+  extend ActiveRecord::AttributeDecorators::ClassMethods
+  extend ActiveRecord::AttributeMethods::ClassMethods
+  extend ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
+  extend ActiveRecord::AttributeMethods::Read::ClassMethods
+  extend ActiveRecord::AttributeMethods::Serialization::ClassMethods
+  extend ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
+  extend ActiveRecord::AttributeMethods::Write::ClassMethods
+  extend ActiveRecord::Attributes::ClassMethods
+  extend ActiveRecord::AutosaveAssociation::ClassMethods
+  extend ActiveRecord::ConnectionHandling
+  extend ActiveRecord::Core::ClassMethods
+  extend ActiveRecord::CounterCache::ClassMethods
+  extend ActiveRecord::DefineCallbacks::ClassMethods
+  extend ActiveRecord::Delegation::DelegateCache
+  extend ActiveRecord::DynamicMatchers
+  extend ActiveRecord::Enum
+  extend ActiveRecord::Explain
+  extend ActiveRecord::Inheritance::ClassMethods
+  extend ActiveRecord::Integration::ClassMethods
+  extend ActiveRecord::Locking::Optimistic::ClassMethods
+  extend ActiveRecord::ModelSchema::ClassMethods
+  extend ActiveRecord::NestedAttributes::ClassMethods
+  extend ActiveRecord::NoTouching::ClassMethods
+  extend ActiveRecord::Persistence::ClassMethods
+  extend ActiveRecord::QueryCache::ClassMethods
+  extend ActiveRecord::Querying
+  extend ActiveRecord::ReadonlyAttributes::ClassMethods
+  extend ActiveRecord::Reflection::ClassMethods
+  extend ActiveRecord::Sanitization::ClassMethods
+  extend ActiveRecord::Scoping::ClassMethods
+  extend ActiveRecord::Scoping::Default::ClassMethods
+  extend ActiveRecord::Scoping::Named::ClassMethods
+  extend ActiveRecord::SecureToken::ClassMethods
+  extend ActiveRecord::Store::ClassMethods
+  extend ActiveRecord::Suppressor::ClassMethods
+  extend ActiveRecord::Timestamp::ClassMethods
+  extend ActiveRecord::Transactions::ClassMethods
+  extend ActiveRecord::Translation
+  extend ActiveRecord::Validations::ClassMethods
+  extend ActiveSupport::Benchmarkable
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  extend ActiveSupport::DescendantsTracker
+  include ActiveModel::AttributeMethods
+  include ActiveModel::AttributeMethods
+  include ActiveModel::Conversion
+  include ActiveModel::Dirty
+  include ActiveModel::SecurePassword
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include ActiveModel::Validations::HelperMethods
+  include ActiveRecord::Associations
+  include ActiveRecord::AttributeAssignment
+  include ActiveRecord::AttributeDecorators
+  include ActiveRecord::AttributeMethods
+  include ActiveRecord::AttributeMethods::BeforeTypeCast
+  include ActiveRecord::AttributeMethods::Dirty
+  include ActiveRecord::AttributeMethods::PrimaryKey
+  include ActiveRecord::AttributeMethods::Query
+  include ActiveRecord::AttributeMethods::Read
+  include ActiveRecord::AttributeMethods::Serialization
+  include ActiveRecord::AttributeMethods::TimeZoneConversion
+  include ActiveRecord::AttributeMethods::Write
+  include ActiveRecord::Attributes
+  include ActiveRecord::AutosaveAssociation
+  include ActiveRecord::Base::GeneratedAssociationMethods
+  include ActiveRecord::Base::GeneratedAttributeMethods
+  include ActiveRecord::Callbacks
+  include ActiveRecord::Core
+  include ActiveRecord::CounterCache
+  include ActiveRecord::DefineCallbacks
+  include ActiveRecord::Inheritance
+  include ActiveRecord::Integration
+  include ActiveRecord::Locking::Optimistic
+  include ActiveRecord::Locking::Pessimistic
+  include ActiveRecord::ModelSchema
+  include ActiveRecord::NestedAttributes
+  include ActiveRecord::NoTouching
+  include ActiveRecord::Persistence
+  include ActiveRecord::ReadonlyAttributes
+  include ActiveRecord::Reflection
+  include ActiveRecord::Sanitization
+  include ActiveRecord::Scoping
+  include ActiveRecord::Scoping::Default
+  include ActiveRecord::Scoping::Named
+  include ActiveRecord::SecureToken
+  include ActiveRecord::Serialization
+  include ActiveRecord::Store
+  include ActiveRecord::Suppressor
+  include ActiveRecord::Timestamp
+  include ActiveRecord::TouchLater
+  include ActiveRecord::Transactions
+  include ActiveRecord::Validations
+  include ActiveSupport::Callbacks
+  include ActiveSupport::Callbacks
+end
+module ActiveRecord::Base::GeneratedAttributeMethods
+end
+module ActiveRecord::Base::GeneratedAssociationMethods
+end
+class ActiveRecord::ConnectionAdapters::ConnectionSpecification
+  def adapter_method; end
+  def config; end
+  def initialize(name, config, adapter_method); end
+  def initialize_dup(original); end
+  def name; end
+  def to_hash; end
+end
+class ActiveRecord::ConnectionAdapters::ConnectionSpecification::ConnectionUrlResolver
+  def database_from_path; end
+  def initialize(url); end
+  def query_hash; end
+  def raw_config; end
+  def to_hash; end
+  def uri; end
+  def uri_parser; end
+end
+class ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
+  def build_configuration_sentence; end
+  def configurations; end
+  def initialize(configurations); end
+  def resolve(config_or_env, pool_name = nil); end
+  def resolve_connection(config_or_env, pool_name = nil); end
+  def resolve_hash_connection(spec); end
+  def resolve_symbol_connection(env_name, pool_name); end
+  def resolve_url_connection(url); end
+  def spec(config); end
+end
+class ActiveRecord::ConnectionAdapters::StatementPool
+  def [](key); end
+  def []=(sql, stmt); end
+  def cache; end
+  def clear; end
+  def dealloc(stmt); end
+  def delete(key); end
+  def each(&block); end
+  def initialize(statement_limit = nil); end
+  def key?(key); end
+  def length; end
+  include Enumerable
+end
+module ActiveRecord::ConnectionAdapters::SQLite3
+end
+class ActiveRecord::ConnectionAdapters::SQLite3::ExplainPrettyPrinter
+  def pp(result); end
+end
+module ActiveRecord::ConnectionAdapters::SQLite3::Quoting
+  def _type_cast(value); end
+  def column_name_matcher; end
+  def column_name_with_order_matcher; end
+  def quote_column_name(name); end
+  def quote_string(s); end
+  def quote_table_name(name); end
+  def quote_table_name_for_assignment(table, attr); end
+  def quoted_binary(value); end
+  def quoted_false; end
+  def quoted_time(value); end
+  def quoted_true; end
+  def unquoted_false; end
+  def unquoted_true; end
+end
+module ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
+  def begin_db_transaction; end
+  def build_fixture_statements(fixture_set); end
+  def build_truncate_statement(table_name); end
+  def commit_db_transaction; end
+  def exec_delete(sql, name = nil, binds = nil); end
+  def exec_query(sql, name = nil, binds = nil, prepare: nil); end
+  def exec_rollback_db_transaction; end
+  def exec_update(sql, name = nil, binds = nil); end
+  def execute(sql, name = nil); end
+  def execute_batch(statements, name = nil); end
+  def last_inserted_id(result); end
+  def write_query?(sql); end
+end
+class ActiveRecord::ConnectionAdapters::SQLite3::SchemaCreation < ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+  def add_column_options!(sql, options); end
+end
+class ActiveRecord::ConnectionAdapters::IndexDefinition
+  def columns; end
+  def comment; end
+  def concise_options(options); end
+  def initialize(table, name, unique = nil, columns = nil, lengths: nil, orders: nil, opclasses: nil, where: nil, type: nil, using: nil, comment: nil); end
+  def lengths; end
+  def name; end
+  def opclasses; end
+  def orders; end
+  def table; end
+  def type; end
+  def unique; end
+  def using; end
+  def where; end
+end
+class ActiveRecord::ConnectionAdapters::ColumnDefinition < Struct
+  def collation; end
+  def collation=(value); end
+  def comment; end
+  def comment=(value); end
+  def default; end
+  def default=(value); end
+  def limit; end
+  def limit=(value); end
+  def name; end
+  def name=(_); end
+  def null; end
+  def null=(value); end
+  def options; end
+  def options=(_); end
+  def precision; end
+  def precision=(value); end
+  def primary_key?; end
+  def scale; end
+  def scale=(value); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def sql_type; end
+  def sql_type=(_); end
+  def type; end
+  def type=(_); end
+end
+class ActiveRecord::ConnectionAdapters::AddColumnDefinition < Struct
+  def column; end
+  def column=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < Struct
+  def column; end
+  def column=(_); end
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < Struct
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < Struct
+  def column; end
+  def custom_primary_key?; end
+  def default_primary_key; end
+  def defined_for?(to_table: nil, **options); end
+  def export_name_on_schema_dump?; end
+  def from_table; end
+  def from_table=(_); end
+  def name; end
+  def on_delete; end
+  def on_update; end
+  def options; end
+  def options=(_); end
+  def primary_key; end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def to_table; end
+  def to_table=(_); end
+  def validate?; end
+  def validated?; end
+end
+class ActiveRecord::ConnectionAdapters::ReferenceDefinition
+  def add_to(table); end
+  def as_options(value); end
+  def column_name; end
+  def column_names; end
+  def columns; end
+  def foreign_key; end
+  def foreign_key_options; end
+  def foreign_table_name; end
+  def index; end
+  def index_options; end
+  def initialize(name, polymorphic: nil, index: nil, foreign_key: nil, type: nil, **options); end
+  def name; end
+  def options; end
+  def polymorphic; end
+  def polymorphic_options; end
+  def type; end
+end
+module ActiveRecord::ConnectionAdapters::ColumnMethods
+  def primary_key(name, type = nil, **options); end
+  extend ActiveSupport::Concern
+end
+module ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
+  def define_column_methods(*column_types); end
+end
+class ActiveRecord::ConnectionAdapters::TableDefinition
+  def [](name); end
+  def aliased_types(name, fallback); end
+  def as; end
+  def belongs_to(*args, **options); end
+  def bigint(*names, **options); end
+  def binary(*names, **options); end
+  def boolean(*names, **options); end
+  def column(name, type, **options); end
+  def columns; end
+  def comment; end
+  def create_column_definition(name, type, options); end
+  def date(*names, **options); end
+  def datetime(*names, **options); end
+  def decimal(*names, **options); end
+  def float(*names, **options); end
+  def foreign_key(table_name, **options); end
+  def foreign_keys; end
+  def if_not_exists; end
+  def index(column_name, options = nil); end
+  def indexes; end
+  def initialize(conn, name, temporary: nil, if_not_exists: nil, options: nil, as: nil, comment: nil, **arg7); end
+  def integer(*names, **options); end
+  def integer_like_primary_key?(type, options); end
+  def integer_like_primary_key_type(type, options); end
+  def json(*names, **options); end
+  def name; end
+  def new_column_definition(name, type, **options); end
+  def numeric(*names, **options); end
+  def options; end
+  def primary_keys(name = nil); end
+  def references(*args, **options); end
+  def remove_column(name); end
+  def string(*names, **options); end
+  def temporary; end
+  def text(*names, **options); end
+  def time(*names, **options); end
+  def timestamp(*names, **options); end
+  def timestamps(**options); end
+  def virtual(*names, **options); end
+  extend ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
+  include ActiveRecord::ConnectionAdapters::ColumnMethods
+end
+class ActiveRecord::ConnectionAdapters::AlterTable
+  def add_column(name, type, **options); end
+  def add_foreign_key(to_table, options); end
+  def adds; end
+  def drop_foreign_key(name); end
+  def foreign_key_adds; end
+  def foreign_key_drops; end
+  def initialize(td); end
+  def name; end
+end
+class ActiveRecord::ConnectionAdapters::Table
+  def belongs_to(*args, **options); end
+  def bigint(*names, **options); end
+  def binary(*names, **options); end
+  def boolean(*names, **options); end
+  def change(column_name, type, options = nil); end
+  def change_default(column_name, default_or_changes); end
+  def column(column_name, type, **options); end
+  def column_exists?(column_name, type = nil, **options); end
+  def date(*names, **options); end
+  def datetime(*names, **options); end
+  def decimal(*names, **options); end
+  def float(*names, **options); end
+  def foreign_key(*args, **options); end
+  def foreign_key_exists?(*args, **options); end
+  def index(column_name, options = nil); end
+  def index_exists?(column_name, options = nil); end
+  def initialize(table_name, base); end
+  def integer(*names, **options); end
+  def json(*names, **options); end
+  def name; end
+  def numeric(*names, **options); end
+  def references(*args, **options); end
+  def remove(*column_names); end
+  def remove_belongs_to(*args, **options); end
+  def remove_foreign_key(*args, **options); end
+  def remove_index(options = nil); end
+  def remove_references(*args, **options); end
+  def remove_timestamps(**options); end
+  def rename(column_name, new_column_name); end
+  def rename_index(index_name, new_index_name); end
+  def string(*names, **options); end
+  def text(*names, **options); end
+  def time(*names, **options); end
+  def timestamp(*names, **options); end
+  def timestamps(**options); end
+  def virtual(*names, **options); end
+  extend ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
+  include ActiveRecord::ConnectionAdapters::ColumnMethods
+end
+class ActiveRecord::ConnectionAdapters::SQLite3::TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+  def belongs_to(*args, **options); end
+  def integer_like_primary_key_type(type, options); end
+  def references(*args, **options); end
+end
+class ActiveRecord::ConnectionAdapters::SQLite3::SchemaDumper < ActiveRecord::ConnectionAdapters::SchemaDumper
+  def default_primary_key?(column); end
+  def explicit_primary_key_default?(column); end
+end
+module ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
+  def add_foreign_key(from_table, to_table, **options); end
+  def create_schema_dumper(options); end
+  def create_table_definition(*args, **options); end
+  def data_source_sql(name = nil, type: nil); end
+  def indexes(table_name); end
+  def new_column_from_field(table_name, field); end
+  def quoted_scope(name = nil, type: nil); end
+  def remove_foreign_key(from_table, to_table = nil, **options); end
+  def schema_creation; end
+end
+class ActiveRecord::ConnectionAdapters::SQLite3Adapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+  def active?; end
+  def add_belongs_to(table_name, ref_name, **options); end
+  def add_column(table_name, column_name, type, **options); end
+  def add_reference(table_name, ref_name, **options); end
+  def allowed_index_name_length; end
+  def alter_table(table_name, foreign_keys = nil, **options); end
+  def arel_visitor; end
+  def bind_params_length; end
+  def build_insert_sql(insert); end
+  def build_statement_pool; end
+  def change_column(table_name, column_name, type, options = nil); end
+  def change_column_default(table_name, column_name, default_or_changes); end
+  def change_column_null(table_name, column_name, null, default = nil); end
+  def check_version; end
+  def column_definitions(table_name); end
+  def configure_connection; end
+  def connect; end
+  def copy_table(from, to, options = nil); end
+  def copy_table_contents(from, to, columns, rename = nil); end
+  def copy_table_indexes(from, to, rename = nil); end
+  def disable_referential_integrity; end
+  def disconnect!; end
+  def encoding; end
+  def explain(arel, binds = nil); end
+  def foreign_keys(table_name); end
+  def get_database_version; end
+  def initialize(connection, logger, connection_options, config); end
+  def initialize_type_map(m = nil); end
+  def invalid_alter_table_type?(type, options); end
+  def move_table(from, to, options = nil, &block); end
+  def native_database_types; end
+  def primary_keys(table_name); end
+  def reconnect!; end
+  def remove_column(table_name, column_name, type = nil, **options); end
+  def remove_index(table_name, options = nil); end
+  def rename_column(table_name, column_name, new_column_name); end
+  def rename_table(table_name, new_name); end
+  def requires_reloading?; end
+  def self.database_exists?(config); end
+  def self.represent_boolean_as_integer=(value); end
+  def supports_common_table_expressions?; end
+  def supports_datetime_with_precision?; end
+  def supports_ddl_transactions?; end
+  def supports_explain?; end
+  def supports_expression_index?; end
+  def supports_foreign_keys?; end
+  def supports_index_sort_order?; end
+  def supports_insert_conflict_target?; end
+  def supports_insert_on_conflict?; end
+  def supports_insert_on_duplicate_skip?; end
+  def supports_insert_on_duplicate_update?; end
+  def supports_json?; end
+  def supports_lazy_transactions?; end
+  def supports_partial_index?; end
+  def supports_savepoints?; end
+  def supports_views?; end
+  def table_structure(table_name); end
+  def table_structure_with_collation(table_name, basic_structure); end
+  def translate_exception(exception, message:, sql:, binds:); end
+  include ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
+  include ActiveRecord::ConnectionAdapters::SQLite3::Quoting
+  include ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
+end
+class ActiveRecord::ConnectionAdapters::SQLite3Adapter::StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
+  def dealloc(stmt); end
+end
+class ActiveRecord::ConnectionAdapters::SQLite3Adapter::SQLite3Integer < ActiveModel::Type::Integer
+  def _limit; end
+end
+class ActiveRecord::Schema < ActiveRecord::Migration::Current
+  def define(info, &block); end
+  def self.define(info = nil, &block); end
+end
+class ActiveRecord::ConnectionAdapters::TransactionState
+  def add_child(state); end
+  def commit!; end
+  def committed?; end
+  def completed?; end
+  def finalized?; end
+  def full_commit!; end
+  def full_rollback!; end
+  def fully_committed?; end
+  def fully_completed?; end
+  def fully_rolledback?; end
+  def initialize(state = nil); end
+  def nullify!; end
+  def rollback!; end
+  def rolledback?; end
+end
+class ActiveRecord::ConnectionAdapters::NullTransaction
+  def add_record(record); end
+  def closed?; end
+  def initialize; end
+  def joinable?; end
+  def open?; end
+  def state; end
+end
+class ActiveRecord::ConnectionAdapters::Transaction
+  def add_record(record); end
+  def before_commit_records; end
+  def closed?; end
+  def commit_records; end
+  def connection; end
+  def full_rollback?; end
+  def initialize(connection, options, run_commit_callbacks: nil); end
+  def isolation_level; end
+  def joinable?; end
+  def materialize!; end
+  def materialized?; end
+  def open?; end
+  def records; end
+  def rollback_records; end
+  def savepoint_name; end
+  def state; end
+end
+class ActiveRecord::ConnectionAdapters::SavepointTransaction < ActiveRecord::ConnectionAdapters::Transaction
+  def commit; end
+  def full_rollback?; end
+  def initialize(connection, savepoint_name, parent_transaction, *args, **options); end
+  def materialize!; end
+  def rollback; end
+end
+class ActiveRecord::ConnectionAdapters::RealTransaction < ActiveRecord::ConnectionAdapters::Transaction
+  def commit; end
+  def materialize!; end
+  def rollback; end
+end
+class ActiveRecord::ConnectionAdapters::TransactionManager
+  def after_failure_actions(transaction, error); end
+  def begin_transaction(options = nil); end
+  def commit_transaction; end
+  def current_transaction; end
+  def disable_lazy_transactions!; end
+  def enable_lazy_transactions!; end
+  def initialize(connection); end
+  def lazy_transactions_enabled?; end
+  def materialize_transactions; end
+  def open_transactions; end
+  def rollback_transaction(transaction = nil); end
+  def within_new_transaction(options = nil); end
+end
+class ActiveRecord::Result
+  def [](idx); end
+  def cast_values(type_overrides = nil); end
+  def collect!; end
+  def column_type(name, type_overrides = nil); end
+  def column_types; end
+  def columns; end
+  def each; end
+  def empty?; end
+  def first; end
+  def hash_rows; end
+  def includes_column?(name); end
+  def initialize(columns, rows, column_types = nil); end
+  def initialize_copy(other); end
+  def last; end
+  def length; end
+  def map!; end
+  def rows; end
+  def to_a; end
+  def to_ary; end
+  def to_hash; end
+  include Enumerable
+end
+module ActiveRecord::FinderMethods
+  def apply_join_dependency(eager_loading: nil); end
+  def construct_relation_for_exists(conditions); end
+  def exists?(conditions = nil); end
+  def fifth!; end
+  def fifth; end
+  def find(*args); end
+  def find_by!(arg, *args); end
+  def find_by(arg, *args); end
+  def find_last(limit); end
+  def find_nth(index); end
+  def find_nth_from_last(index); end
+  def find_nth_with_limit(index, limit); end
+  def find_one(id); end
+  def find_some(ids); end
+  def find_some_ordered(ids); end
+  def find_take; end
+  def find_take_with_limit(limit); end
+  def find_with_ids(*ids); end
+  def first!; end
+  def first(limit = nil); end
+  def forty_two!; end
+  def forty_two; end
+  def fourth!; end
+  def fourth; end
+  def last!; end
+  def last(limit = nil); end
+  def limited_ids_for(relation); end
+  def offset_index; end
+  def ordered_relation; end
+  def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = nil, not_found_ids = nil); end
+  def second!; end
+  def second; end
+  def second_to_last!; end
+  def second_to_last; end
+  def take!; end
+  def take(limit = nil); end
+  def third!; end
+  def third; end
+  def third_to_last!; end
+  def third_to_last; end
+  def using_limitable_reflections?(reflections); end
+end
+module ActiveRecord::Calculations
+  def aggregate_column(column_name); end
+  def average(column_name); end
+  def build_count_subquery(relation, column_name, distinct); end
+  def calculate(operation, column_name); end
+  def column_alias_for(field); end
+  def count(column_name = nil); end
+  def distinct_select?(column_name); end
+  def execute_grouped_calculation(operation, column_name, distinct); end
+  def execute_simple_calculation(operation, column_name, distinct); end
+  def has_include?(column_name); end
+  def ids; end
+  def maximum(column_name); end
+  def minimum(column_name); end
+  def operation_over_aggregate_column(column, operation, distinct); end
+  def perform_calculation(operation, column_name); end
+  def pick(*column_names); end
+  def pluck(*column_names); end
+  def select_for_count; end
+  def sum(column_name = nil); end
+  def type_cast_calculated_value(value, type, operation = nil); end
+  def type_for(field, &block); end
+end
+class ActiveRecord::Relation
+  def ==(other); end
+  def _deprecated_scope_block(name, &block); end
+  def _deprecated_scope_source; end
+  def _deprecated_scope_source=(arg0); end
+  def _deprecated_spawn(name); end
+  def _exec_scope(name, *args, &block); end
+  def _increment_attribute(attribute, value = nil); end
+  def _scoping(scope); end
+  def _substitute_values(values); end
+  def alias_tracker(joins = nil, aliases = nil); end
+  def already_in_scope?; end
+  def any?; end
+  def arel_attribute(name); end
+  def bind_attribute(name, value); end
+  def blank?; end
+  def build(attributes = nil, &block); end
+  def build_preloader; end
+  def cache_key(timestamp_column = nil); end
+  def cache_key_with_version; end
+  def cache_version(timestamp_column = nil); end
+  def compute_cache_key(timestamp_column = nil); end
+  def compute_cache_version(timestamp_column); end
+  def create!(attributes = nil, &block); end
+  def create(attributes = nil, &block); end
+  def create_or_find_by!(attributes, &block); end
+  def create_or_find_by(attributes, &block); end
+  def delete_all; end
+  def delete_by(*args); end
+  def destroy_all; end
+  def destroy_by(*args); end
+  def eager_loading?; end
+  def empty?; end
+  def empty_scope?; end
+  def encode_with(coder); end
+  def exec_queries(&block); end
+  def explain; end
+  def find_or_create_by!(attributes, &block); end
+  def find_or_create_by(attributes, &block); end
+  def find_or_initialize_by(attributes, &block); end
+  def first_or_create!(attributes = nil, &block); end
+  def first_or_create(attributes = nil, &block); end
+  def first_or_initialize(attributes = nil, &block); end
+  def has_limit_or_offset?; end
+  def initialize(klass, table: nil, predicate_builder: nil, values: nil); end
+  def initialize_copy(other); end
+  def inspect; end
+  def joined_includes_values; end
+  def klass; end
+  def load(&block); end
+  def load_records(records); end
+  def loaded; end
+  def loaded?; end
+  def locked?; end
+  def many?; end
+  def model; end
+  def new(attributes = nil, &block); end
+  def none?; end
+  def null_relation?; end
+  def one?; end
+  def predicate_builder; end
+  def preload_associations(records); end
+  def pretty_print(q); end
+  def records; end
+  def references_eager_loaded_tables?; end
+  def reload; end
+  def reset; end
+  def scope_for_create; end
+  def scoping; end
+  def size; end
+  def skip_preloading_value; end
+  def skip_preloading_value=(arg0); end
+  def skip_query_cache_if_necessary; end
+  def table; end
+  def tables_in_string(string); end
+  def to_a; end
+  def to_ary; end
+  def to_sql; end
+  def touch_all(*names, time: nil); end
+  def update(id = nil, attributes); end
+  def update_all(updates); end
+  def update_counters(counters); end
+  def values; end
+  def where_values_hash(relation_table_name = nil); end
+  extend ActiveRecord::Delegation::ClassMethods
+  include ActiveRecord::FinderMethods
+  include Enumerable
+end
+class ActiveRecord::Relation::HashMerger
+  def hash; end
+  def initialize(relation, hash); end
+  def merge; end
+  def other; end
+  def relation; end
+end
+class ActiveRecord::Relation::Merger
+  def initialize(relation, other); end
+  def merge; end
+  def merge_clauses; end
+  def merge_joins; end
+  def merge_multi_values; end
+  def merge_outer_joins; end
+  def merge_preloads; end
+  def merge_single_values; end
+  def normal_values; end
+  def other; end
+  def relation; end
+  def replace_from_clause?; end
+  def values; end
+end
+module ActiveRecord::SpawnMethods
+  def except(*skips); end
+  def merge!(other); end
+  def merge(other); end
+  def only(*onlies); end
+  def relation_with(values); end
+  def spawn; end
+end
+class ActiveRecord::Relation::FromClause
+  def ==(other); end
+  def empty?; end
+  def initialize(value, name); end
+  def merge(other); end
+  def name; end
+  def self.empty; end
+  def value; end
+end
+class ActiveRecord::Relation::QueryAttribute < ActiveModel::Attribute
+  def infinite?; end
+  def infinity?(value); end
+  def nil?; end
+  def type_cast(value); end
+  def unboundable?; end
+  def value_for_database; end
+  def with_cast_value(value); end
+end
+class ActiveRecord::Relation::WhereClause
+  def +(other); end
+  def -(other); end
+  def ==(other); end
+  def any?(*args, &block); end
+  def ast; end
+  def empty?(*args, &block); end
+  def equalities(predicates); end
+  def equality_node?(node); end
+  def except(*columns); end
+  def except_predicates(columns); end
+  def extract_node_value(node); end
+  def initialize(predicates); end
+  def invert(as = nil); end
+  def invert_predicate(node); end
+  def merge(other); end
+  def non_empty_predicates; end
+  def or(other); end
+  def predicates; end
+  def predicates_unreferenced_by(other); end
+  def predicates_with_wrapped_sql_literals; end
+  def referenced_columns; end
+  def self.empty; end
+  def to_h(table_name = nil); end
+  def wrap_sql_literal(node); end
+end
+class ActiveRecord::Relation::WhereClauseFactory
+  def build(opts, other); end
+  def initialize(klass, predicate_builder); end
+  def klass; end
+  def predicate_builder; end
+end
+module ActiveRecord::QueryMethods
+  def _select!(*fields); end
+  def annotate!(*args); end
+  def annotate(*args); end
+  def annotate_values; end
+  def annotate_values=(value); end
+  def arel(aliases = nil); end
+  def arel_column(field); end
+  def arel_columns(columns); end
+  def assert_mutability!; end
+  def build_arel(aliases); end
+  def build_from; end
+  def build_join_query(manager, buckets, join_type, aliases); end
+  def build_joins(manager, joins, aliases); end
+  def build_left_outer_joins(manager, outer_joins, aliases); end
+  def build_order(arel); end
+  def build_select(arel); end
+  def build_subquery(subquery_alias, select_value); end
+  def check_if_method_has_arguments!(method_name, args); end
+  def construct_join_dependency(associations, join_type); end
+  def create_with!(value); end
+  def create_with(value); end
+  def create_with_value; end
+  def create_with_value=(value); end
+  def distinct!(value = nil); end
+  def distinct(value = nil); end
+  def distinct_value; end
+  def distinct_value=(value); end
+  def does_not_support_reverse?(order); end
+  def eager_load!(*args); end
+  def eager_load(*args); end
+  def eager_load_values; end
+  def eager_load_values=(value); end
+  def extending!(*modules, &block); end
+  def extending(*modules, &block); end
+  def extending_values; end
+  def extending_values=(value); end
+  def extensions; end
+  def extract_associated(association); end
+  def from!(value, subquery_name = nil); end
+  def from(value, subquery_name = nil); end
+  def from_clause; end
+  def from_clause=(value); end
+  def group!(*args); end
+  def group(*args); end
+  def group_values; end
+  def group_values=(value); end
+  def having!(opts, *rest); end
+  def having(opts, *rest); end
+  def having_clause; end
+  def having_clause=(value); end
+  def having_clause_factory; end
+  def includes!(*args); end
+  def includes(*args); end
+  def includes_values; end
+  def includes_values=(value); end
+  def joins!(*args); end
+  def joins(*args); end
+  def joins_values; end
+  def joins_values=(value); end
+  def left_joins(*args); end
+  def left_outer_joins!(*args); end
+  def left_outer_joins(*args); end
+  def left_outer_joins_values; end
+  def left_outer_joins_values=(value); end
+  def limit!(value); end
+  def limit(value); end
+  def limit_value; end
+  def limit_value=(value); end
+  def lock!(locks = nil); end
+  def lock(locks = nil); end
+  def lock_value; end
+  def lock_value=(value); end
+  def none!; end
+  def none; end
+  def offset!(value); end
+  def offset(value); end
+  def offset_value; end
+  def offset_value=(value); end
+  def optimizer_hints!(*args); end
+  def optimizer_hints(*args); end
+  def optimizer_hints_values; end
+  def optimizer_hints_values=(value); end
+  def or!(other); end
+  def or(other); end
+  def order!(*args); end
+  def order(*args); end
+  def order_column(field); end
+  def order_values; end
+  def order_values=(value); end
+  def preload!(*args); end
+  def preload(*args); end
+  def preload_values; end
+  def preload_values=(value); end
+  def preprocess_order_args(order_args); end
+  def readonly!(value = nil); end
+  def readonly(value = nil); end
+  def readonly_value; end
+  def readonly_value=(value); end
+  def references!(*table_names); end
+  def references(*table_names); end
+  def references_values; end
+  def references_values=(value); end
+  def reorder!(*args); end
+  def reorder(*args); end
+  def reordering_value; end
+  def reordering_value=(value); end
+  def reselect!(*args); end
+  def reselect(*args); end
+  def reverse_order!; end
+  def reverse_order; end
+  def reverse_order_value; end
+  def reverse_order_value=(value); end
+  def reverse_sql_order(order_query); end
+  def rewhere(conditions); end
+  def select(*fields); end
+  def select_association_list(associations); end
+  def select_values; end
+  def select_values=(value); end
+  def skip_preloading!; end
+  def skip_query_cache!(value = nil); end
+  def skip_query_cache_value; end
+  def skip_query_cache_value=(value); end
+  def structurally_incompatible_values_for_or(other); end
+  def table_name_matches?(from); end
+  def unscope!(*args); end
+  def unscope(*args); end
+  def unscope_values; end
+  def unscope_values=(value); end
+  def valid_association_list(associations); end
+  def validate_order_args(args); end
+  def where!(opts, *rest); end
+  def where(opts = nil, *rest); end
+  def where_clause; end
+  def where_clause=(value); end
+  def where_clause_factory; end
+  extend ActiveSupport::Concern
+  include ActiveModel::ForbiddenAttributesProtection
+end
+class ActiveRecord::QueryMethods::WhereChain
+  def initialize(scope); end
+  def not(opts, *rest); end
+  def not_behaves_as_nor?(opts); end
+  include ActiveModel::ForbiddenAttributesProtection
+end
+module ActiveRecord::Batches
+  def act_on_ignored_order(error_on_ignore); end
+  def apply_finish_limit(relation, finish); end
+  def apply_limits(relation, start, finish); end
+  def apply_start_limit(relation, start); end
+  def batch_order; end
+  def find_each(start: nil, finish: nil, batch_size: nil, error_on_ignore: nil); end
+  def find_in_batches(start: nil, finish: nil, batch_size: nil, error_on_ignore: nil); end
+  def in_batches(of: nil, start: nil, finish: nil, load: nil, error_on_ignore: nil); end
+end
+class ActiveRecord::Batches::BatchEnumerator
+  def delete_all(*args, &block); end
+  def destroy_all(*args, &block); end
+  def each; end
+  def each_record; end
+  def initialize(relation:, of: nil, start: nil, finish: nil); end
+  def update_all(*args, &block); end
+  include Enumerable
+end
+class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
+  def <<(*records); end
+  def ==(other); end
+  def _select!(*args, &block); end
+  def annotate!(*args, &block); end
+  def annotate(*args, &block); end
+  def annotate_values(*args, &block); end
+  def annotate_values=(arg); end
+  def append(*records); end
+  def arel(*args, &block); end
+  def build(attributes = nil, &block); end
+  def calculate(operation, column_name); end
+  def clear; end
+  def concat(*records); end
+  def construct_join_dependency(*args, &block); end
+  def create!(attributes = nil, &block); end
+  def create(attributes = nil, &block); end
+  def create_with!(*args, &block); end
+  def create_with(*args, &block); end
+  def create_with_value(*args, &block); end
+  def create_with_value=(arg); end
+  def delete(*records); end
+  def delete_all(dependent = nil); end
+  def destroy(*records); end
+  def destroy_all; end
+  def distinct!(*args, &block); end
+  def distinct(*args, &block); end
+  def distinct_value(*args, &block); end
+  def distinct_value=(arg); end
+  def eager_load!(*args, &block); end
+  def eager_load(*args, &block); end
+  def eager_load_values(*args, &block); end
+  def eager_load_values=(arg); end
+  def empty?; end
+  def except(*args, &block); end
+  def exec_queries; end
+  def extending!(*args, &block); end
+  def extending(*args, &block); end
+  def extending_values(*args, &block); end
+  def extending_values=(arg); end
+  def extensions(*args, &block); end
+  def extract_associated(*args, &block); end
+  def find(*args); end
+  def find_from_target?; end
+  def find_nth_from_last(index); end
+  def find_nth_with_limit(index, limit); end
+  def from!(*args, &block); end
+  def from(*args, &block); end
+  def from_clause(*args, &block); end
+  def from_clause=(arg); end
+  def group!(*args, &block); end
+  def group(*args, &block); end
+  def group_values(*args, &block); end
+  def group_values=(arg); end
+  def having!(*args, &block); end
+  def having(*args, &block); end
+  def having_clause(*args, &block); end
+  def having_clause=(arg); end
+  def include?(record); end
+  def includes!(*args, &block); end
+  def includes(*args, &block); end
+  def includes_values(*args, &block); end
+  def includes_values=(arg); end
+  def initialize(klass, association, **arg2); end
+  def joins!(*args, &block); end
+  def joins(*args, &block); end
+  def joins_values(*args, &block); end
+  def joins_values=(arg); end
+  def last(limit = nil); end
+  def left_joins(*args, &block); end
+  def left_outer_joins!(*args, &block); end
+  def left_outer_joins(*args, &block); end
+  def left_outer_joins_values(*args, &block); end
+  def left_outer_joins_values=(arg); end
+  def limit!(*args, &block); end
+  def limit(*args, &block); end
+  def limit_value(*args, &block); end
+  def limit_value=(arg); end
+  def load_target; end
+  def loaded?; end
+  def lock!(*args, &block); end
+  def lock(*args, &block); end
+  def lock_value(*args, &block); end
+  def lock_value=(arg); end
+  def merge!(*args, &block); end
+  def merge(*args, &block); end
+  def new(attributes = nil, &block); end
+  def none!(*args, &block); end
+  def none(*args, &block); end
+  def null_scope?; end
+  def offset!(*args, &block); end
+  def offset(*args, &block); end
+  def offset_value(*args, &block); end
+  def offset_value=(arg); end
+  def only(*args, &block); end
+  def optimizer_hints!(*args, &block); end
+  def optimizer_hints(*args, &block); end
+  def optimizer_hints_values(*args, &block); end
+  def optimizer_hints_values=(arg); end
+  def or!(*args, &block); end
+  def or(*args, &block); end
+  def order!(*args, &block); end
+  def order(*args, &block); end
+  def order_values(*args, &block); end
+  def order_values=(arg); end
+  def pluck(*column_names); end
+  def preload!(*args, &block); end
+  def preload(*args, &block); end
+  def preload_values(*args, &block); end
+  def preload_values=(arg); end
+  def prepend(*args); end
+  def proxy_association; end
+  def push(*records); end
+  def readonly!(*args, &block); end
+  def readonly(*args, &block); end
+  def readonly_value(*args, &block); end
+  def readonly_value=(arg); end
+  def records; end
+  def references!(*args, &block); end
+  def references(*args, &block); end
+  def references_values(*args, &block); end
+  def references_values=(arg); end
+  def reload; end
+  def reorder!(*args, &block); end
+  def reorder(*args, &block); end
+  def reordering_value(*args, &block); end
+  def reordering_value=(arg); end
+  def replace(other_array); end
+  def reselect!(*args, &block); end
+  def reselect(*args, &block); end
+  def reset; end
+  def reset_scope; end
+  def reverse_order!(*args, &block); end
+  def reverse_order(*args, &block); end
+  def reverse_order_value(*args, &block); end
+  def reverse_order_value=(arg); end
+  def rewhere(*args, &block); end
+  def scope; end
+  def scoping(*args, &block); end
+  def select_values(*args, &block); end
+  def select_values=(arg); end
+  def size; end
+  def skip_preloading!(*args, &block); end
+  def skip_query_cache!(*args, &block); end
+  def skip_query_cache_value(*args, &block); end
+  def skip_query_cache_value=(arg); end
+  def spawn(*args, &block); end
+  def take(limit = nil); end
+  def target; end
+  def unscope!(*args, &block); end
+  def unscope(*args, &block); end
+  def unscope_values(*args, &block); end
+  def unscope_values=(arg); end
+  def values(*args, &block); end
+  def where!(*args, &block); end
+  def where(*args, &block); end
+  def where_clause(*args, &block); end
+  def where_clause=(arg); end
+end
+class ActiveRecord::AssociationRelation < ActiveRecord::Relation
+  def ==(other); end
+  def build(attributes = nil, &block); end
+  def create!(attributes = nil, &block); end
+  def create(attributes = nil, &block); end
+  def exec_queries; end
+  def initialize(klass, association, **arg2); end
+  def new(attributes = nil, &block); end
+  def proxy_association; end
+end
+module ActiveRecord::InternalMetadata::GeneratedAttributeMethods
+end
+class ActiveRecord::InternalMetadata < ActiveRecord::Base
+  def self.[](key); end
+  def self.[]=(key, value); end
+  def self._internal?; end
+  def self._validators; end
+  def self.attribute_type_decorations; end
+  def self.create_table; end
+  def self.defined_enums; end
+  def self.drop_table; end
+  def self.primary_key; end
+  def self.table_exists?; end
+  def self.table_name; end
+  include ActiveRecord::InternalMetadata::GeneratedAssociationMethods
+  include ActiveRecord::InternalMetadata::GeneratedAttributeMethods
+end
+module ActiveRecord::InternalMetadata::GeneratedAssociationMethods
+end
+class ActiveRecord::InternalMetadata::ActiveRecord_Relation < ActiveRecord::Relation
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::InternalMetadata::GeneratedRelationMethods
+end
+module ActiveRecord::InternalMetadata::GeneratedRelationMethods
+end
+class ActiveRecord::InternalMetadata::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::InternalMetadata::GeneratedRelationMethods
+end
+class ActiveRecord::InternalMetadata::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::InternalMetadata::GeneratedRelationMethods
+end
+module ActiveRecord::SchemaMigration::GeneratedAttributeMethods
+end
+class ActiveRecord::SchemaMigration < ActiveRecord::Base
+  def self._internal?; end
+  def self._validators; end
+  def self.all_versions; end
+  def self.attribute_type_decorations; end
+  def self.create_table; end
+  def self.defined_enums; end
+  def self.drop_table; end
+  def self.normalize_migration_number(number); end
+  def self.normalized_versions; end
+  def self.primary_key; end
+  def self.table_exists?; end
+  def self.table_name; end
+  def version; end
+  include ActiveRecord::SchemaMigration::GeneratedAssociationMethods
+  include ActiveRecord::SchemaMigration::GeneratedAttributeMethods
+end
+module ActiveRecord::SchemaMigration::GeneratedAssociationMethods
+end
+class ActiveRecord::SchemaMigration::ActiveRecord_Relation < ActiveRecord::Relation
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::SchemaMigration::GeneratedRelationMethods
+end
+module ActiveRecord::SchemaMigration::GeneratedRelationMethods
+end
+class ActiveRecord::SchemaMigration::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::SchemaMigration::GeneratedRelationMethods
+end
+class ActiveRecord::SchemaMigration::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation
+  extend ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
+  include ActiveRecord::Delegation::ClassSpecificRelation
+  include ActiveRecord::SchemaMigration::GeneratedRelationMethods
+end
+class ActiveRecord::PredicateBuilder
+  def build(attribute, value); end
+  def build_bind_attribute(column_name, value); end
+  def build_from_hash(attributes); end
+  def convert_dot_notation_to_hash(attributes); end
+  def expand_from_hash(attributes); end
+  def handler_for(object); end
+  def initialize(table); end
+  def register_handler(klass, handler); end
+  def resolve_column_aliases(*args, &block); end
+  def self.references(attributes); end
+  def table; end
+end
+class ActiveRecord::PredicateBuilder::ArrayHandler
+  def call(attribute, value); end
+  def initialize(predicate_builder); end
+  def predicate_builder; end
+end
+module ActiveRecord::PredicateBuilder::ArrayHandler::NullPredicate
+  def self.or(other); end
+end
+class ActiveRecord::PredicateBuilder::BaseHandler
+  def call(attribute, value); end
+  def initialize(predicate_builder); end
+  def predicate_builder; end
+end
+class ActiveRecord::PredicateBuilder::BasicObjectHandler
+  def call(attribute, value); end
+  def initialize(predicate_builder); end
+  def predicate_builder; end
+end
+class ActiveRecord::PredicateBuilder::RangeHandler
+  def call(attribute, value); end
+  def initialize(predicate_builder); end
+  def predicate_builder; end
+end
+class ActiveRecord::PredicateBuilder::RangeHandler::RangeWithBinds < Struct
+  def begin; end
+  def begin=(_); end
+  def end; end
+  def end=(_); end
+  def exclude_end?; end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveRecord::PredicateBuilder::RelationHandler
+  def call(attribute, value); end
+end
+class ActiveRecord::PredicateBuilder::AssociationQueryValue
+  def associated_table; end
+  def convert_to_id(value); end
+  def ids; end
+  def initialize(associated_table, value); end
+  def primary_key; end
+  def queries; end
+  def value; end
+end
+class ActiveRecord::PredicateBuilder::PolymorphicArrayValue
+  def associated_table; end
+  def convert_to_id(value); end
+  def initialize(associated_table, values); end
+  def klass(value); end
+  def primary_key(value); end
+  def queries; end
+  def type_to_ids_mapping; end
+  def values; end
+end
+class ActiveRecord::TableMetadata
+  def aggregated_with?(aggregation_name); end
+  def arel_attribute(column_name); end
+  def arel_table; end
+  def associated_predicate_builder(table_name); end
+  def associated_table(table_name); end
+  def associated_with?(association_name); end
+  def association; end
+  def association_foreign_key(*args, &block); end
+  def association_foreign_type(*args, &block); end
+  def association_join_foreign_key(*args, &block); end
+  def association_join_primary_key(*args, &block); end
+  def has_column?(column_name); end
+  def initialize(klass, arel_table, association = nil, types = nil); end
+  def klass; end
+  def polymorphic_association?; end
+  def predicate_builder; end
+  def reflect_on_aggregation(aggregation_name); end
+  def resolve_column_aliases(hash); end
+  def type(column_name); end
+  def types; end
+end
+class ActiveRecord::ConnectionAdapters::Column
+  def ==(other); end
+  def bigint?; end
+  def collation; end
+  def comment; end
+  def default; end
+  def default_function; end
+  def encode_with(coder); end
+  def eql?(other); end
+  def has_default?; end
+  def hash; end
+  def human_name; end
+  def init_with(coder); end
+  def initialize(name, default, sql_type_metadata = nil, null = nil, default_function = nil, collation: nil, comment: nil, **arg7); end
+  def limit(*args, &block); end
+  def name; end
+  def null; end
+  def precision(*args, &block); end
+  def scale(*args, &block); end
+  def sql_type(*args, &block); end
+  def sql_type_metadata; end
+  def type(*args, &block); end
+end
+class ActiveRecord::ConnectionAdapters::NullColumn < ActiveRecord::ConnectionAdapters::Column
+  def initialize(name); end
+end
+class ActiveRecord::StatementCache
+  def bind_map; end
+  def execute(params, connection, &block); end
+  def initialize(query_builder, bind_map, klass); end
+  def klass; end
+  def query_builder; end
+  def self.create(connection, callable = nil, &block); end
+  def self.partial_query(values); end
+  def self.partial_query_collector; end
+  def self.query(sql); end
+  def self.unsupported_value?(value); end
+end
+class ActiveRecord::StatementCache::Substitute
+end
+class ActiveRecord::StatementCache::Query
+  def initialize(sql); end
+  def sql_for(binds, connection); end
+end
+class ActiveRecord::StatementCache::PartialQuery < ActiveRecord::StatementCache::Query
+  def initialize(values); end
+  def sql_for(binds, connection); end
+end
+class ActiveRecord::StatementCache::PartialQueryCollector
+  def <<(str); end
+  def add_bind(obj); end
+  def initialize; end
+  def value; end
+end
+class ActiveRecord::StatementCache::Params
+  def bind; end
+end
+class ActiveRecord::StatementCache::BindMap
+  def bind(values); end
+  def initialize(bound_attributes); end
+end
+class ActiveRecord::Associations::Builder::SingularAssociation < ActiveRecord::Associations::Builder::Association
+  def self.define_accessors(model, reflection); end
+  def self.define_constructors(mixin, name); end
+  def self.valid_options(options); end
+end
+class ActiveRecord::Associations::Builder::BelongsTo < ActiveRecord::Associations::Builder::SingularAssociation
+  def self.add_counter_cache_callbacks(model, reflection); end
+  def self.add_default_callbacks(model, reflection); end
+  def self.add_destroy_callbacks(model, reflection); end
+  def self.add_touch_callbacks(model, reflection); end
+  def self.define_callbacks(model, reflection); end
+  def self.define_validations(model, reflection); end
+  def self.macro; end
+  def self.touch_record(o, changes, foreign_key, name, touch, touch_method); end
+  def self.valid_dependent_options; end
+  def self.valid_options(options); end
+end
+class ActiveRecord::Associations::Builder::CollectionAssociation < ActiveRecord::Associations::Builder::Association
+  def self.define_callback(model, callback_name, name, options); end
+  def self.define_callbacks(model, reflection); end
+  def self.define_extensions(model, name, &block); end
+  def self.define_readers(mixin, name); end
+  def self.define_writers(mixin, name); end
+  def self.valid_options(options); end
+end
+class ActiveRecord::Associations::Builder::HasMany < ActiveRecord::Associations::Builder::CollectionAssociation
+  def self.macro; end
+  def self.valid_dependent_options; end
+  def self.valid_options(options); end
+end
diff --git a/sorbet/rbi/gems/activesupport.rbi b/sorbet/rbi/gems/activesupport.rbi
new file mode 100644
index 0000000..85aa7e4
--- /dev/null
+++ b/sorbet/rbi/gems/activesupport.rbi
@@ -0,0 +1,1965 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/activesupport/all/activesupport.rbi
+#
+# activesupport-6.0.3.2
+
+class Hash
+  def _deep_transform_keys_in_object!(object, &block); end
+  def _deep_transform_keys_in_object(object, &block); end
+  def as_json(options = nil); end
+  def assert_valid_keys(*valid_keys); end
+  def blank?; end
+  def deep_dup; end
+  def deep_merge!(other_hash, &block); end
+  def deep_merge(other_hash, &block); end
+  def deep_stringify_keys!; end
+  def deep_stringify_keys; end
+  def deep_symbolize_keys!; end
+  def deep_symbolize_keys; end
+  def deep_transform_keys!(&block); end
+  def deep_transform_keys(&block); end
+  def except!(*keys); end
+  def except(*keys); end
+  def extract!(*keys); end
+  def extractable_options?; end
+  def nested_under_indifferent_access; end
+  def reverse_merge!(other_hash); end
+  def reverse_merge(other_hash); end
+  def reverse_update(other_hash); end
+  def slice!(*keys); end
+  def stringify_keys!; end
+  def stringify_keys; end
+  def symbolize_keys!; end
+  def symbolize_keys; end
+  def to_options!; end
+  def to_options; end
+  def to_param(namespace = nil); end
+  def to_query(namespace = nil); end
+  def with_defaults!(other_hash); end
+  def with_defaults(other_hash); end
+  def with_indifferent_access; end
+end
+module ActiveSupport
+  def parse_json_times; end
+  def parse_json_times=(obj); end
+  def self.eager_load!; end
+  def self.escape_html_entities_in_json(*args, &block); end
+  def self.escape_html_entities_in_json=(arg); end
+  def self.gem_version; end
+  def self.json_encoder(*args, &block); end
+  def self.json_encoder=(arg); end
+  def self.parse_json_times; end
+  def self.parse_json_times=(obj); end
+  def self.test_order; end
+  def self.test_order=(obj); end
+  def self.time_precision(*args, &block); end
+  def self.time_precision=(arg); end
+  def self.to_time_preserves_timezone; end
+  def self.to_time_preserves_timezone=(value); end
+  def self.use_standard_json_time_format(*args, &block); end
+  def self.use_standard_json_time_format=(arg); end
+  def self.version; end
+  def test_order; end
+  def test_order=(obj); end
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::LazyLoadHooks
+end
+module ActiveSupport::LazyLoadHooks
+  def execute_hook(name, base, options, block); end
+  def on_load(name, options = nil, &block); end
+  def run_load_hooks(name, base = nil); end
+  def self.extended(base); end
+  def with_execution_control(name, block, once); end
+end
+module Kernel
+  def class_eval(*args, &block); end
+  def enable_warnings; end
+  def self.enable_warnings; end
+  def self.silence_warnings; end
+  def self.suppress(*exception_classes); end
+  def self.with_warnings(flag); end
+  def silence_warnings; end
+  def suppress(*exception_classes); end
+  def with_warnings(flag); end
+end
+class Module
+  def alias_attribute(new_name, old_name); end
+  def anonymous?; end
+  def cattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil, default: nil, &blk); end
+  def cattr_reader(*syms, instance_reader: nil, instance_accessor: nil, default: nil); end
+  def cattr_writer(*syms, instance_writer: nil, instance_accessor: nil, default: nil); end
+  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil); end
+  def delegate_missing_to(target); end
+  def deprecate(*method_names); end
+  def mattr_accessor(*syms, instance_reader: nil, instance_writer: nil, instance_accessor: nil, default: nil, &blk); end
+  def mattr_reader(*syms, instance_reader: nil, instance_accessor: nil, default: nil); end
+  def mattr_writer(*syms, instance_writer: nil, instance_accessor: nil, default: nil); end
+  def method_visibility(method); end
+  def module_parent; end
+  def module_parent_name; end
+  def module_parents; end
+  def parent; end
+  def parent_name; end
+  def parents; end
+  def redefine_method(method, &block); end
+  def redefine_singleton_method(method, &block); end
+  def remove_possible_method(method); end
+  def remove_possible_singleton_method(method); end
+  def silence_redefinition_of_method(method); end
+  include ActiveSupport::Dependencies::ModuleConstMissing
+end
+class Module::DelegationError < NoMethodError
+end
+class ActiveSupport::Deprecation
+  def self.behavior(*args, &block); end
+  def self.behavior=(arg); end
+  def self.debug(*args, &block); end
+  def self.debug=(arg); end
+  def self.deprecate_methods(*args, &block); end
+  def self.deprecation_horizon(*args, &block); end
+  def self.deprecation_horizon=(arg); end
+  def self.deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
+  def self.gem_name(*args, &block); end
+  def self.gem_name=(arg); end
+  def self.initialize(*args, &block); end
+  def self.instance; end
+  def self.silence(*args, &block); end
+  def self.silenced(*args, &block); end
+  def self.silenced=(arg); end
+  def self.warn(message = nil, callstack = nil); end
+  extend ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
+  extend Singleton::SingletonClassMethods
+  include ActiveSupport::Deprecation::Behavior
+  include ActiveSupport::Deprecation::InstanceDelegator
+  include ActiveSupport::Deprecation::MethodWrapper
+  include ActiveSupport::Deprecation::Reporting
+  include Singleton
+end
+module ActiveSupport::Deprecation::InstanceDelegator
+  def self.included(base); end
+end
+module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
+  def include(included_module); end
+  def method_added(method_name); end
+end
+module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
+  def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
+  def warn(message = nil, callstack = nil); end
+end
+module ActiveSupport::Notifications
+  def self.instrument(name, payload = nil); end
+  def self.instrumenter; end
+  def self.notifier; end
+  def self.notifier=(arg0); end
+  def self.publish(name, *args); end
+  def self.subscribe(*args, &block); end
+  def self.subscribed(callback, *args, &block); end
+  def self.unsubscribe(subscriber_or_name); end
+end
+class ActiveSupport::Notifications::Instrumenter
+  def finish(name, payload); end
+  def finish_with_state(listeners_state, name, payload); end
+  def id; end
+  def initialize(notifier); end
+  def instrument(name, payload = nil); end
+  def start(name, payload); end
+  def unique_id; end
+end
+class ActiveSupport::Notifications::Event
+  def <<(event); end
+  def allocations; end
+  def children; end
+  def cpu_time; end
+  def duration; end
+  def end; end
+  def end=(ending); end
+  def finish!; end
+  def idle_time; end
+  def initialize(name, start, ending, transaction_id, payload); end
+  def name; end
+  def now; end
+  def now_allocations; end
+  def now_cpu; end
+  def parent_of?(event); end
+  def payload; end
+  def self.clock_gettime_supported?; end
+  def start!; end
+  def time; end
+  def transaction_id; end
+end
+class ActiveSupport::Notifications::Fanout
+  def finish(name, id, payload, listeners = nil); end
+  def initialize; end
+  def listeners_for(name); end
+  def listening?(name); end
+  def lock; end
+  def locked?; end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribe(pattern = nil, callable = nil, &block); end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+  def unsubscribe(subscriber_or_name); end
+  def wait; end
+  include Mutex_m
+end
+module ActiveSupport::Notifications::Fanout::Subscribers
+  def self.event_object_subscriber(pattern, block); end
+  def self.new(pattern, listener); end
+  def self.wrap_all(pattern, subscriber); end
+end
+class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
+  def ===(name); end
+  def exclusions; end
+  def initialize(pattern); end
+  def pattern; end
+  def self.wrap(pattern); end
+  def unsubscribe!(name); end
+end
+class ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def finish(name, id, payload); end
+  def initialize(pattern, delegate); end
+  def matches?(name); end
+  def pattern; end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribed_to?(name); end
+  def unsubscribe!(name); end
+end
+class ActiveSupport::Notifications::Fanout::Subscribers::Timed < ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def finish(name, id, payload); end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+end
+class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def build_event(name, id, payload); end
+  def finish(name, id, payload); end
+  def start(name, id, payload); end
+end
+class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
+  def finish(name, id, payload); end
+  def initialize(delegate); end
+  def matches?(arg0); end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribed_to?(name); end
+  def unsubscribe!(*arg0); end
+end
+module ActiveSupport::PerThreadRegistry
+  def instance; end
+  def method_missing(name, *args, &block); end
+  def self.extended(object); end
+end
+class ActiveSupport::Notifications::InstrumentationRegistry
+  def initialize; end
+  def instrumenter_for(notifier); end
+  extend ActiveSupport::PerThreadRegistry
+end
+class ActiveSupport::DeprecationException < StandardError
+end
+module ActiveSupport::Deprecation::Behavior
+  def arity_coerce(behavior); end
+  def behavior; end
+  def behavior=(behavior); end
+  def debug; end
+  def debug=(arg0); end
+end
+module ActiveSupport::Deprecation::Reporting
+  def _extract_callstack(callstack); end
+  def deprecated_method_warning(method_name, message = nil); end
+  def deprecation_caller_message(callstack); end
+  def deprecation_message(callstack, message = nil); end
+  def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil); end
+  def extract_callstack(callstack); end
+  def gem_name; end
+  def gem_name=(arg0); end
+  def ignored_callstack(path); end
+  def silence; end
+  def silenced; end
+  def silenced=(arg0); end
+  def warn(message = nil, callstack = nil); end
+end
+module ActiveSupport::Deprecation::DeprecatedConstantAccessor
+  def self.included(base); end
+end
+class Array
+  def as_json(options = nil); end
+  def blank?; end
+  def deep_dup; end
+  def excluding(*elements); end
+  def extract!; end
+  def extract_options!; end
+  def fifth; end
+  def forty_two; end
+  def fourth; end
+  def from(position); end
+  def in_groups(number, fill_with = nil); end
+  def in_groups_of(number, fill_with = nil); end
+  def including(*elements); end
+  def inquiry; end
+  def second; end
+  def second_to_last; end
+  def self.try_convert(arg0); end
+  def split(value = nil); end
+  def third; end
+  def third_to_last; end
+  def to(position); end
+  def to_default_s; end
+  def to_formatted_s(format = nil); end
+  def to_param; end
+  def to_query(key); end
+  def to_sentence(options = nil); end
+  def to_xml(options = nil); end
+  def without(*elements); end
+end
+module ActiveSupport::Deprecation::MethodWrapper
+  def deprecate_methods(target_module, *method_names); end
+end
+class ActiveSupport::Deprecation::DeprecationProxy
+  def inspect; end
+  def method_missing(called, *args, &block); end
+  def self.new(*args, &block); end
+end
+class ActiveSupport::Deprecation::DeprecatedObjectProxy < ActiveSupport::Deprecation::DeprecationProxy
+  def initialize(object, message, deprecator = nil); end
+  def target; end
+  def warn(callstack, called, args); end
+end
+class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ActiveSupport::Deprecation::DeprecationProxy
+  def initialize(instance, method, var = nil, deprecator = nil); end
+  def target; end
+  def warn(callstack, called, args); end
+end
+class ActiveSupport::Deprecation::DeprecatedConstantProxy < Module
+  def class; end
+  def const_missing(name); end
+  def hash(*args, &block); end
+  def initialize(old_const, new_const, deprecator = nil, message: nil); end
+  def inspect; end
+  def instance_methods(*args, &block); end
+  def method_missing(called, *args, &block); end
+  def name(*args, &block); end
+  def self.new(*args, **kwargs, &block); end
+  def target; end
+end
+module ActiveSupport::Inflector
+  def apply_inflections(word, rules, locale = nil); end
+  def camelize(term, uppercase_first_letter = nil); end
+  def classify(table_name); end
+  def const_regexp(camel_cased_word); end
+  def constantize(camel_cased_word); end
+  def dasherize(underscored_word); end
+  def deconstantize(path); end
+  def demodulize(path); end
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = nil); end
+  def humanize(lower_case_and_underscored_word, capitalize: nil, keep_id_suffix: nil); end
+  def inflections(locale = nil); end
+  def ordinal(number); end
+  def ordinalize(number); end
+  def parameterize(string, separator: nil, preserve_case: nil, locale: nil); end
+  def pluralize(word, locale = nil); end
+  def safe_constantize(camel_cased_word); end
+  def singularize(word, locale = nil); end
+  def tableize(class_name); end
+  def titleize(word, keep_id_suffix: nil); end
+  def transliterate(string, replacement = nil, locale: nil); end
+  def underscore(camel_cased_word); end
+  def upcase_first(string); end
+  extend ActiveSupport::Inflector
+  extend ActiveSupport::Inflector
+end
+class ActiveSupport::Inflector::Inflections
+  def acronym(word); end
+  def acronyms; end
+  def acronyms_camelize_regex; end
+  def acronyms_underscore_regex; end
+  def clear(scope = nil); end
+  def define_acronym_regex_patterns; end
+  def human(rule, replacement); end
+  def humans; end
+  def initialize; end
+  def initialize_dup(orig); end
+  def irregular(singular, plural); end
+  def plural(rule, replacement); end
+  def plurals; end
+  def self.instance(locale = nil); end
+  def singular(rule, replacement); end
+  def singulars; end
+  def uncountable(*words); end
+  def uncountables; end
+end
+class ActiveSupport::Inflector::Inflections::Uncountables < Array
+  def <<(*word); end
+  def add(words); end
+  def delete(entry); end
+  def initialize; end
+  def to_regex(string); end
+  def uncountable?(str); end
+end
+module ActiveSupport::Autoload
+  def autoload(const_name, path = nil); end
+  def autoload_at(path); end
+  def autoload_under(path); end
+  def autoloads; end
+  def eager_autoload; end
+  def eager_load!; end
+  def self.extended(base); end
+end
+module ActiveSupport::VERSION
+end
+module ActiveSupport::Concern
+  def append_features(base); end
+  def class_methods(&class_methods_module_definition); end
+  def included(base = nil, &block); end
+  def self.extended(base); end
+end
+class ActiveSupport::Concern::MultipleIncludedBlocks < StandardError
+  def initialize; end
+end
+module ActiveSupport::LoggerThreadSafeLevel
+  def add(severity, message = nil, progname = nil, &block); end
+  def after_initialize; end
+  def debug?; end
+  def error?; end
+  def fatal?; end
+  def info?; end
+  def level; end
+  def local_level; end
+  def local_level=(level); end
+  def local_log_id; end
+  def unknown?; end
+  def warn?; end
+  extend ActiveSupport::Concern
+end
+module LoggerSilence
+  extend ActiveSupport::Concern
+end
+module ActiveSupport::LoggerSilence
+  def silence(temporary_level = nil); end
+  extend ActiveSupport::Concern
+end
+class ActiveSupport::Logger < Logger
+  def initialize(*args, **kwargs); end
+  def self.broadcast(logger); end
+  def self.local_levels; end
+  def self.local_levels=(obj); end
+  def self.logger_outputs_to?(logger, *sources); end
+  def self.silencer; end
+  def self.silencer=(obj); end
+  def silencer; end
+  def silencer=(obj); end
+  include ActiveSupport::LoggerSilence
+  include ActiveSupport::LoggerThreadSafeLevel
+end
+class ActiveSupport::Logger::SimpleFormatter < Logger::Formatter
+  def call(severity, timestamp, progname, msg); end
+end
+module DateAndTime
+end
+module DateAndTime::Compatibility
+  def preserve_timezone; end
+  def self.preserve_timezone; end
+  def self.preserve_timezone=(obj); end
+end
+class Object < BasicObject
+  def acts_like?(duck); end
+  def as_json(options = nil); end
+  def blank?; end
+  def deep_dup; end
+  def duplicable?; end
+  def instance_values; end
+  def instance_variable_names; end
+  def presence; end
+  def present?; end
+  def to_param; end
+  def to_query(key); end
+  include ActiveSupport::Dependencies::Loadable
+  include ActiveSupport::Tryable
+end
+class NilClass
+  def as_json(options = nil); end
+  def blank?; end
+  def to_param; end
+  def try!(method_name = nil, *args); end
+  def try(method_name = nil, *args); end
+end
+class FalseClass
+  def as_json(options = nil); end
+  def blank?; end
+  def to_param; end
+end
+class TrueClass
+  def as_json(options = nil); end
+  def blank?; end
+  def to_param; end
+end
+class String
+  def acts_like_string?; end
+  def as_json(options = nil); end
+  def at(position); end
+  def blank?; end
+  def camelcase(first_letter = nil); end
+  def camelize(first_letter = nil); end
+  def classify; end
+  def constantize; end
+  def dasherize; end
+  def deconstantize; end
+  def demodulize; end
+  def ends_with?(*arg0); end
+  def first(limit = nil); end
+  def foreign_key(separate_class_name_and_id_with_underscore = nil); end
+  def from(position); end
+  def humanize(capitalize: nil, keep_id_suffix: nil); end
+  def in_time_zone(zone = nil); end
+  def is_utf8?; end
+  def last(limit = nil); end
+  def mb_chars; end
+  def parameterize(separator: nil, preserve_case: nil, locale: nil); end
+  def pluralize(count = nil, locale = nil); end
+  def remove!(*patterns); end
+  def remove(*patterns); end
+  def safe_constantize; end
+  def singularize(locale = nil); end
+  def squish!; end
+  def squish; end
+  def starts_with?(*arg0); end
+  def tableize; end
+  def titlecase(keep_id_suffix: nil); end
+  def titleize(keep_id_suffix: nil); end
+  def to(position); end
+  def to_date; end
+  def to_datetime; end
+  def to_time(form = nil); end
+  def truncate(truncate_at, options = nil); end
+  def truncate_bytes(truncate_at, omission: nil); end
+  def truncate_words(words_count, options = nil); end
+  def underscore; end
+  def upcase_first; end
+end
+class Numeric
+  def as_json(options = nil); end
+  def blank?; end
+  def byte; end
+  def bytes; end
+  def day; end
+  def days; end
+  def exabyte; end
+  def exabytes; end
+  def fortnight; end
+  def fortnights; end
+  def gigabyte; end
+  def gigabytes; end
+  def hour; end
+  def hours; end
+  def in_milliseconds; end
+  def kilobyte; end
+  def kilobytes; end
+  def megabyte; end
+  def megabytes; end
+  def minute; end
+  def minutes; end
+  def petabyte; end
+  def petabytes; end
+  def second; end
+  def seconds; end
+  def terabyte; end
+  def terabytes; end
+  def week; end
+  def weeks; end
+end
+class Time
+  def acts_like_time?; end
+  def advance(options); end
+  def ago(seconds); end
+  def as_json(options = nil); end
+  def at_beginning_of_day; end
+  def at_beginning_of_hour; end
+  def at_beginning_of_minute; end
+  def at_end_of_day; end
+  def at_end_of_hour; end
+  def at_end_of_minute; end
+  def at_midday; end
+  def at_middle_of_day; end
+  def at_midnight; end
+  def at_noon; end
+  def beginning_of_day; end
+  def beginning_of_hour; end
+  def beginning_of_minute; end
+  def blank?; end
+  def change(options); end
+  def compare_with_coercion(other); end
+  def compare_without_coercion(arg0); end
+  def end_of_day; end
+  def end_of_hour; end
+  def end_of_minute; end
+  def eql_with_coercion(other); end
+  def eql_without_coercion(arg0); end
+  def formatted_offset(colon = nil, alternate_utc_string = nil); end
+  def in(seconds); end
+  def midday; end
+  def middle_of_day; end
+  def midnight; end
+  def minus_with_coercion(other); end
+  def minus_with_duration(other); end
+  def minus_without_coercion(other); end
+  def minus_without_duration(arg0); end
+  def next_day(days = nil); end
+  def next_month(months = nil); end
+  def next_year(years = nil); end
+  def noon; end
+  def plus_with_duration(other); end
+  def plus_without_duration(arg0); end
+  def prev_day(days = nil); end
+  def prev_month(months = nil); end
+  def prev_year(years = nil); end
+  def rfc3339(fraction_digits = nil); end
+  def sec_fraction; end
+  def seconds_since_midnight; end
+  def seconds_until_end_of_day; end
+  def self.===(other); end
+  def self.at_with_coercion(*args); end
+  def self.at_without_coercion(*arg0); end
+  def self.current; end
+  def self.days_in_month(month, year = nil); end
+  def self.days_in_year(year = nil); end
+  def self.find_zone!(time_zone); end
+  def self.find_zone(time_zone); end
+  def self.rfc3339(str); end
+  def self.use_zone(time_zone); end
+  def self.zone; end
+  def self.zone=(time_zone); end
+  def self.zone_default; end
+  def self.zone_default=(arg0); end
+  def since(seconds); end
+  def to_default_s; end
+  def to_formatted_s(format = nil); end
+  include DateAndTime::Calculations
+  include DateAndTime::Compatibility
+  include DateAndTime::Zones
+end
+class Class < Module
+  def class_attribute(*attrs, instance_accessor: nil, instance_reader: nil, instance_writer: nil, instance_predicate: nil, default: nil); end
+  def descendants; end
+  def subclasses; end
+end
+class Method
+  def duplicable?; end
+end
+class UnboundMethod
+  def duplicable?; end
+end
+module ActiveSupport::Concurrency
+end
+class ActiveSupport::Concurrency::LoadInterlockAwareMonitor < Monitor
+  def mon_enter; end
+  def synchronize; end
+end
+module ActiveSupport::DescendantsTracker
+  def descendants; end
+  def direct_descendants; end
+  def inherited(base); end
+  def self.accumulate_descendants(klass, acc); end
+  def self.clear; end
+  def self.descendants(klass); end
+  def self.direct_descendants(klass); end
+  def self.store_inherited(klass, descendant); end
+end
+class ActiveSupport::DescendantsTracker::DescendantsArray
+  def <<(klass); end
+  def cleanup!; end
+  def each; end
+  def initialize; end
+  def initialize_copy(orig); end
+  def refs_size; end
+  def reject!; end
+  include Enumerable
+end
+module ActiveSupport::Callbacks
+  def halted_callback_hook(filter); end
+  def run_callbacks(kind); end
+  extend ActiveSupport::Concern
+end
+module ActiveSupport::Callbacks::Conditionals
+end
+class ActiveSupport::Callbacks::Conditionals::Value
+  def call(target, value); end
+  def initialize(&block); end
+end
+module ActiveSupport::Callbacks::Filters
+end
+class ActiveSupport::Callbacks::Filters::Environment < Struct
+  def halted; end
+  def halted=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def target; end
+  def target=(_); end
+  def value; end
+  def value=(_); end
+end
+class ActiveSupport::Callbacks::Filters::Before
+  def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter); end
+  def self.halting(callback_sequence, user_callback, halted_lambda, filter); end
+  def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter); end
+end
+class ActiveSupport::Callbacks::Filters::After
+  def self.build(callback_sequence, user_callback, user_conditions, chain_config); end
+  def self.conditional(callback_sequence, user_callback, user_conditions); end
+  def self.halting(callback_sequence, user_callback); end
+  def self.halting_and_conditional(callback_sequence, user_callback, user_conditions); end
+  def self.simple(callback_sequence, user_callback); end
+end
+class ActiveSupport::Callbacks::Callback
+  def apply(callback_sequence); end
+  def chain_config; end
+  def check_conditionals(conditionals); end
+  def compute_identifier(filter); end
+  def conditions_lambdas; end
+  def current_scopes; end
+  def duplicates?(other); end
+  def filter; end
+  def initialize(name, filter, kind, options, chain_config); end
+  def kind; end
+  def kind=(arg0); end
+  def matches?(_kind, _filter); end
+  def merge_conditional_options(chain, if_option:, unless_option:); end
+  def name; end
+  def name=(arg0); end
+  def raw_filter; end
+  def self.build(chain, filter, kind, options); end
+end
+class ActiveSupport::Callbacks::CallTemplate
+  def expand(target, value, block); end
+  def initialize(target, method, arguments, block); end
+  def inverted_lambda; end
+  def make_lambda; end
+  def self.build(filter, callback); end
+end
+class ActiveSupport::Callbacks::CallbackSequence
+  def after(&after); end
+  def around(call_template, user_conditions); end
+  def before(&before); end
+  def expand_call_template(arg, block); end
+  def final?; end
+  def initialize(nested = nil, call_template = nil, user_conditions = nil); end
+  def invoke_after(arg); end
+  def invoke_before(arg); end
+  def nested; end
+  def skip?(arg); end
+end
+class ActiveSupport::Callbacks::CallbackChain
+  def append(*callbacks); end
+  def append_one(callback); end
+  def chain; end
+  def clear; end
+  def compile; end
+  def config; end
+  def default_terminator; end
+  def delete(o); end
+  def each(&block); end
+  def empty?; end
+  def index(o); end
+  def initialize(name, config); end
+  def initialize_copy(other); end
+  def insert(index, o); end
+  def name; end
+  def prepend(*callbacks); end
+  def prepend_one(callback); end
+  def remove_duplicates(callback); end
+  include Enumerable
+end
+module ActiveSupport::Callbacks::ClassMethods
+  def __update_callbacks(name); end
+  def define_callbacks(*names); end
+  def get_callbacks(name); end
+  def normalize_callback_params(filters, block); end
+  def reset_callbacks(name); end
+  def set_callback(name, *filter_list, &block); end
+  def set_callbacks(name, callbacks); end
+  def skip_callback(name, *filter_list, &block); end
+end
+module ActiveSupport::BigDecimalWithDefaultFormat
+  def to_s(format = nil); end
+end
+module ActiveSupport::JSON
+  def self.convert_dates_from(data); end
+  def self.decode(json); end
+  def self.encode(value, options = nil); end
+  def self.parse_error; end
+end
+class ActiveSupport::TimeZone
+  def <=>(zone); end
+  def =~(re); end
+  def at(*args); end
+  def encode_with(coder); end
+  def formatted_offset(colon = nil, alternate_utc_string = nil); end
+  def init_with(coder); end
+  def initialize(name, utc_offset = nil, tzinfo = nil); end
+  def iso8601(str); end
+  def local(*args); end
+  def local_to_utc(time, dst = nil); end
+  def name; end
+  def now; end
+  def parse(str, now = nil); end
+  def parts_to_time(parts, now); end
+  def period_for_local(time, dst = nil); end
+  def period_for_utc(time); end
+  def periods_for_local(time); end
+  def rfc3339(str); end
+  def self.[](arg); end
+  def self.all; end
+  def self.clear; end
+  def self.country_zones(country_code); end
+  def self.create(*arg0); end
+  def self.find_tzinfo(name); end
+  def self.load_country_zones(code); end
+  def self.new(name); end
+  def self.seconds_to_utc_offset(seconds, colon = nil); end
+  def self.us_zones; end
+  def self.zones_map; end
+  def strptime(str, format, now = nil); end
+  def time_now; end
+  def to_s; end
+  def today; end
+  def tomorrow; end
+  def tzinfo; end
+  def utc_offset; end
+  def utc_to_local(time); end
+  def yesterday; end
+  include Comparable
+end
+class DateTime < Date
+  def <=>(other); end
+  def acts_like_date?; end
+  def acts_like_time?; end
+  def advance(options); end
+  def ago(seconds); end
+  def as_json(options = nil); end
+  def at_beginning_of_day; end
+  def at_beginning_of_hour; end
+  def at_beginning_of_minute; end
+  def at_end_of_day; end
+  def at_end_of_hour; end
+  def at_end_of_minute; end
+  def at_midday; end
+  def at_middle_of_day; end
+  def at_midnight; end
+  def at_noon; end
+  def beginning_of_day; end
+  def beginning_of_hour; end
+  def beginning_of_minute; end
+  def blank?; end
+  def change(options); end
+  def default_inspect; end
+  def end_of_day; end
+  def end_of_hour; end
+  def end_of_minute; end
+  def formatted_offset(colon = nil, alternate_utc_string = nil); end
+  def getgm; end
+  def getlocal(utc_offset = nil); end
+  def getutc; end
+  def gmtime; end
+  def in(seconds); end
+  def inspect; end
+  def localtime(utc_offset = nil); end
+  def midday; end
+  def middle_of_day; end
+  def midnight; end
+  def noon; end
+  def nsec; end
+  def offset_in_seconds; end
+  def readable_inspect; end
+  def seconds_since_midnight; end
+  def seconds_since_unix_epoch; end
+  def seconds_until_end_of_day; end
+  def self.civil_from_format(utc_or_local, year, month = nil, day = nil, hour = nil, min = nil, sec = nil); end
+  def self.current; end
+  def since(seconds); end
+  def subsec; end
+  def to_default_s; end
+  def to_f; end
+  def to_formatted_s(format = nil); end
+  def to_i; end
+  def usec; end
+  def utc; end
+  def utc?; end
+  def utc_offset; end
+  include DateAndTime::Compatibility
+end
+module DateAndTime::Zones
+  def in_time_zone(zone = nil); end
+  def time_with_zone(time, zone); end
+end
+class Date
+  def acts_like_date?; end
+  def advance(options); end
+  def ago(seconds); end
+  def as_json(options = nil); end
+  def at_beginning_of_day; end
+  def at_end_of_day; end
+  def at_midday; end
+  def at_middle_of_day; end
+  def at_midnight; end
+  def at_noon; end
+  def beginning_of_day; end
+  def blank?; end
+  def change(options); end
+  def compare_with_coercion(other); end
+  def compare_without_coercion(arg0); end
+  def default_inspect; end
+  def end_of_day; end
+  def in(seconds); end
+  def midday; end
+  def middle_of_day; end
+  def midnight; end
+  def minus_with_duration(other); end
+  def minus_without_duration(arg0); end
+  def noon; end
+  def plus_with_duration(other); end
+  def plus_without_duration(arg0); end
+  def readable_inspect; end
+  def self.beginning_of_week; end
+  def self.beginning_of_week=(week_start); end
+  def self.beginning_of_week_default; end
+  def self.beginning_of_week_default=(arg0); end
+  def self.current; end
+  def self.find_beginning_of_week!(week_start); end
+  def self.tomorrow; end
+  def self.yesterday; end
+  def since(seconds); end
+  def to_default_s; end
+  def to_formatted_s(format = nil); end
+  include DateAndTime::Calculations
+  include DateAndTime::Zones
+end
+module ActiveSupport::ToJsonWithActiveSupportEncoder
+  def to_json(options = nil); end
+end
+class Struct
+  def as_json(options = nil); end
+end
+class Symbol
+  def as_json(options = nil); end
+end
+class Float < Numeric
+  def as_json(options = nil); end
+end
+class BigDecimal < Numeric
+  def as_json(options = nil); end
+end
+class Regexp
+  def as_json(options = nil); end
+end
+module Enumerable
+  def _original_sum_with_required_identity(*arg0); end
+  def as_json(options = nil); end
+  def exclude?(object); end
+  def excluding(*elements); end
+  def including(*elements); end
+  def index_by; end
+  def index_with(default = nil); end
+  def many?; end
+  def pluck(*keys); end
+  def without(*elements); end
+end
+class IO
+  def as_json(options = nil); end
+end
+class Range
+  def as_json(options = nil); end
+  def overlaps?(other); end
+  def sum(identity = nil); end
+end
+class URI::Generic
+  def as_json(options = nil); end
+end
+class Pathname
+  def as_json(options = nil); end
+end
+class Process::Status
+  def as_json(options = nil); end
+end
+class Exception
+  def as_json(options = nil); end
+  include ActiveSupport::Dependencies::Blamable
+end
+module ActiveSupport::JSON::Encoding
+  def self.escape_html_entities_in_json; end
+  def self.escape_html_entities_in_json=(arg0); end
+  def self.json_encoder; end
+  def self.json_encoder=(arg0); end
+  def self.time_precision; end
+  def self.time_precision=(arg0); end
+  def self.use_standard_json_time_format; end
+  def self.use_standard_json_time_format=(arg0); end
+end
+class ActiveSupport::JSON::Encoding::JSONGemEncoder
+  def encode(value); end
+  def initialize(options = nil); end
+  def jsonify(value); end
+  def options; end
+  def stringify(jsonified); end
+end
+class ActiveSupport::JSON::Encoding::JSONGemEncoder::EscapedString < String
+  def to_json(*arg0); end
+  def to_s; end
+end
+module ActiveSupport::Multibyte
+  def self.proxy_class; end
+  def self.proxy_class=(klass); end
+end
+class ActiveSupport::Multibyte::Chars
+  def <=>(*args, &block); end
+  def =~(*args, &block); end
+  def acts_like_string?(*args, &block); end
+  def as_json(options = nil); end
+  def chars(string); end
+  def compose; end
+  def decompose; end
+  def grapheme_length; end
+  def initialize(string); end
+  def limit(limit); end
+  def method_missing(method, *args, &block); end
+  def normalize(form = nil); end
+  def respond_to_missing?(method, include_private); end
+  def reverse!(*args); end
+  def reverse; end
+  def self.consumes?(string); end
+  def slice!(*args); end
+  def split(*args); end
+  def tidy_bytes!(*args); end
+  def tidy_bytes(force = nil); end
+  def titlecase; end
+  def titleize; end
+  def to_s; end
+  def to_str; end
+  def wrapped_string; end
+  include Comparable
+end
+module ActiveSupport::ActionableError
+  def self.actions(error); end
+  def self.dispatch(error, name); end
+  extend ActiveSupport::Concern
+end
+class ActiveSupport::ActionableError::NonActionable < StandardError
+end
+module ActiveSupport::ActionableError::ClassMethods
+  def action(name, &block); end
+end
+module ActiveSupport::XmlMini_REXML
+  def collapse(element, depth); end
+  def empty_content?(element); end
+  def get_attributes(element); end
+  def merge!(hash, key, value); end
+  def merge_element!(hash, element, depth); end
+  def merge_texts!(hash, element); end
+  def parse(data); end
+  extend ActiveSupport::XmlMini_REXML
+end
+module ActiveSupport::XmlMini
+  def _dasherize(key); end
+  def _parse_binary(bin, entity); end
+  def _parse_file(file, entity); end
+  def backend; end
+  def backend=(name); end
+  def cast_backend_name_to_module(name); end
+  def current_thread_backend; end
+  def current_thread_backend=(name); end
+  def depth; end
+  def depth=(arg0); end
+  def parse(*args, &block); end
+  def rename_key(key, options = nil); end
+  def to_tag(key, value, options); end
+  def with_backend(name); end
+  extend ActiveSupport::XmlMini
+end
+module ActiveSupport::XmlMini::FileLike
+  def content_type; end
+  def content_type=(arg0); end
+  def original_filename; end
+  def original_filename=(arg0); end
+end
+class ActiveSupport::CurrentAttributes
+  def __callbacks; end
+  def __callbacks?; end
+  def _reset_callbacks; end
+  def _run_reset_callbacks(&block); end
+  def assign_attributes(new_attributes); end
+  def attributes; end
+  def attributes=(arg0); end
+  def compute_attributes(keys); end
+  def initialize; end
+  def reset; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._reset_callbacks; end
+  def self._reset_callbacks=(value); end
+  def self.after_reset(&block); end
+  def self.attribute(*names); end
+  def self.before_reset(&block); end
+  def self.clear_all; end
+  def self.current_instances; end
+  def self.generated_attribute_methods; end
+  def self.instance; end
+  def self.method_missing(name, *args, &block); end
+  def self.reset(*args, &block); end
+  def self.reset_all; end
+  def self.resets(&block); end
+  def self.set(*args, &block); end
+  def set(set_attributes); end
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  include ActiveSupport::Callbacks
+end
+class LoadError < ScriptError
+  def is_missing?(location); end
+end
+class NameError < StandardError
+  def missing_name; end
+  def missing_name?(name); end
+end
+class ActiveSupport::Concurrency::ShareLock
+  def busy_for_exclusive?(purpose); end
+  def busy_for_sharing?(purpose); end
+  def eligible_waiters?(compatible); end
+  def exclusive(purpose: nil, compatible: nil, after_compatible: nil, no_wait: nil); end
+  def initialize; end
+  def raw_state; end
+  def sharing; end
+  def start_exclusive(purpose: nil, compatible: nil, no_wait: nil); end
+  def start_sharing; end
+  def stop_exclusive(compatible: nil); end
+  def stop_sharing; end
+  def wait_for(method); end
+  def yield_shares(purpose: nil, compatible: nil, block_share: nil); end
+  include MonitorMixin
+end
+module ActiveSupport::Dependencies
+  def _eager_load_paths; end
+  def _eager_load_paths=(obj); end
+  def autoload_module!(into, const_name, qualified_name, path_suffix); end
+  def autoload_once_paths; end
+  def autoload_once_paths=(obj); end
+  def autoload_paths; end
+  def autoload_paths=(obj); end
+  def autoloadable_module?(path_suffix); end
+  def autoloaded?(desc); end
+  def autoloaded_constants; end
+  def autoloaded_constants=(obj); end
+  def clear; end
+  def constant_watch_stack; end
+  def constant_watch_stack=(obj); end
+  def constantize(name); end
+  def depend_on(file_name, message = nil); end
+  def explicitly_unloadable_constants; end
+  def explicitly_unloadable_constants=(obj); end
+  def history; end
+  def history=(obj); end
+  def hook!; end
+  def interlock; end
+  def interlock=(obj); end
+  def load?; end
+  def load_file(path, const_paths = nil); end
+  def load_missing_constant(from_mod, const_name); end
+  def load_once_path?(path); end
+  def loadable_constants_for_path(path, bases = nil); end
+  def loaded; end
+  def loaded=(obj); end
+  def loading; end
+  def loading=(obj); end
+  def log(message); end
+  def logger; end
+  def logger=(obj); end
+  def mark_for_unload(const_desc); end
+  def mechanism; end
+  def mechanism=(obj); end
+  def new_constants_in(*descs); end
+  def qualified_const_defined?(path); end
+  def qualified_name_for(mod, name); end
+  def real_mod_name(mod); end
+  def reference(klass); end
+  def remove_constant(const); end
+  def remove_unloadable_constants!; end
+  def require_or_load(file_name, const_path = nil); end
+  def safe_constantize(name); end
+  def search_for_file(path_suffix); end
+  def self._eager_load_paths; end
+  def self._eager_load_paths=(obj); end
+  def self.autoload_once_paths; end
+  def self.autoload_once_paths=(obj); end
+  def self.autoload_paths; end
+  def self.autoload_paths=(obj); end
+  def self.autoloaded_constants; end
+  def self.autoloaded_constants=(obj); end
+  def self.constant_watch_stack; end
+  def self.constant_watch_stack=(obj); end
+  def self.explicitly_unloadable_constants; end
+  def self.explicitly_unloadable_constants=(obj); end
+  def self.history; end
+  def self.history=(obj); end
+  def self.interlock; end
+  def self.interlock=(obj); end
+  def self.load_interlock; end
+  def self.loaded; end
+  def self.loaded=(obj); end
+  def self.loading; end
+  def self.loading=(obj); end
+  def self.logger; end
+  def self.logger=(obj); end
+  def self.mechanism; end
+  def self.mechanism=(obj); end
+  def self.run_interlock; end
+  def self.unload_interlock; end
+  def self.verbose; end
+  def self.verbose=(obj); end
+  def self.warnings_on_first_load; end
+  def self.warnings_on_first_load=(obj); end
+  def to_constant_name(desc); end
+  def unhook!; end
+  def verbose; end
+  def verbose=(obj); end
+  def warnings_on_first_load; end
+  def warnings_on_first_load=(obj); end
+  def will_unload?(const_desc); end
+  extend ActiveSupport::Dependencies
+end
+class ActiveSupport::Dependencies::Interlock
+  def done_running; end
+  def done_unloading; end
+  def initialize; end
+  def loading; end
+  def permit_concurrent_loads; end
+  def raw_state(&block); end
+  def running; end
+  def start_running; end
+  def start_unloading; end
+  def unloading; end
+end
+class ActiveSupport::Dependencies::WatchStack
+  def each(&block); end
+  def initialize; end
+  def new_constants; end
+  def pop_modules(modules); end
+  def watch_namespaces(namespaces); end
+  def watching; end
+  def watching?; end
+  include Enumerable
+end
+module ActiveSupport::Dependencies::ModuleConstMissing
+  def const_missing(const_name); end
+  def guess_for_anonymous(const_name); end
+  def self.append_features(base); end
+  def self.exclude_from(base); end
+  def self.include_into(base); end
+  def unloadable(const_desc = nil); end
+end
+module ActiveSupport::Dependencies::Loadable
+  def load(file, wrap = nil); end
+  def load_dependency(file); end
+  def require(file); end
+  def require_dependency(file_name, message = nil); end
+  def require_or_load(file_name); end
+  def self.exclude_from(base); end
+  def self.include_into(base); end
+  def unloadable(const_desc); end
+end
+module ActiveSupport::Dependencies::Blamable
+  def blame_file!(file); end
+  def blamed_files; end
+  def copy_blame!(exc); end
+  def describe_blame; end
+end
+class ActiveSupport::Dependencies::ClassCache
+  def [](key); end
+  def clear!; end
+  def empty?; end
+  def get(key); end
+  def initialize; end
+  def key?(key); end
+  def safe_get(key); end
+  def store(klass); end
+end
+class ActiveSupport::ExecutionWrapper
+  def __callbacks; end
+  def __callbacks?; end
+  def _complete_callbacks; end
+  def _run_callbacks; end
+  def _run_complete_callbacks(&block); end
+  def _run_run_callbacks(&block); end
+  def complete!; end
+  def hook_state; end
+  def run!; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._complete_callbacks; end
+  def self._complete_callbacks=(value); end
+  def self._run_callbacks; end
+  def self._run_callbacks=(value); end
+  def self.active; end
+  def self.active=(arg0); end
+  def self.active?; end
+  def self.inherited(other); end
+  def self.register_hook(hook, outer: nil); end
+  def self.run!; end
+  def self.to_complete(*args, &block); end
+  def self.to_run(*args, &block); end
+  def self.wrap; end
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  include ActiveSupport::Callbacks
+end
+class ActiveSupport::ExecutionWrapper::RunHook < Struct
+  def before(target); end
+  def hook; end
+  def hook=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveSupport::ExecutionWrapper::CompleteHook < Struct
+  def after(target); end
+  def before(target); end
+  def hook; end
+  def hook=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class ActiveSupport::Executor < ActiveSupport::ExecutionWrapper
+end
+class ActiveSupport::Duration
+  def %(other); end
+  def *(other); end
+  def +(other); end
+  def -(other); end
+  def -@; end
+  def /(other); end
+  def <=>(other); end
+  def ==(other); end
+  def after(time = nil); end
+  def ago(time = nil); end
+  def as_json(options = nil); end
+  def before(time = nil); end
+  def coerce(other); end
+  def encode_with(coder); end
+  def eql?(other); end
+  def from_now(time = nil); end
+  def hash; end
+  def init_with(coder); end
+  def initialize(value, parts); end
+  def inspect; end
+  def instance_of?(klass); end
+  def is_a?(klass); end
+  def iso8601(precision: nil); end
+  def kind_of?(klass); end
+  def method_missing(method, *args, &block); end
+  def parts; end
+  def parts=(arg0); end
+  def raise_type_error(other); end
+  def respond_to_missing?(method, _); end
+  def self.===(other); end
+  def self.build(value); end
+  def self.calculate_total_seconds(parts); end
+  def self.days(value); end
+  def self.hours(value); end
+  def self.minutes(value); end
+  def self.months(value); end
+  def self.parse(iso8601duration); end
+  def self.seconds(value); end
+  def self.weeks(value); end
+  def self.years(value); end
+  def since(time = nil); end
+  def sum(sign, time = nil); end
+  def to_i; end
+  def to_s; end
+  def until(time = nil); end
+  def value; end
+  def value=(arg0); end
+end
+class ActiveSupport::Duration::Scalar < Numeric
+  def %(other); end
+  def *(other); end
+  def +(other); end
+  def -(other); end
+  def -@; end
+  def /(other); end
+  def <=>(other); end
+  def calculate(op, other); end
+  def coerce(other); end
+  def initialize(value); end
+  def raise_type_error(other); end
+  def to_f(*args, &block); end
+  def to_i(*args, &block); end
+  def to_s(*args, &block); end
+  def value; end
+end
+class ActiveSupport::TimeWithZone
+  def +(other); end
+  def -(other); end
+  def <=>(other); end
+  def acts_like_time?; end
+  def advance(options); end
+  def after?(arg0); end
+  def ago(other); end
+  def as_json(options = nil); end
+  def before?(arg0); end
+  def between?(min, max); end
+  def blank?; end
+  def change(options); end
+  def comparable_time; end
+  def day; end
+  def dst?; end
+  def duration_of_variable_length?(obj); end
+  def encode_with(coder); end
+  def eql?(other); end
+  def formatted_offset(colon = nil, alternate_utc_string = nil); end
+  def freeze; end
+  def future?; end
+  def get_period_and_ensure_valid_local_time(period); end
+  def getgm; end
+  def getlocal(utc_offset = nil); end
+  def getutc; end
+  def gmt?; end
+  def gmt_offset; end
+  def gmtime; end
+  def gmtoff; end
+  def hash; end
+  def hour; end
+  def httpdate; end
+  def in(other); end
+  def in_time_zone(new_zone = nil); end
+  def init_with(coder); end
+  def initialize(utc_time, time_zone, local_time = nil, period = nil); end
+  def inspect; end
+  def is_a?(klass); end
+  def isdst; end
+  def iso8601(fraction_digits = nil); end
+  def kind_of?(klass); end
+  def localtime(utc_offset = nil); end
+  def marshal_dump; end
+  def marshal_load(variables); end
+  def mday; end
+  def method_missing(sym, *args, &block); end
+  def min; end
+  def mon; end
+  def month; end
+  def nsec; end
+  def past?; end
+  def period; end
+  def respond_to?(sym, include_priv = nil); end
+  def respond_to_missing?(sym, include_priv); end
+  def rfc2822; end
+  def rfc3339(fraction_digits = nil); end
+  def rfc822; end
+  def sec; end
+  def self.name; end
+  def since(other); end
+  def strftime(format); end
+  def time; end
+  def time_zone; end
+  def to_a; end
+  def to_date; end
+  def to_datetime; end
+  def to_f; end
+  def to_formatted_s(format = nil); end
+  def to_i; end
+  def to_r; end
+  def to_s(format = nil); end
+  def to_time; end
+  def today?; end
+  def transfer_time_values_to_utc_constructor(time); end
+  def tv_sec; end
+  def usec; end
+  def utc; end
+  def utc?; end
+  def utc_offset; end
+  def wday; end
+  def wrap_with_time_zone(time); end
+  def xmlschema(fraction_digits = nil); end
+  def yday; end
+  def year; end
+  def zone; end
+  include Comparable
+end
+module ActiveSupport::Tryable
+  def try!(method_name = nil, *args, &b); end
+  def try(method_name = nil, *args, &b); end
+end
+class Delegator < BasicObject
+  include ActiveSupport::Tryable
+end
+module DateAndTime::Calculations
+  def after?(date_or_time); end
+  def all_day; end
+  def all_month; end
+  def all_quarter; end
+  def all_week(start_day = nil); end
+  def all_year; end
+  def at_beginning_of_month; end
+  def at_beginning_of_quarter; end
+  def at_beginning_of_week(start_day = nil); end
+  def at_beginning_of_year; end
+  def at_end_of_month; end
+  def at_end_of_quarter; end
+  def at_end_of_week(start_day = nil); end
+  def at_end_of_year; end
+  def before?(date_or_time); end
+  def beginning_of_month; end
+  def beginning_of_quarter; end
+  def beginning_of_week(start_day = nil); end
+  def beginning_of_year; end
+  def copy_time_to(other); end
+  def days_ago(days); end
+  def days_since(days); end
+  def days_span(day); end
+  def days_to_week_start(start_day = nil); end
+  def end_of_month; end
+  def end_of_quarter; end
+  def end_of_week(start_day = nil); end
+  def end_of_year; end
+  def first_hour(date_or_time); end
+  def future?; end
+  def last_hour(date_or_time); end
+  def last_month; end
+  def last_quarter; end
+  def last_week(start_day = nil, same_time: nil); end
+  def last_weekday; end
+  def last_year; end
+  def monday; end
+  def months_ago(months); end
+  def months_since(months); end
+  def next_occurring(day_of_week); end
+  def next_quarter; end
+  def next_week(given_day_in_next_week = nil, same_time: nil); end
+  def next_weekday; end
+  def on_weekday?; end
+  def on_weekend?; end
+  def past?; end
+  def prev_occurring(day_of_week); end
+  def prev_quarter; end
+  def prev_week(start_day = nil, same_time: nil); end
+  def prev_weekday; end
+  def sunday; end
+  def today?; end
+  def tomorrow; end
+  def weeks_ago(weeks); end
+  def weeks_since(weeks); end
+  def years_ago(years); end
+  def years_since(years); end
+  def yesterday; end
+end
+class ActiveSupport::FileUpdateChecker
+  def compile_ext(array); end
+  def compile_glob(hash); end
+  def escape(key); end
+  def execute; end
+  def execute_if_updated; end
+  def initialize(files, dirs = nil, &block); end
+  def max_mtime(paths); end
+  def updated?; end
+  def updated_at(paths); end
+  def watched; end
+end
+class ActiveSupport::EventedFileUpdateChecker
+  def boot!; end
+  def changed(modified, added, removed); end
+  def directories_to_watch; end
+  def execute; end
+  def execute_if_updated; end
+  def initialize(files, dirs = nil, &block); end
+  def normalize_dirs!; end
+  def shutdown!; end
+  def updated?; end
+  def watching?(file); end
+end
+class ActiveSupport::EventedFileUpdateChecker::PathHelper
+  def ascendant_of?(base, other); end
+  def existing_parent(dir); end
+  def filter_out_descendants(dirs); end
+  def longest_common_subpath(paths); end
+  def normalize_extension(ext); end
+  def xpath(path); end
+end
+class ActiveSupport::Subscriber
+  def self.add_event_subscriber(event); end
+  def self.attach_to(namespace, subscriber = nil, notifier = nil); end
+  def self.detach_from(namespace, notifier = nil); end
+  def self.find_attached_subscriber; end
+  def self.invalid_event?(event); end
+  def self.method_added(event); end
+  def self.namespace; end
+  def self.notifier; end
+  def self.pattern_subscribed?(pattern); end
+  def self.prepare_pattern(event); end
+  def self.remove_event_subscriber(event); end
+  def self.subscriber; end
+  def self.subscribers; end
+end
+class ActiveSupport::SubscriberQueueRegistry
+  def get_queue(queue_key); end
+  def initialize; end
+  extend ActiveSupport::PerThreadRegistry
+end
+class ActiveSupport::LogSubscriber < ActiveSupport::Subscriber
+  def self.colorize_logging; end
+  def self.colorize_logging=(obj); end
+  def self.flush_all!; end
+  def self.log_subscribers; end
+  def self.logger; end
+  def self.logger=(arg0); end
+end
+class ActiveSupport::Reloader < ActiveSupport::ExecutionWrapper
+  def _class_unload_callbacks; end
+  def _prepare_callbacks; end
+  def _run_class_unload_callbacks(&block); end
+  def _run_prepare_callbacks(&block); end
+  def check; end
+  def check=(val); end
+  def check?; end
+  def class_unload!(&block); end
+  def complete!; end
+  def executor; end
+  def executor=(val); end
+  def executor?; end
+  def initialize; end
+  def release_unload_lock!; end
+  def require_unload_lock!; end
+  def run!; end
+  def self.__callbacks; end
+  def self._class_unload_callbacks; end
+  def self._class_unload_callbacks=(value); end
+  def self._prepare_callbacks; end
+  def self._prepare_callbacks=(value); end
+  def self.after_class_unload(*args, &block); end
+  def self.before_class_unload(*args, &block); end
+  def self.check!; end
+  def self.check; end
+  def self.check=(val); end
+  def self.check?; end
+  def self.executor; end
+  def self.executor=(val); end
+  def self.executor?; end
+  def self.prepare!; end
+  def self.reload!; end
+  def self.reloaded!; end
+  def self.run!; end
+  def self.to_prepare(*args, &block); end
+  def self.wrap; end
+end
+class ActiveSupport::BacktraceCleaner
+  def add_filter(&block); end
+  def add_gem_filter; end
+  def add_gem_silencer; end
+  def add_silencer(&block); end
+  def add_stdlib_silencer; end
+  def clean(backtrace, kind = nil); end
+  def filter(backtrace, kind = nil); end
+  def filter_backtrace(backtrace); end
+  def initialize; end
+  def noise(backtrace); end
+  def remove_filters!; end
+  def remove_silencers!; end
+  def silence(backtrace); end
+end
+class ActiveSupport::ProxyObject < BasicObject
+  def raise(*args); end
+end
+module Benchmark
+  def self.ms; end
+end
+module ActiveSupport::Benchmarkable
+  def benchmark(message = nil, options = nil); end
+end
+module ActiveSupport::Cache
+  def self.expand_cache_key(key, namespace = nil); end
+  def self.lookup_store(store = nil, *parameters); end
+  def self.retrieve_cache_key(key); end
+  def self.retrieve_store_class(store); end
+end
+module ActiveSupport::Cache::Strategy
+end
+class ActiveSupport::Cache::Store
+  def cleanup(options = nil); end
+  def clear(options = nil); end
+  def decrement(name, amount = nil, options = nil); end
+  def delete(name, options = nil); end
+  def delete_entry(key, **options); end
+  def delete_matched(matcher, options = nil); end
+  def exist?(name, options = nil); end
+  def expanded_key(key); end
+  def expanded_version(key); end
+  def fetch(name, options = nil); end
+  def fetch_multi(*names); end
+  def get_entry_value(entry, name, options); end
+  def handle_expired_entry(entry, key, options); end
+  def increment(name, amount = nil, options = nil); end
+  def initialize(options = nil); end
+  def instrument(operation, key, options = nil); end
+  def key_matcher(pattern, options); end
+  def log; end
+  def logger; end
+  def logger=(obj); end
+  def merged_options(call_options); end
+  def mute; end
+  def namespace_key(key, options = nil); end
+  def normalize_key(key, options = nil); end
+  def normalize_version(key, options = nil); end
+  def options; end
+  def read(name, options = nil); end
+  def read_entry(key, **options); end
+  def read_multi(*names); end
+  def read_multi_entries(names, **options); end
+  def save_block_result_to_cache(name, **options); end
+  def self.ensure_connection_pool_added!; end
+  def self.logger; end
+  def self.logger=(obj); end
+  def self.retrieve_pool_options(options); end
+  def silence!; end
+  def silence; end
+  def silence?; end
+  def write(name, value, options = nil); end
+  def write_entry(key, entry, **options); end
+  def write_multi(hash, options = nil); end
+  def write_multi_entries(hash, **options); end
+end
+class ActiveSupport::Cache::Entry
+  def compress!(compress_threshold); end
+  def compressed?; end
+  def dup_value!; end
+  def expired?; end
+  def expires_at; end
+  def expires_at=(value); end
+  def initialize(value, compress: nil, compress_threshold: nil, version: nil, expires_in: nil, **arg5); end
+  def mismatched?(version); end
+  def size; end
+  def uncompress(value); end
+  def value; end
+  def version; end
+end
+module ActiveSupport::MarshalWithAutoloading
+  def load(source, proc = nil); end
+end
+class File < IO
+  def self.atomic_write(file_name, temp_dir = nil); end
+  def self.probe_stat_in(dir); end
+end
+module ActiveSupport::Cache::Strategy::LocalCache
+  def bypass_local_cache; end
+  def cleanup(**options); end
+  def clear(**options); end
+  def decrement(name, amount = nil, **options); end
+  def delete_entry(key, **options); end
+  def increment(name, amount = nil, **options); end
+  def local_cache; end
+  def local_cache_key; end
+  def middleware; end
+  def read_entry(key, **options); end
+  def read_multi_entries(keys, **options); end
+  def use_temporary_local_cache(temporary_cache); end
+  def with_local_cache; end
+  def write_cache_value(name, value, **options); end
+  def write_entry(key, entry, **options); end
+end
+class ActiveSupport::Cache::Strategy::LocalCache::LocalCacheRegistry
+  def cache_for(local_cache_key); end
+  def initialize; end
+  def self.cache_for(l); end
+  def self.set_cache_for(l, v); end
+  def set_cache_for(local_cache_key, value); end
+  extend ActiveSupport::PerThreadRegistry
+end
+class ActiveSupport::Cache::Strategy::LocalCache::LocalStore < ActiveSupport::Cache::Store
+  def clear(options = nil); end
+  def delete_entry(key, **options); end
+  def fetch_entry(key, options = nil); end
+  def initialize; end
+  def read_entry(key, **options); end
+  def read_multi_entries(keys, **options); end
+  def synchronize; end
+  def write_entry(key, value, **options); end
+end
+class ActiveSupport::Cache::FileStore < ActiveSupport::Cache::Store
+  def cache_path; end
+  def cleanup(**options); end
+  def clear(**options); end
+  def decrement(name, amount = nil, **options); end
+  def delete_empty_directories(dir); end
+  def delete_entry(key, **options); end
+  def delete_matched(matcher, options = nil); end
+  def ensure_cache_path(path); end
+  def file_path_key(path); end
+  def increment(name, amount = nil, **options); end
+  def initialize(cache_path, options = nil); end
+  def lock_file(file_name, &block); end
+  def modify_value(name, amount, options); end
+  def normalize_key(key, options); end
+  def read_entry(key, **options); end
+  def search_dir(dir, &callback); end
+  def self.supports_cache_versioning?; end
+  def write_entry(key, entry, **options); end
+end
+class ActiveSupport::Cache::MemoryStore < ActiveSupport::Cache::Store
+  def cached_size(key, entry); end
+  def cleanup(options = nil); end
+  def clear(options = nil); end
+  def decrement(name, amount = nil, options = nil); end
+  def delete_entry(key, **options); end
+  def delete_matched(matcher, options = nil); end
+  def increment(name, amount = nil, options = nil); end
+  def initialize(options = nil); end
+  def inspect; end
+  def modify_value(name, amount, options); end
+  def prune(target_size, max_time = nil); end
+  def pruning?; end
+  def read_entry(key, **options); end
+  def self.supports_cache_versioning?; end
+  def synchronize(&block); end
+  def write_entry(key, entry, **options); end
+end
+class ActiveSupport::Cache::NullStore < ActiveSupport::Cache::Store
+  def cleanup(**options); end
+  def clear(**options); end
+  def decrement(name, amount = nil, **options); end
+  def delete_entry(key, **options); end
+  def delete_matched(matcher, options = nil); end
+  def increment(name, amount = nil, **options); end
+  def read_entry(key, **options); end
+  def self.supports_cache_versioning?; end
+  def write_entry(key, entry, **options); end
+end
+class ActiveSupport::OrderedOptions < Hash
+  def [](key); end
+  def []=(key, value); end
+  def _get(arg0); end
+  def extractable_options?; end
+  def method_missing(name, *args); end
+  def respond_to_missing?(name, include_private); end
+end
+class ActiveSupport::InheritableOptions < ActiveSupport::OrderedOptions
+  def inheritable_copy; end
+  def initialize(parent = nil); end
+end
+module ActiveSupport::Configurable
+  def config; end
+  extend ActiveSupport::Concern
+end
+class ActiveSupport::Configurable::Configuration < ActiveSupport::InheritableOptions
+  def compile_methods!; end
+  def self.compile_methods!(keys); end
+end
+module ActiveSupport::Configurable::ClassMethods
+  def config; end
+  def config_accessor(*names, instance_reader: nil, instance_writer: nil, instance_accessor: nil); end
+  def configure; end
+end
+class Integer < Numeric
+  def month; end
+  def months; end
+  def year; end
+  def years; end
+end
+class ActiveSupport::HashWithIndifferentAccess < Hash
+  def [](key); end
+  def []=(key, value); end
+  def assoc(key); end
+  def compact; end
+  def convert_key(key); end
+  def convert_value(value, options = nil); end
+  def deep_stringify_keys!; end
+  def deep_stringify_keys; end
+  def deep_symbolize_keys; end
+  def default(*args); end
+  def delete(key); end
+  def dig(*args); end
+  def dup; end
+  def except(*keys); end
+  def extractable_options?; end
+  def fetch(key, *extras); end
+  def fetch_values(*indices, &block); end
+  def has_key?(key); end
+  def include?(key); end
+  def initialize(constructor = nil); end
+  def key?(key); end
+  def member?(key); end
+  def merge!(other_hash); end
+  def merge(hash, &block); end
+  def nested_under_indifferent_access; end
+  def regular_update(*arg0); end
+  def regular_writer(arg0, arg1); end
+  def reject(*args, &block); end
+  def replace(other_hash); end
+  def reverse_merge!(other_hash); end
+  def reverse_merge(other_hash); end
+  def select(*args, &block); end
+  def self.[](*args); end
+  def set_defaults(target); end
+  def slice!(*keys); end
+  def slice(*keys); end
+  def store(key, value); end
+  def stringify_keys!; end
+  def stringify_keys; end
+  def symbolize_keys; end
+  def to_hash; end
+  def to_options!; end
+  def to_options; end
+  def transform_keys!; end
+  def transform_keys(*args, &block); end
+  def transform_values(*args, &block); end
+  def update(other_hash); end
+  def values_at(*keys); end
+  def with_defaults!(other_hash); end
+  def with_defaults(other_hash); end
+  def with_indifferent_access; end
+  def without(*keys); end
+end
+class ActiveSupport::ParameterFilter
+  def compiled_filter; end
+  def filter(params); end
+  def filter_param(key, value); end
+  def initialize(filters = nil, mask: nil); end
+end
+class ActiveSupport::ParameterFilter::CompiledFilter
+  def blocks; end
+  def call(params, parents = nil, original_params = nil); end
+  def deep_regexps; end
+  def initialize(regexps, deep_regexps, blocks, mask:); end
+  def regexps; end
+  def self.compile(filters, mask:); end
+  def value_for_key(key, value, parents = nil, original_params = nil); end
+end
+class ActiveSupport::ArrayInquirer < Array
+  def any?(*candidates); end
+  def method_missing(name, *args); end
+  def respond_to_missing?(name, include_private = nil); end
+end
+module ActiveSupport::RangeWithFormat
+  def to_default_s(format = nil); end
+  def to_formatted_s(format = nil); end
+  def to_s(format = nil); end
+end
+module ActiveSupport::CompareWithRange
+  def ===(value); end
+  def cover?(value); end
+  def include?(value); end
+end
+module ActiveSupport::IncludeTimeWithZone
+  def include?(value); end
+end
+module ActiveSupport::EachTimeWithZone
+  def each(&block); end
+  def ensure_iteration_allowed; end
+  def step(n = nil, &block); end
+end
diff --git a/sorbet/rbi/gems/coderay.rbi b/sorbet/rbi/gems/coderay.rbi
new file mode 100644
index 0000000..49b4687
--- /dev/null
+++ b/sorbet/rbi/gems/coderay.rbi
@@ -0,0 +1,92 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/coderay/all/coderay.rbi
+#
+# coderay-1.1.3
+
+module CodeRay
+  def self.coderay_path(*path); end
+  def self.encode(code, lang, format, options = nil); end
+  def self.encode_file(filename, format, options = nil); end
+  def self.encode_tokens(tokens, format, options = nil); end
+  def self.encoder(format, options = nil); end
+  def self.get_scanner_options(options); end
+  def self.highlight(code, lang, options = nil, format = nil); end
+  def self.highlight_file(filename, options = nil, format = nil); end
+  def self.scan(code, lang, options = nil, &block); end
+  def self.scan_file(filename, lang = nil, options = nil, &block); end
+  def self.scanner(lang, options = nil, &block); end
+end
+module CodeRay::PluginHost
+  def [](id, *args, &blk); end
+  def all_plugins; end
+  def const_missing(const); end
+  def default(id = nil); end
+  def list; end
+  def load(id, *args, &blk); end
+  def load_all; end
+  def load_plugin_map; end
+  def make_plugin_hash; end
+  def map(hash); end
+  def path_to(plugin_id); end
+  def plugin_hash; end
+  def plugin_path(*args); end
+  def register(plugin, id); end
+  def self.extended(mod); end
+  def validate_id(id); end
+end
+class CodeRay::PluginHost::PluginNotFound < LoadError
+end
+class CodeRay::PluginHost::HostNotFound < LoadError
+end
+module CodeRay::Encoders
+  extend CodeRay::PluginHost
+end
+module CodeRay::Plugin
+  def aliases; end
+  def plugin_host(host = nil); end
+  def plugin_id; end
+  def register_for(id); end
+  def title(title = nil); end
+end
+class CodeRay::Encoders::Encoder
+  def <<(token); end
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def compile(tokens, options = nil); end
+  def encode(code, lang, options = nil); end
+  def encode_tokens(tokens, options = nil); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def file_extension; end
+  def finish(options); end
+  def get_output(options); end
+  def highlight(code, lang, options = nil); end
+  def initialize(options = nil); end
+  def options; end
+  def options=(arg0); end
+  def output(data); end
+  def scanner; end
+  def scanner=(arg0); end
+  def self.const_missing(sym); end
+  def self.file_extension; end
+  def setup(options); end
+  def text_token(text, kind); end
+  def token(content, kind); end
+  def tokens(tokens, options = nil); end
+  extend CodeRay::Plugin
+end
+class CodeRay::Encoders::Terminal < CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def open_token(kind); end
+  def setup(options); end
+  def text_token(text, kind); end
+end
diff --git a/sorbet/rbi/gems/concurrent-ruby.rbi b/sorbet/rbi/gems/concurrent-ruby.rbi
new file mode 100644
index 0000000..4f405f6
--- /dev/null
+++ b/sorbet/rbi/gems/concurrent-ruby.rbi
@@ -0,0 +1,1590 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
+#
+# concurrent-ruby-1.1.7
+
+module Concurrent
+  def abort_transaction; end
+  def atomically; end
+  def call_dataflow(method, executor, *inputs, &block); end
+  def dataflow!(*inputs, &block); end
+  def dataflow(*inputs, &block); end
+  def dataflow_with!(executor, *inputs, &block); end
+  def dataflow_with(executor, *inputs, &block); end
+  def leave_transaction; end
+  def monotonic_time; end
+  def self.abort_transaction; end
+  def self.atomically; end
+  def self.call_dataflow(method, executor, *inputs, &block); end
+  def self.create_simple_logger(level = nil, output = nil); end
+  def self.create_stdlib_logger(level = nil, output = nil); end
+  def self.dataflow!(*inputs, &block); end
+  def self.dataflow(*inputs, &block); end
+  def self.dataflow_with!(executor, *inputs, &block); end
+  def self.dataflow_with(executor, *inputs, &block); end
+  def self.disable_at_exit_handlers!; end
+  def self.executor(executor_identifier); end
+  def self.global_fast_executor; end
+  def self.global_immediate_executor; end
+  def self.global_io_executor; end
+  def self.global_logger; end
+  def self.global_logger=(value); end
+  def self.global_timer_set; end
+  def self.leave_transaction; end
+  def self.monotonic_time; end
+  def self.new_fast_executor(opts = nil); end
+  def self.new_io_executor(opts = nil); end
+  def self.physical_processor_count; end
+  def self.processor_count; end
+  def self.processor_counter; end
+  def self.use_simple_logger(level = nil, output = nil); end
+  def self.use_stdlib_logger(level = nil, output = nil); end
+  extend Concurrent::Concern::Deprecation
+  extend Concurrent::Concern::Logging
+  extend Concurrent::Utility::EngineDetector
+  extend Concurrent::Utility::NativeExtensionLoader
+end
+module Concurrent::Utility
+end
+module Concurrent::Utility::EngineDetector
+  def on_cruby?; end
+  def on_jruby?; end
+  def on_jruby_9000?; end
+  def on_linux?; end
+  def on_osx?; end
+  def on_rbx?; end
+  def on_truffleruby?; end
+  def on_windows?; end
+  def ruby_engine; end
+  def ruby_version(version = nil, comparison, major, minor, patch); end
+end
+module Concurrent::Synchronization
+end
+class Concurrent::Synchronization::AbstractObject
+  def full_memory_barrier; end
+  def initialize; end
+  def self.attr_volatile(*names); end
+end
+module Concurrent::Utility::NativeExtensionLoader
+  def allow_c_extensions?; end
+  def c_extensions_loaded?; end
+  def java_extensions_loaded?; end
+  def load_error_path(error); end
+  def load_native_extensions; end
+  def set_c_extensions_loaded; end
+  def set_java_extensions_loaded; end
+  def try_load_c_extension(path); end
+end
+module Concurrent::Synchronization::MriAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::MriAttrVolatile
+end
+module Concurrent::Synchronization::RbxAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::RbxAttrVolatile
+end
+module Concurrent::Synchronization::TruffleRubyAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::TruffleRubyAttrVolatile
+end
+class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
+  def __initialize_atomic_fields__; end
+  def initialize; end
+  def self.atomic_attribute?(name); end
+  def self.atomic_attributes(inherited = nil); end
+  def self.attr_atomic(*names); end
+  def self.define_initialize_atomic_fields; end
+  def self.ensure_safe_initialization_when_final_fields_are_present; end
+  def self.safe_initialization!; end
+  def self.safe_initialization?; end
+end
+class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def synchronize; end
+end
+module Concurrent::Synchronization::ConditionSignalling
+  def ns_broadcast; end
+  def ns_signal; end
+end
+class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize; end
+  include Concurrent::Synchronization::ConditionSignalling
+end
+class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize; end
+  include Concurrent::Synchronization::ConditionSignalling
+end
+class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize(&block); end
+end
+class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
+  def new_condition; end
+end
+class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
+  def broadcast; end
+  def initialize(lock); end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def self.new(*args, &block); end
+  def self.private_new(*args, &block); end
+  def signal; end
+  def wait(timeout = nil); end
+  def wait_until(timeout = nil, &condition); end
+end
+class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
+  def broadcast; end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def signal; end
+  def synchronize; end
+  def wait(timeout = nil); end
+  def wait_until(timeout = nil, &condition); end
+end
+module Concurrent::Collection
+end
+class Concurrent::Collection::NonConcurrentMapBackend
+  def [](key); end
+  def []=(key, value); end
+  def _get(key); end
+  def _set(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def dupped_backend; end
+  def each_pair; end
+  def get_and_set(key, value); end
+  def get_or_default(key, default_value); end
+  def initialize(options = nil); end
+  def initialize_copy(other); end
+  def key?(key); end
+  def merge_pair(key, value); end
+  def pair?(key, expected_value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+  def size; end
+  def store_computed_value(key, new_value); end
+end
+class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
+  def []=(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def get_and_set(key, value); end
+  def initialize(options = nil); end
+  def merge_pair(key, value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+end
+class Concurrent::Map < Concurrent::Collection::MriMapBackend
+  def [](key); end
+  def each; end
+  def each_key; end
+  def each_pair; end
+  def each_value; end
+  def empty?; end
+  def fetch(key, default_value = nil); end
+  def fetch_or_store(key, default_value = nil); end
+  def get(key); end
+  def initialize(options = nil, &block); end
+  def initialize_copy(other); end
+  def inspect; end
+  def key(value); end
+  def keys; end
+  def marshal_dump; end
+  def marshal_load(hash); end
+  def populate_from(hash); end
+  def put(key, value); end
+  def put_if_absent(key, value); end
+  def raise_fetch_no_key; end
+  def validate_options_hash!(options); end
+  def value?(value); end
+  def values; end
+end
+class Concurrent::Error < StandardError
+end
+class Concurrent::ConfigurationError < Concurrent::Error
+end
+class Concurrent::CancelledOperationError < Concurrent::Error
+end
+class Concurrent::LifecycleError < Concurrent::Error
+end
+class Concurrent::ImmutabilityError < Concurrent::Error
+end
+class Concurrent::IllegalOperationError < Concurrent::Error
+end
+class Concurrent::InitializationError < Concurrent::Error
+end
+class Concurrent::MaxRestartFrequencyError < Concurrent::Error
+end
+class Concurrent::MultipleAssignmentError < Concurrent::Error
+  def initialize(message = nil, inspection_data = nil); end
+  def inspect; end
+  def inspection_data; end
+end
+class Concurrent::RejectedExecutionError < Concurrent::Error
+end
+class Concurrent::ResourceLimitError < Concurrent::Error
+end
+class Concurrent::TimeoutError < Concurrent::Error
+end
+class Concurrent::MultipleErrors < Concurrent::Error
+  def errors; end
+  def initialize(errors, message = nil); end
+end
+class Concurrent::Event < Concurrent::Synchronization::LockableObject
+  def initialize; end
+  def ns_initialize; end
+  def ns_set; end
+  def reset; end
+  def set; end
+  def set?; end
+  def try?; end
+  def wait(timeout = nil); end
+end
+module Concurrent::Concern
+end
+module Concurrent::Concern::Dereferenceable
+  def apply_deref_options(value); end
+  def deref; end
+  def ns_set_deref_options(opts); end
+  def set_deref_options(opts = nil); end
+  def value; end
+  def value=(value); end
+end
+module Concurrent::Concern::Obligation
+  def compare_and_set_state(next_state, *expected_current); end
+  def complete?; end
+  def event; end
+  def exception(*args); end
+  def fulfilled?; end
+  def get_arguments_from(opts = nil); end
+  def if_state(*expected_states); end
+  def incomplete?; end
+  def init_obligation; end
+  def no_error!(timeout = nil); end
+  def ns_check_state?(expected); end
+  def ns_set_state(value); end
+  def pending?; end
+  def realized?; end
+  def reason; end
+  def rejected?; end
+  def set_state(success, value, reason); end
+  def state; end
+  def state=(value); end
+  def unscheduled?; end
+  def value!(timeout = nil); end
+  def value(timeout = nil); end
+  def wait!(timeout = nil); end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Dereferenceable
+end
+module Concurrent::Concern::Logging
+  def log(level, progname, message = nil, &block); end
+  include Logger::Severity
+end
+module Concurrent::Concern::Deprecation
+  def deprecated(message, strip = nil); end
+  def deprecated_method(old_name, new_name); end
+  extend Concurrent::Concern::Deprecation
+  include Concurrent::Concern::Logging
+end
+module Concurrent::ExecutorService
+  def <<(task); end
+  def can_overflow?; end
+  def post(*args, &task); end
+  def serialized?; end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
+  def auto_terminate=(value); end
+  def auto_terminate?; end
+  def fallback_policy; end
+  def handle_fallback(*args); end
+  def initialize(opts = nil, &block); end
+  def kill; end
+  def name; end
+  def ns_auto_terminate?; end
+  def ns_execute(*args, &task); end
+  def ns_kill_execution; end
+  def ns_shutdown_execution; end
+  def running?; end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def to_s; end
+  def wait_for_termination(timeout = nil); end
+  include Concurrent::Concern::Deprecation
+  include Concurrent::ExecutorService
+end
+module Concurrent::SerialExecutorService
+  def serialized?; end
+  include Concurrent::ExecutorService
+end
+class Concurrent::ImmediateExecutor < Concurrent::AbstractExecutorService
+  def <<(task); end
+  def initialize; end
+  def kill; end
+  def post(*args, &task); end
+  def running?; end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def wait_for_termination(timeout = nil); end
+  include Concurrent::SerialExecutorService
+end
+class Concurrent::Delay < Concurrent::Synchronization::LockableObject
+  def execute_task_once; end
+  def initialize(opts = nil, &block); end
+  def ns_initialize(opts, &block); end
+  def reconfigure(&block); end
+  def value!(timeout = nil); end
+  def value(timeout = nil); end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Obligation
+end
+module Concurrent::AtomicNumericCompareAndSetWrapper
+  def compare_and_set(old_value, new_value); end
+end
+class Concurrent::MutexAtomicReference < Concurrent::Synchronization::LockableObject
+  def _compare_and_set(old_value, new_value); end
+  def compare_and_swap(old_value, new_value); end
+  def get; end
+  def get_and_set(new_value); end
+  def initialize(value = nil); end
+  def ns_initialize(value); end
+  def set(new_value); end
+  def swap(new_value); end
+  def value; end
+  def value=(new_value); end
+  include Concurrent::AtomicDirectUpdate
+  include Concurrent::AtomicNumericCompareAndSetWrapper
+end
+module Concurrent::AtomicDirectUpdate
+  def try_update!; end
+  def try_update; end
+  def update; end
+end
+class Concurrent::ConcurrentUpdateError < ThreadError
+end
+class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
+  def inspect; end
+  def to_s; end
+end
+class Concurrent::RubyExecutorService < Concurrent::AbstractExecutorService
+  def initialize(*args, &block); end
+  def kill; end
+  def ns_running?; end
+  def ns_shutdown?; end
+  def ns_shutdown_execution; end
+  def ns_shuttingdown?; end
+  def post(*args, &task); end
+  def shutdown; end
+  def stop_event; end
+  def stopped_event; end
+  def wait_for_termination(timeout = nil); end
+end
+class Concurrent::RubyThreadPoolExecutor < Concurrent::RubyExecutorService
+  def can_overflow?; end
+  def completed_task_count; end
+  def idletime; end
+  def initialize(opts = nil); end
+  def largest_length; end
+  def length; end
+  def max_length; end
+  def max_queue; end
+  def min_length; end
+  def ns_add_busy_worker; end
+  def ns_assign_worker(*args, &task); end
+  def ns_enqueue(*args, &task); end
+  def ns_execute(*args, &task); end
+  def ns_initialize(opts); end
+  def ns_kill_execution; end
+  def ns_limited_queue?; end
+  def ns_prune_pool; end
+  def ns_ready_worker(worker, success = nil); end
+  def ns_remove_busy_worker(worker); end
+  def ns_reset_if_forked; end
+  def ns_shutdown_execution; end
+  def ns_worker_died(worker); end
+  def ns_worker_not_old_enough(worker); end
+  def queue_length; end
+  def ready_worker(worker); end
+  def remaining_capacity; end
+  def remove_busy_worker(worker); end
+  def scheduled_task_count; end
+  def synchronous; end
+  def worker_died(worker); end
+  def worker_not_old_enough(worker); end
+  def worker_task_completed; end
+end
+class Concurrent::RubyThreadPoolExecutor::Worker
+  def <<(message); end
+  def create_worker(queue, pool, idletime); end
+  def initialize(pool, id); end
+  def kill; end
+  def run_task(pool, task, args); end
+  def stop; end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::ThreadPoolExecutor < Concurrent::RubyThreadPoolExecutor
+end
+class Concurrent::CachedThreadPool < Concurrent::ThreadPoolExecutor
+  def initialize(opts = nil); end
+  def ns_initialize(opts); end
+end
+class Concurrent::Utility::ProcessorCounter
+  def compute_physical_processor_count; end
+  def compute_processor_count; end
+  def initialize; end
+  def physical_processor_count; end
+  def processor_count; end
+end
+class Concurrent::MutexAtomicBoolean < Concurrent::Synchronization::LockableObject
+  def false?; end
+  def initialize(initial = nil); end
+  def make_false; end
+  def make_true; end
+  def ns_initialize(initial); end
+  def ns_make_value(value); end
+  def true?; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::AtomicBoolean < Concurrent::MutexAtomicBoolean
+  def inspect; end
+  def to_s; end
+end
+module Concurrent::Utility::NativeInteger
+  def ensure_integer(value); end
+  def ensure_integer_and_bounds(value); end
+  def ensure_lower_bound(value); end
+  def ensure_positive(value); end
+  def ensure_positive_and_no_zero(value); end
+  def ensure_upper_bound(value); end
+  extend Concurrent::Utility::NativeInteger
+end
+class Concurrent::MutexAtomicFixnum < Concurrent::Synchronization::LockableObject
+  def compare_and_set(expect, update); end
+  def decrement(delta = nil); end
+  def down(delta = nil); end
+  def increment(delta = nil); end
+  def initialize(initial = nil); end
+  def ns_initialize(initial); end
+  def ns_set(value); end
+  def up(delta = nil); end
+  def update; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::AtomicFixnum < Concurrent::MutexAtomicFixnum
+  def inspect; end
+  def to_s; end
+end
+class Concurrent::CyclicBarrier < Concurrent::Synchronization::LockableObject
+  def broken?; end
+  def initialize(parties, &block); end
+  def ns_generation_done(generation, status, continue = nil); end
+  def ns_initialize(parties, &block); end
+  def ns_next_generation; end
+  def number_waiting; end
+  def parties; end
+  def reset; end
+  def wait(timeout = nil); end
+end
+class Concurrent::CyclicBarrier::Generation < Struct
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def status; end
+  def status=(_); end
+end
+class Concurrent::MutexCountDownLatch < Concurrent::Synchronization::LockableObject
+  def count; end
+  def count_down; end
+  def initialize(count = nil); end
+  def ns_initialize(count); end
+  def wait(timeout = nil); end
+end
+class Concurrent::CountDownLatch < Concurrent::MutexCountDownLatch
+end
+class Concurrent::ReadWriteLock < Concurrent::Synchronization::Object
+  def acquire_read_lock; end
+  def acquire_write_lock; end
+  def has_waiters?; end
+  def initialize; end
+  def max_readers?(c = nil); end
+  def max_writers?(c = nil); end
+  def release_read_lock; end
+  def release_write_lock; end
+  def running_readers(c = nil); end
+  def running_readers?(c = nil); end
+  def running_writer?(c = nil); end
+  def self.new(*args, &block); end
+  def waiting_writer?(c = nil); end
+  def waiting_writers(c = nil); end
+  def with_read_lock; end
+  def with_write_lock; end
+  def write_locked?; end
+end
+class Concurrent::AbstractThreadLocalVar
+  def allocate_storage; end
+  def bind(value, &block); end
+  def default; end
+  def initialize(default = nil, &default_block); end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
+  def allocate_storage; end
+  def get_default; end
+  def get_threadlocal_array(thread = nil); end
+  def next_index; end
+  def self.semi_sync(&block); end
+  def self.thread_finalizer(id); end
+  def self.thread_local_finalizer(index); end
+  def set_threadlocal_array(array, thread = nil); end
+  def value; end
+  def value=(value); end
+  def value_for(thread); end
+end
+class Concurrent::ThreadLocalVar < Concurrent::RubyThreadLocalVar
+end
+class Concurrent::ReentrantReadWriteLock < Concurrent::Synchronization::Object
+  def acquire_read_lock; end
+  def acquire_write_lock; end
+  def initialize; end
+  def max_readers?(c = nil); end
+  def max_writers?(c = nil); end
+  def release_read_lock; end
+  def release_write_lock; end
+  def running_readers(c = nil); end
+  def running_readers?(c = nil); end
+  def running_writer?(c = nil); end
+  def self.new(*args, &block); end
+  def try_read_lock; end
+  def try_write_lock; end
+  def waiting_or_running_writer?(c = nil); end
+  def waiting_writers(c = nil); end
+  def with_read_lock; end
+  def with_write_lock; end
+end
+class Concurrent::MutexSemaphore < Concurrent::Synchronization::LockableObject
+  def acquire(permits = nil); end
+  def available_permits; end
+  def drain_permits; end
+  def initialize(count); end
+  def ns_initialize(count); end
+  def reduce_permits(reduction); end
+  def release(permits = nil); end
+  def try_acquire(permits = nil, timeout = nil); end
+  def try_acquire_now(permits); end
+  def try_acquire_timed(permits, timeout); end
+end
+class Concurrent::Semaphore < Concurrent::MutexSemaphore
+end
+class Concurrent::FixedThreadPool < Concurrent::ThreadPoolExecutor
+  def initialize(num_threads, opts = nil); end
+end
+class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
+  def <<(task); end
+  def kill; end
+  def ns_initialize(*args); end
+  def post(*args, &task); end
+  def running?; end
+  def self.<<(task); end
+  def self.post(*args); end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def wait_for_termination(timeout = nil); end
+end
+class Concurrent::IndirectImmediateExecutor < Concurrent::ImmediateExecutor
+  def initialize; end
+  def post(*args, &task); end
+end
+class Concurrent::RubySingleThreadExecutor < Concurrent::RubyThreadPoolExecutor
+  def initialize(opts = nil); end
+end
+class Concurrent::SafeTaskExecutor < Concurrent::Synchronization::LockableObject
+  def execute(*args); end
+  def initialize(task, opts = nil); end
+end
+class Concurrent::SerializedExecution < Concurrent::Synchronization::LockableObject
+  def call_job(job); end
+  def initialize; end
+  def ns_initialize; end
+  def post(executor, *args, &task); end
+  def posts(posts); end
+  def work(job); end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::SerializedExecution::Job < Struct
+  def args; end
+  def args=(_); end
+  def block; end
+  def block=(_); end
+  def call; end
+  def executor; end
+  def executor=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Concurrent::SerializedExecutionDelegator < SimpleDelegator
+  def initialize(executor); end
+  def post(*args, &task); end
+  include Concurrent::SerialExecutorService
+end
+class Concurrent::SingleThreadExecutor < Concurrent::RubySingleThreadExecutor
+end
+class Concurrent::Collection::CopyOnWriteObserverSet < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def clear_observers_and_return_old; end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def initialize; end
+  def notify_and_delete_observers(*args, &block); end
+  def notify_observers(*args, &block); end
+  def notify_to(observers, *args); end
+  def ns_initialize; end
+  def observers; end
+  def observers=(new_set); end
+end
+class Concurrent::Collection::CopyOnNotifyObserverSet < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def duplicate_and_clear_observers; end
+  def duplicate_observers; end
+  def initialize; end
+  def notify_and_delete_observers(*args, &block); end
+  def notify_observers(*args, &block); end
+  def notify_to(observers, *args); end
+  def ns_initialize; end
+end
+module Concurrent::Concern::Observable
+  def add_observer(observer = nil, func = nil, &block); end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def observers; end
+  def observers=(arg0); end
+  def with_observer(observer = nil, func = nil, &block); end
+end
+class Concurrent::IVar < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def check_for_block_or_value!(block_given, value); end
+  def complete(success, value, reason); end
+  def complete_without_notification(success, value, reason); end
+  def fail(reason = nil); end
+  def initialize(value = nil, opts = nil, &block); end
+  def notify_observers(value, reason); end
+  def ns_complete_without_notification(success, value, reason); end
+  def ns_initialize(value, opts); end
+  def safe_execute(task, args = nil); end
+  def set(value = nil); end
+  def try_set(value = nil, &block); end
+  include Concurrent::Concern::Obligation
+  include Concurrent::Concern::Observable
+end
+module Concurrent::Options
+  def self.executor(executor_identifier); end
+  def self.executor_from_options(opts = nil); end
+end
+class Concurrent::ScheduledTask < Concurrent::IVar
+  def <=>(other); end
+  def cancel; end
+  def cancelled?; end
+  def execute; end
+  def executor; end
+  def fail(reason = nil); end
+  def initial_delay; end
+  def initialize(delay, opts = nil, &task); end
+  def ns_reschedule(delay); end
+  def ns_schedule(delay); end
+  def process_task; end
+  def processing?; end
+  def reschedule(delay); end
+  def reset; end
+  def schedule_time; end
+  def self.execute(delay, opts = nil, &task); end
+  def set(value = nil); end
+  def try_set(value = nil, &block); end
+  include Comparable
+end
+class Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  def <<(item); end
+  def clear; end
+  def delete(item); end
+  def deq; end
+  def empty?; end
+  def enq(item); end
+  def has_priority?(item); end
+  def include?(item); end
+  def initialize(opts = nil); end
+  def length; end
+  def ordered?(x, y); end
+  def peek; end
+  def pop; end
+  def push(item); end
+  def self.from_list(list, opts = nil); end
+  def shift; end
+  def sink(k); end
+  def size; end
+  def swap(x, y); end
+  def swim(k); end
+end
+class Concurrent::Collection::NonConcurrentPriorityQueue < Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  def <<(item); end
+  def deq; end
+  def enq(item); end
+  def has_priority?(item); end
+  def shift; end
+  def size; end
+end
+class Concurrent::TimerSet < Concurrent::RubyExecutorService
+  def <<(task); end
+  def initialize(opts = nil); end
+  def kill; end
+  def ns_initialize(opts); end
+  def ns_post_task(task); end
+  def ns_reset_if_forked; end
+  def ns_shutdown_execution; end
+  def post(delay, *args, &task); end
+  def post_task(task); end
+  def process_tasks; end
+  def remove_task(task); end
+end
+class Concurrent::AtomicMarkableReference < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
+  def compare_and_set_reference(expected, value); end
+  def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
+  def get; end
+  def immutable_array(*args); end
+  def initialize(value = nil, mark = nil); end
+  def mark; end
+  def marked?; end
+  def reference; end
+  def reference=(value); end
+  def self.new(*args, &block); end
+  def set(new_val, new_mark); end
+  def swap_reference(value); end
+  def try_update!; end
+  def try_update; end
+  def update; end
+  def update_reference(&block); end
+  def value; end
+end
+class Concurrent::Agent < Concurrent::Synchronization::LockableObject
+  def <<(action); end
+  def await; end
+  def await_for!(timeout); end
+  def await_for(timeout); end
+  def deref; end
+  def enqueue_action_job(action, args, executor); end
+  def enqueue_await_job(latch); end
+  def error; end
+  def error_mode; end
+  def execute_next_job; end
+  def failed?; end
+  def handle_error(error); end
+  def initialize(initial, opts = nil); end
+  def ns_enqueue_job(job, index = nil); end
+  def ns_find_last_job_for_thread; end
+  def ns_initialize(initial, opts); end
+  def ns_post_next_job; end
+  def ns_validate(value); end
+  def post(*args, &action); end
+  def reason; end
+  def restart(new_value, opts = nil); end
+  def self.await(*agents); end
+  def self.await_for!(timeout, *agents); end
+  def self.await_for(timeout, *agents); end
+  def send!(*args, &action); end
+  def send(*args, &action); end
+  def send_off!(*args, &action); end
+  def send_off(*args, &action); end
+  def send_via!(executor, *args, &action); end
+  def send_via(executor, *args, &action); end
+  def stopped?; end
+  def value; end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Observable
+end
+class Concurrent::Agent::Job < Struct
+  def action; end
+  def action=(_); end
+  def args; end
+  def args=(_); end
+  def caller; end
+  def caller=(_); end
+  def executor; end
+  def executor=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Concurrent::Agent::Error < StandardError
+  def initialize(message = nil); end
+end
+class Concurrent::Agent::ValidationError < Concurrent::Agent::Error
+  def initialize(message = nil); end
+end
+class Concurrent::Atom < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set(old_value, new_value); end
+  def compare_and_set_value(expected, value); end
+  def deref; end
+  def initialize(value, opts = nil); end
+  def reset(new_value); end
+  def self.new(*args, &block); end
+  def swap(*args); end
+  def swap_value(value); end
+  def update_value(&block); end
+  def valid?(new_value); end
+  def value; end
+  def value=(value); end
+  include Concurrent::Concern::Observable
+end
+module Concurrent::ThreadSafe
+end
+module Concurrent::ThreadSafe::Util
+end
+class Concurrent::Array < Array
+end
+class Concurrent::Hash < Hash
+end
+class Concurrent::Set < Set
+end
+class Concurrent::Tuple
+  def cas(i, old_value, new_value); end
+  def compare_and_set(i, old_value, new_value); end
+  def each; end
+  def get(i); end
+  def initialize(size); end
+  def set(i, value); end
+  def size; end
+  def volatile_get(i); end
+  def volatile_set(i, value); end
+  include Enumerable
+end
+module Concurrent::Async
+  def async; end
+  def await; end
+  def call; end
+  def cast; end
+  def init_synchronization; end
+  def self.included(base); end
+  def self.validate_argc(obj, method, *args); end
+end
+module Concurrent::Async::ClassMethods
+  def new(*args, &block); end
+end
+class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableObject
+  def initialize(delegate); end
+  def method_missing(method, *args, &block); end
+  def perform; end
+  def reset_if_forked; end
+  def respond_to_missing?(method, include_private = nil); end
+end
+class Concurrent::Async::AwaitDelegator
+  def initialize(delegate); end
+  def method_missing(method, *args, &block); end
+  def respond_to_missing?(method, include_private = nil); end
+end
+class Concurrent::Future < Concurrent::IVar
+  def cancel; end
+  def cancelled?; end
+  def execute; end
+  def initialize(opts = nil, &block); end
+  def ns_initialize(value, opts); end
+  def self.execute(opts = nil, &block); end
+  def set(value = nil, &block); end
+  def wait_or_cancel(timeout); end
+end
+class Concurrent::DependencyCounter
+  def initialize(count, &block); end
+  def update(time, value, reason); end
+end
+class Concurrent::Maybe < Concurrent::Synchronization::Object
+  def <=>(other); end
+  def fulfilled?; end
+  def initialize(just, nothing); end
+  def just; end
+  def just?; end
+  def nothing; end
+  def nothing?; end
+  def or(other); end
+  def reason; end
+  def rejected?; end
+  def self.from(*args); end
+  def self.just(value); end
+  def self.new(*args, &block); end
+  def self.nothing(error = nil); end
+  def value; end
+  include Comparable
+end
+class Concurrent::AbstractExchanger < Concurrent::Synchronization::Object
+  def do_exchange(value, timeout); end
+  def exchange!(value, timeout = nil); end
+  def exchange(value, timeout = nil); end
+  def initialize; end
+  def try_exchange(value, timeout = nil); end
+end
+class Concurrent::RubyExchanger < Concurrent::AbstractExchanger
+  def __initialize_atomic_fields__; end
+  def compare_and_set_slot(expected, value); end
+  def do_exchange(value, timeout); end
+  def initialize; end
+  def self.new(*args, &block); end
+  def slot; end
+  def slot=(value); end
+  def swap_slot(value); end
+  def update_slot(&block); end
+end
+class Concurrent::RubyExchanger::Node < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set_value(expected, value); end
+  def initialize(item); end
+  def item; end
+  def latch; end
+  def self.new(*args, &block); end
+  def swap_value(value); end
+  def update_value(&block); end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::Exchanger < Concurrent::RubyExchanger
+end
+module Concurrent::Synchronization::AbstractStruct
+  def initialize(*values); end
+  def length; end
+  def members; end
+  def ns_each; end
+  def ns_each_pair; end
+  def ns_equality(other); end
+  def ns_get(member); end
+  def ns_initialize_copy; end
+  def ns_inspect; end
+  def ns_merge(other, &block); end
+  def ns_select; end
+  def ns_to_h; end
+  def ns_values; end
+  def ns_values_at(indexes); end
+  def pr_underscore(clazz); end
+  def self.define_struct_class(parent, base, name, members, &block); end
+  def size; end
+end
+module Concurrent::ImmutableStruct
+  def ==(other); end
+  def [](member); end
+  def each(&block); end
+  def each_pair(&block); end
+  def initialize_copy(original); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.included(base); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+module Concurrent::MutableStruct
+  def ==(other); end
+  def [](member); end
+  def []=(member, value); end
+  def each(&block); end
+  def each_pair(&block); end
+  def initialize_copy(original); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+class Concurrent::MVar < Concurrent::Synchronization::Object
+  def borrow(timeout = nil); end
+  def empty?; end
+  def full?; end
+  def initialize(value = nil, opts = nil); end
+  def modify!; end
+  def modify(timeout = nil); end
+  def put(value, timeout = nil); end
+  def self.new(*args, &block); end
+  def set!(value); end
+  def synchronize(&block); end
+  def take(timeout = nil); end
+  def try_put!(value); end
+  def try_take!; end
+  def unlocked_empty?; end
+  def unlocked_full?; end
+  def wait_for_empty(timeout); end
+  def wait_for_full(timeout); end
+  def wait_while(condition, timeout); end
+  include Concurrent::Concern::Dereferenceable
+end
+class Concurrent::PromiseExecutionError < StandardError
+end
+class Concurrent::Promise < Concurrent::IVar
+  def catch(&block); end
+  def complete(success, value, reason); end
+  def execute; end
+  def fail(reason = nil); end
+  def flat_map(&block); end
+  def initialize(opts = nil, &block); end
+  def notify_child(child); end
+  def ns_initialize(value, opts); end
+  def on_error(&block); end
+  def on_fulfill(result); end
+  def on_reject(reason); end
+  def on_success(&block); end
+  def realize(task); end
+  def rescue(&block); end
+  def root?; end
+  def self.aggregate(method, *promises); end
+  def self.all?(*promises); end
+  def self.any?(*promises); end
+  def self.execute(opts = nil, &block); end
+  def self.fulfill(value, opts = nil); end
+  def self.reject(reason, opts = nil); end
+  def self.zip(*promises); end
+  def set(value = nil, &block); end
+  def set_pending; end
+  def set_state!(success, value, reason); end
+  def synchronized_set_state!(success, value, reason); end
+  def then(*args, &block); end
+  def zip(*others); end
+end
+module Concurrent::SettableStruct
+  def ==(other); end
+  def [](member); end
+  def []=(member, value); end
+  def each(&block); end
+  def each_pair(&block); end
+  def initialize_copy(original); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+class Concurrent::TimerTask < Concurrent::RubyExecutorService
+  def <<(task); end
+  def execute; end
+  def execute_task(completion); end
+  def execution_interval; end
+  def execution_interval=(value); end
+  def initialize(opts = nil, &task); end
+  def ns_initialize(opts, &task); end
+  def ns_kill_execution; end
+  def ns_shutdown_execution; end
+  def post(*args, &task); end
+  def running?; end
+  def schedule_next_task(interval = nil); end
+  def self.execute(opts = nil, &task); end
+  def timeout_interval; end
+  def timeout_interval=(value); end
+  def timeout_task(completion); end
+  include Concurrent::Concern::Dereferenceable
+  include Concurrent::Concern::Observable
+end
+class Concurrent::TVar < Concurrent::Synchronization::Object
+  def initialize(value); end
+  def self.new(*args, &block); end
+  def unsafe_increment_version; end
+  def unsafe_lock; end
+  def unsafe_value; end
+  def unsafe_value=(value); end
+  def unsafe_version; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::Transaction
+  def abort; end
+  def commit; end
+  def initialize; end
+  def read(tvar); end
+  def self.current; end
+  def self.current=(transaction); end
+  def unlock; end
+  def valid?; end
+  def write(tvar, value); end
+end
+class Concurrent::Transaction::ReadLogEntry < Struct
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def tvar; end
+  def tvar=(_); end
+  def version; end
+  def version=(_); end
+end
+class Concurrent::Transaction::AbortError < StandardError
+end
+class Concurrent::Transaction::LeaveError < StandardError
+end
+class Concurrent::LockFreeStack < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def clear; end
+  def clear_each(&block); end
+  def clear_if(head); end
+  def compare_and_clear(head); end
+  def compare_and_pop(head); end
+  def compare_and_push(head, value); end
+  def compare_and_set_head(expected, value); end
+  def each(head = nil); end
+  def empty?(head = nil); end
+  def head; end
+  def head=(value); end
+  def initialize(head = nil); end
+  def inspect; end
+  def peek; end
+  def pop; end
+  def push(value); end
+  def replace_if(head, new_head); end
+  def self.new(*args, &block); end
+  def self.of1(value); end
+  def self.of2(value1, value2); end
+  def swap_head(value); end
+  def to_s; end
+  def update_head(&block); end
+  include Enumerable
+end
+class Concurrent::LockFreeStack::Node
+  def initialize(value, next_node); end
+  def next_node; end
+  def self.[](*arg0); end
+  def value; end
+  def value=(arg0); end
+end
+module Concurrent::ReInclude
+  def extended(base); end
+  def include(*modules); end
+  def included(base); end
+end
+module Concurrent::Promises
+  extend Concurrent::Promises::FactoryMethods
+end
+module Concurrent::Promises::FactoryMethods
+  def any(*futures_and_or_events); end
+  def any_event(*futures_and_or_events); end
+  def any_event_on(default_executor, *futures_and_or_events); end
+  def any_fulfilled_future(*futures_and_or_events); end
+  def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
+  def any_resolved_future(*futures_and_or_events); end
+  def any_resolved_future_on(default_executor, *futures_and_or_events); end
+  def delay(*args, &task); end
+  def delay_on(default_executor, *args, &task); end
+  def fulfilled_future(value, default_executor = nil); end
+  def future(*args, &task); end
+  def future_on(default_executor, *args, &task); end
+  def make_future(argument = nil, default_executor = nil); end
+  def rejected_future(reason, default_executor = nil); end
+  def resolvable_event; end
+  def resolvable_event_on(default_executor = nil); end
+  def resolvable_future; end
+  def resolvable_future_on(default_executor = nil); end
+  def resolved_event(default_executor = nil); end
+  def resolved_future(fulfilled, value, reason, default_executor = nil); end
+  def schedule(intended_time, *args, &task); end
+  def schedule_on(default_executor, intended_time, *args, &task); end
+  def zip(*futures_and_or_events); end
+  def zip_events(*futures_and_or_events); end
+  def zip_events_on(default_executor, *futures_and_or_events); end
+  def zip_futures(*futures_and_or_events); end
+  def zip_futures_on(default_executor, *futures_and_or_events); end
+  extend Concurrent::Promises::FactoryMethods
+  extend Concurrent::Promises::FactoryMethods::Configuration
+  extend Concurrent::ReInclude
+  include Concurrent::Promises::FactoryMethods::Configuration
+end
+module Concurrent::Promises::FactoryMethods::Configuration
+  def default_executor; end
+end
+module Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::InternalStates::State
+  def resolved?; end
+  def to_sym; end
+end
+class Concurrent::Promises::InternalStates::Pending < Concurrent::Promises::InternalStates::State
+  def resolved?; end
+  def to_sym; end
+end
+class Concurrent::Promises::InternalStates::Reserved < Concurrent::Promises::InternalStates::Pending
+end
+class Concurrent::Promises::InternalStates::ResolvedWithResult < Concurrent::Promises::InternalStates::State
+  def apply; end
+  def fulfilled?; end
+  def reason; end
+  def resolved?; end
+  def result; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::Fulfilled < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(value); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::FulfilledArray < Concurrent::Promises::InternalStates::Fulfilled
+  def apply(args, block); end
+end
+class Concurrent::Promises::InternalStates::Rejected < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(reason); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::PartiallyRejected < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(value, reason); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::AbstractEventFuture < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def add_callback(method, *args); end
+  def add_callback_clear_delayed_node(node); end
+  def add_callback_notify_blocked(promise, index); end
+  def async_callback_on_resolution(state, executor, args, callback); end
+  def blocks; end
+  def call_callback(method, state, args); end
+  def call_callbacks(state); end
+  def callback_clear_delayed_node(state, node); end
+  def callback_notify_blocked(state, promise, index); end
+  def callbacks; end
+  def chain(*args, &task); end
+  def chain_on(executor, *args, &task); end
+  def chain_resolvable(resolvable); end
+  def compare_and_set_internal_state(expected, value); end
+  def default_executor; end
+  def initialize(promise, default_executor); end
+  def inspect; end
+  def internal_state; end
+  def internal_state=(value); end
+  def on_resolution!(*args, &callback); end
+  def on_resolution(*args, &callback); end
+  def on_resolution_using(executor, *args, &callback); end
+  def pending?; end
+  def promise; end
+  def resolve_with(state, raise_on_reassign = nil, reserved = nil); end
+  def resolved?; end
+  def self.new(*args, &block); end
+  def state; end
+  def swap_internal_state(value); end
+  def tangle(resolvable); end
+  def to_s; end
+  def touch; end
+  def touched?; end
+  def update_internal_state(&block); end
+  def wait(timeout = nil); end
+  def wait_until_resolved(timeout); end
+  def waiting_threads; end
+  def with_async(executor, *args, &block); end
+  def with_default_executor(executor); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::Event < Concurrent::Promises::AbstractEventFuture
+  def &(other); end
+  def any(event_or_future); end
+  def callback_on_resolution(state, args, callback); end
+  def delay; end
+  def rejected_resolution(raise_on_reassign, state); end
+  def schedule(intended_time); end
+  def then(*args, &task); end
+  def to_event; end
+  def to_future; end
+  def with_default_executor(executor); end
+  def zip(other); end
+  def |(event_or_future); end
+end
+class Concurrent::Promises::Future < Concurrent::Promises::AbstractEventFuture
+  def &(other); end
+  def any(event_or_future); end
+  def apply(args, block); end
+  def async_callback_on_fulfillment(state, executor, args, callback); end
+  def async_callback_on_rejection(state, executor, args, callback); end
+  def callback_on_fulfillment(state, args, callback); end
+  def callback_on_rejection(state, args, callback); end
+  def callback_on_resolution(state, args, callback); end
+  def delay; end
+  def exception(*args); end
+  def flat(level = nil); end
+  def flat_event; end
+  def flat_future(level = nil); end
+  def fulfilled?; end
+  def inspect; end
+  def on_fulfillment!(*args, &callback); end
+  def on_fulfillment(*args, &callback); end
+  def on_fulfillment_using(executor, *args, &callback); end
+  def on_rejection!(*args, &callback); end
+  def on_rejection(*args, &callback); end
+  def on_rejection_using(executor, *args, &callback); end
+  def reason(timeout = nil, timeout_value = nil); end
+  def rejected?; end
+  def rejected_resolution(raise_on_reassign, state); end
+  def rescue(*args, &task); end
+  def rescue_on(executor, *args, &task); end
+  def result(timeout = nil); end
+  def run(run_test = nil); end
+  def run_test(v); end
+  def schedule(intended_time); end
+  def then(*args, &task); end
+  def then_on(executor, *args, &task); end
+  def to_event; end
+  def to_future; end
+  def to_s; end
+  def value!(timeout = nil, timeout_value = nil); end
+  def value(timeout = nil, timeout_value = nil); end
+  def wait!(timeout = nil); end
+  def wait_until_resolved!(timeout = nil); end
+  def with_default_executor(executor); end
+  def zip(other); end
+  def |(event_or_future); end
+end
+module Concurrent::Promises::Resolvable
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::ResolvableEvent < Concurrent::Promises::Event
+  def resolve(raise_on_reassign = nil, reserved = nil); end
+  def wait(timeout = nil, resolve_on_timeout = nil); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::Resolvable
+end
+class Concurrent::Promises::ResolvableFuture < Concurrent::Promises::Future
+  def evaluate_to!(*args, &block); end
+  def evaluate_to(*args, &block); end
+  def fulfill(value, raise_on_reassign = nil, reserved = nil); end
+  def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def reject(reason, raise_on_reassign = nil, reserved = nil); end
+  def resolve(fulfilled = nil, value = nil, reason = nil, raise_on_reassign = nil, reserved = nil); end
+  def result(timeout = nil, resolve_on_timeout = nil); end
+  def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def wait!(timeout = nil, resolve_on_timeout = nil); end
+  def wait(timeout = nil, resolve_on_timeout = nil); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::Resolvable
+end
+class Concurrent::Promises::AbstractPromise < Concurrent::Synchronization::Object
+  def default_executor; end
+  def delayed_because; end
+  def evaluate_to(*args, block); end
+  def event; end
+  def future; end
+  def initialize(future); end
+  def inspect; end
+  def resolve_with(new_state, raise_on_reassign = nil); end
+  def self.new(*args, &block); end
+  def state; end
+  def to_s; end
+  def touch; end
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::ResolvableEventPromise < Concurrent::Promises::AbstractPromise
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::ResolvableFuturePromise < Concurrent::Promises::AbstractPromise
+  def evaluate_to(*args, block); end
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::InnerPromise < Concurrent::Promises::AbstractPromise
+end
+class Concurrent::Promises::BlockedPromise < Concurrent::Promises::InnerPromise
+  def blocked_by; end
+  def clear_and_propagate_touch(stack_or_element = nil); end
+  def delayed_because; end
+  def initialize(delayed, blockers_count, future); end
+  def on_blocker_resolution(future, index); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+  def resolvable?(countdown, future, index); end
+  def self.add_delayed(delayed1, delayed2); end
+  def self.new(*args, &block); end
+  def self.new_blocked_by(blockers, *args, &block); end
+  def self.new_blocked_by1(blocker, *args, &block); end
+  def self.new_blocked_by2(blocker1, blocker2, *args, &block); end
+  def touch; end
+end
+class Concurrent::Promises::BlockedTaskPromise < Concurrent::Promises::BlockedPromise
+  def executor; end
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+end
+class Concurrent::Promises::ThenPromise < Concurrent::Promises::BlockedTaskPromise
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::RescuePromise < Concurrent::Promises::BlockedTaskPromise
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ChainPromise < Concurrent::Promises::BlockedTaskPromise
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ImmediateEventPromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::ImmediateFuturePromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor, fulfilled, value, reason); end
+end
+class Concurrent::Promises::AbstractFlatPromise < Concurrent::Promises::BlockedPromise
+  def add_delayed_of(future); end
+  def initialize(delayed_because, blockers_count, event_or_future); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+  def touch; end
+  def touched?; end
+end
+class Concurrent::Promises::FlatEventPromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::FlatFuturePromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, levels, default_executor); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::RunFuturePromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, default_executor, run_test); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::ZipEventEventPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ZipFutureEventPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::EventWrapperPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::FutureWrapperPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ZipFuturesPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::ZipEventsPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::AbstractAnyPromise < Concurrent::Promises::BlockedPromise
+end
+class Concurrent::Promises::AnyResolvedEventPromise < Concurrent::Promises::AbstractAnyPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::AnyResolvedFuturePromise < Concurrent::Promises::AbstractAnyPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::AnyFulfilledFuturePromise < Concurrent::Promises::AnyResolvedFuturePromise
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::DelayPromise < Concurrent::Promises::InnerPromise
+  def delayed_because; end
+  def initialize(default_executor); end
+  def touch; end
+end
+class Concurrent::Promises::ScheduledPromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor, intended_time); end
+  def inspect; end
+  def intended_time; end
+end
+class Concurrent::SynchronizedDelegator < SimpleDelegator
+  def initialize(obj); end
+  def method_missing(method, *args, &block); end
+  def setup; end
+  def teardown; end
+end
diff --git a/sorbet/rbi/gems/database_cleaner.rbi b/sorbet/rbi/gems/database_cleaner.rbi
new file mode 100644
index 0000000..eeca01e
--- /dev/null
+++ b/sorbet/rbi/gems/database_cleaner.rbi
@@ -0,0 +1,95 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/database_cleaner/all/database_cleaner.rbi
+#
+# database_cleaner-1.7.0
+
+module DatabaseCleaner
+  def self.[](orm, opts = nil); end
+  def self.add_cleaner(orm, opts = nil); end
+  def self.allow_production; end
+  def self.allow_production=(arg0); end
+  def self.allow_remote_database_url; end
+  def self.allow_remote_database_url=(arg0); end
+  def self.app_root; end
+  def self.app_root=(desired_root); end
+  def self.can_detect_orm?; end
+  def self.clean!; end
+  def self.clean; end
+  def self.clean_with!(*args); end
+  def self.clean_with(*args); end
+  def self.cleaning(&inner_block); end
+  def self.connections; end
+  def self.init_cleaners; end
+  def self.logger; end
+  def self.logger=(log_source); end
+  def self.orm=(orm); end
+  def self.orm_module(symbol); end
+  def self.remove_duplicates; end
+  def self.start; end
+  def self.strategy=(stratagem); end
+end
+class DatabaseCleaner::NullStrategy
+  def self.clean; end
+  def self.cleaning(&block); end
+  def self.db=(connection); end
+  def self.start; end
+end
+class DatabaseCleaner::Safeguard
+  def run; end
+end
+class DatabaseCleaner::Safeguard::Error < Exception
+end
+class DatabaseCleaner::Safeguard::Error::RemoteDatabaseUrl < DatabaseCleaner::Safeguard::Error
+  def initialize; end
+end
+class DatabaseCleaner::Safeguard::Error::ProductionEnv < DatabaseCleaner::Safeguard::Error
+  def initialize(env); end
+end
+class DatabaseCleaner::Safeguard::RemoteDatabaseUrl
+  def given?; end
+  def remote?(url); end
+  def run; end
+  def skip?; end
+end
+class DatabaseCleaner::Safeguard::Production
+  def given?; end
+  def key; end
+  def run; end
+  def skip?; end
+end
+class DatabaseCleaner::Base
+  def <=>(other); end
+  def auto_detected?; end
+  def autodetect; end
+  def autodetect_orm; end
+  def clean!; end
+  def clean; end
+  def clean_with!(*args); end
+  def clean_with(*args); end
+  def cleaning(&block); end
+  def create_strategy(*args); end
+  def db; end
+  def db=(desired_db); end
+  def initialize(desired_orm = nil, opts = nil); end
+  def orm; end
+  def orm=(desired_orm); end
+  def orm_module; end
+  def orm_strategy(strategy); end
+  def set_default_orm_strategy; end
+  def set_strategy_db(strategy, desired_db); end
+  def start; end
+  def strategy; end
+  def strategy=(args); end
+  def strategy_db=(desired_db); end
+  include Comparable
+end
+class DatabaseCleaner::NoORMDetected < StandardError
+end
+class DatabaseCleaner::UnknownStrategySpecified < ArgumentError
+end
diff --git a/sorbet/rbi/gems/docile.rbi b/sorbet/rbi/gems/docile.rbi
new file mode 100644
index 0000000..2e77c35
--- /dev/null
+++ b/sorbet/rbi/gems/docile.rbi
@@ -0,0 +1,32 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/docile/all/docile.rbi
+#
+# docile-1.3.2
+
+module Docile
+  def dsl_eval(dsl, *args, &block); end
+  def dsl_eval_immutable(dsl, *args, &block); end
+  def dsl_eval_with_block_return(dsl, *args, &block); end
+  def self.dsl_eval(dsl, *args, &block); end
+  def self.dsl_eval_immutable(dsl, *args, &block); end
+  def self.dsl_eval_with_block_return(dsl, *args, &block); end
+  extend Docile::Execution
+end
+module Docile::Execution
+  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+end
+class Docile::FallbackContextProxy
+  def initialize(receiver, fallback); end
+  def instance_variables; end
+  def method_missing(method, *args, &block); end
+end
+class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy
+  def method_missing(method, *args, &block); end
+end
diff --git a/sorbet/rbi/gems/i18n.rbi b/sorbet/rbi/gems/i18n.rbi
new file mode 100644
index 0000000..97a21f9
--- /dev/null
+++ b/sorbet/rbi/gems/i18n.rbi
@@ -0,0 +1,133 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/i18n/all/i18n.rbi
+#
+# i18n-1.8.5
+
+module I18n
+  def self.interpolate(string, values); end
+  def self.interpolate_hash(string, values); end
+  def self.new_double_nested_cache; end
+  extend I18n::Base
+end
+class I18n::ExceptionHandler
+  def call(exception, _locale, _key, _options); end
+end
+class I18n::ArgumentError < ArgumentError
+end
+class I18n::Disabled < I18n::ArgumentError
+  def initialize(method); end
+end
+class I18n::InvalidLocale < I18n::ArgumentError
+  def initialize(locale); end
+  def locale; end
+end
+class I18n::InvalidLocaleData < I18n::ArgumentError
+  def filename; end
+  def initialize(filename, exception_message); end
+end
+class I18n::MissingTranslation < I18n::ArgumentError
+  include I18n::MissingTranslation::Base
+end
+module I18n::MissingTranslation::Base
+  def initialize(locale, key, options = nil); end
+  def key; end
+  def keys; end
+  def locale; end
+  def message; end
+  def options; end
+  def to_exception; end
+  def to_s; end
+end
+class I18n::MissingTranslationData < I18n::ArgumentError
+  include I18n::MissingTranslation::Base
+end
+class I18n::InvalidPluralizationData < I18n::ArgumentError
+  def count; end
+  def entry; end
+  def initialize(entry, count, key); end
+  def key; end
+end
+class I18n::MissingInterpolationArgument < I18n::ArgumentError
+  def initialize(key, values, string); end
+  def key; end
+  def string; end
+  def values; end
+end
+class I18n::ReservedInterpolationKey < I18n::ArgumentError
+  def initialize(key, string); end
+  def key; end
+  def string; end
+end
+class I18n::UnknownFileType < I18n::ArgumentError
+  def filename; end
+  def initialize(type, filename); end
+  def type; end
+end
+module I18n::Base
+  def available_locales; end
+  def available_locales=(value); end
+  def available_locales_initialized?; end
+  def backend; end
+  def backend=(value); end
+  def config; end
+  def config=(value); end
+  def default_locale; end
+  def default_locale=(value); end
+  def default_separator; end
+  def default_separator=(value); end
+  def eager_load!; end
+  def enforce_available_locales!(locale); end
+  def enforce_available_locales; end
+  def enforce_available_locales=(value); end
+  def exception_handler; end
+  def exception_handler=(value); end
+  def exists?(key, _locale = nil, locale: nil, **options); end
+  def handle_exception(handling, exception, locale, key, options); end
+  def l(object, locale: nil, format: nil, **options); end
+  def load_path; end
+  def load_path=(value); end
+  def locale; end
+  def locale=(value); end
+  def locale_available?(locale); end
+  def localize(object, locale: nil, format: nil, **options); end
+  def normalize_key(key, separator); end
+  def normalize_keys(locale, key, scope, separator = nil); end
+  def reload!; end
+  def t!(key, options = nil); end
+  def t(key = nil, *arg1, throw: nil, raise: nil, locale: nil, **options); end
+  def translate!(key, options = nil); end
+  def translate(key = nil, *arg1, throw: nil, raise: nil, locale: nil, **options); end
+  def transliterate(key, *arg1, throw: nil, raise: nil, locale: nil, replacement: nil, **options); end
+  def with_locale(tmp_locale = nil); end
+end
+class I18n::Config
+  def available_locales; end
+  def available_locales=(locales); end
+  def available_locales_initialized?; end
+  def available_locales_set; end
+  def backend; end
+  def backend=(backend); end
+  def clear_available_locales_set; end
+  def default_locale; end
+  def default_locale=(locale); end
+  def default_separator; end
+  def default_separator=(separator); end
+  def enforce_available_locales; end
+  def enforce_available_locales=(enforce_available_locales); end
+  def exception_handler; end
+  def exception_handler=(exception_handler); end
+  def interpolation_patterns; end
+  def interpolation_patterns=(interpolation_patterns); end
+  def load_path; end
+  def load_path=(load_path); end
+  def locale; end
+  def locale=(locale); end
+  def missing_interpolation_argument_handler; end
+  def missing_interpolation_argument_handler=(exception_handler); end
+end
diff --git a/sorbet/rbi/gems/method_source.rbi b/sorbet/rbi/gems/method_source.rbi
new file mode 100644
index 0000000..92cdecd
--- /dev/null
+++ b/sorbet/rbi/gems/method_source.rbi
@@ -0,0 +1,64 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/method_source/all/method_source.rbi
+#
+# method_source-1.0.0
+
+module MethodSource
+  def self.comment_helper(source_location, name = nil); end
+  def self.extract_code(source_location); end
+  def self.lines_for(file_name, name = nil); end
+  def self.source_helper(source_location, name = nil); end
+  def self.valid_expression?(str); end
+  extend MethodSource::CodeHelpers
+end
+module MethodSource::ReeSourceLocation
+  def source_location; end
+end
+module MethodSource::SourceLocation
+end
+module MethodSource::SourceLocation::MethodExtensions
+  def source_location; end
+  def trace_func(event, file, line, id, binding, classname); end
+end
+module MethodSource::SourceLocation::ProcExtensions
+  def source_location; end
+end
+module MethodSource::SourceLocation::UnboundMethodExtensions
+  def source_location; end
+end
+module MethodSource::CodeHelpers
+  def comment_describing(file, line_number); end
+  def complete_expression?(str); end
+  def expression_at(file, line_number, options = nil); end
+  def extract_first_expression(lines, consume = nil, &block); end
+  def extract_last_comment(lines); end
+end
+module MethodSource::CodeHelpers::IncompleteExpression
+  def self.===(ex); end
+  def self.rbx?; end
+end
+class MethodSource::SourceNotFoundError < StandardError
+end
+module MethodSource::MethodExtensions
+  def comment; end
+  def self.included(klass); end
+  def source; end
+end
+class Method
+  include MethodSource::MethodExtensions
+  include MethodSource::SourceLocation::MethodExtensions
+end
+class UnboundMethod
+  include MethodSource::MethodExtensions
+  include MethodSource::SourceLocation::UnboundMethodExtensions
+end
+class Proc
+  include MethodSource::MethodExtensions
+  include MethodSource::SourceLocation::ProcExtensions
+end
diff --git a/sorbet/rbi/gems/pastel.rbi b/sorbet/rbi/gems/pastel.rbi
new file mode 100644
index 0000000..1cf5bb8
--- /dev/null
+++ b/sorbet/rbi/gems/pastel.rbi
@@ -0,0 +1,119 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pastel/all/pastel.rbi
+#
+# pastel-0.8.0
+
+module Pastel
+  def new(enabled: nil, eachline: nil); end
+  def self.new(enabled: nil, eachline: nil); end
+end
+class Pastel::AliasImporter
+  def color; end
+  def env; end
+  def import; end
+  def initialize(color, env, output = nil); end
+  def output; end
+end
+module Pastel::ANSI
+  def background?(code); end
+  def foreground?(code); end
+  def self.background?(code); end
+  def self.foreground?(code); end
+  def self.style?(code); end
+  def style?(code); end
+end
+class Pastel::Color
+  def ==(other); end
+  def alias_color(alias_name, *colors); end
+  def apply_codes(string, ansi_colors); end
+  def blank?(value); end
+  def clear; end
+  def code(*colors); end
+  def colored?(string); end
+  def decorate(string, *colors); end
+  def disable!; end
+  def eachline; end
+  def enabled; end
+  def enabled?; end
+  def eql?(other); end
+  def hash; end
+  def initialize(enabled: nil, eachline: nil); end
+  def inspect; end
+  def lookup(*colors); end
+  def strip(*strings); end
+  def style_names; end
+  def styles; end
+  def valid?(*colors); end
+  def validate(*colors); end
+  include Pastel::ANSI
+end
+class Pastel::Detached
+  def ==(other); end
+  def [](*args); end
+  def call(*args); end
+  def eql?(other); end
+  def hash; end
+  def initialize(color, *styles); end
+  def inspect; end
+  def styles; end
+  def to_proc; end
+end
+class Pastel::ColorResolver
+  def color; end
+  def initialize(color); end
+  def resolve(base, unprocessed_string); end
+end
+class Pastel::ColorParser
+  def self.attribute_name(ansi); end
+  def self.color_name(ansi_code); end
+  def self.parse(text); end
+  def self.unpack_ansi(ansi_stack); end
+  include Pastel::ANSI
+end
+class Pastel::DecoratorChain
+  def ==(other); end
+  def add(decorator); end
+  def decorators; end
+  def each(&block); end
+  def eql?(other); end
+  def hash; end
+  def initialize(decorators = nil); end
+  def inspect; end
+  def self.empty; end
+  include Enumerable
+end
+class Pastel::Delegator
+  def ==(other); end
+  def alias_color(*args, &block); end
+  def chain; end
+  def colored?(*args, &block); end
+  def decorate(*args, &block); end
+  def enabled?(*args, &block); end
+  def eql?(other); end
+  def evaluate_block(&block); end
+  def hash; end
+  def initialize(resolver, chain); end
+  def inspect; end
+  def lookup(*args, &block); end
+  def method_missing(method_name, *args, &block); end
+  def parse(*args, &block); end
+  def resolver; end
+  def respond_to_missing?(name, include_all = nil); end
+  def self.wrap(resolver, chain = nil); end
+  def strip(*args, &block); end
+  def styles(*args, &block); end
+  def to_s; end
+  def undecorate(*args, &block); end
+  def valid?(*args, &block); end
+  extend Forwardable
+end
+class Pastel::InvalidAttributeNameError < ArgumentError
+end
+class Pastel::InvalidAliasNameError < ArgumentError
+end
diff --git a/sorbet/rbi/gems/pry.rbi b/sorbet/rbi/gems/pry.rbi
new file mode 100644
index 0000000..2e1aa6f
--- /dev/null
+++ b/sorbet/rbi/gems/pry.rbi
@@ -0,0 +1,1949 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry/all/pry.rbi
+#
+# pry-0.13.1
+
+class Pry
+  def add_sticky_local(name, &block); end
+  def backtrace; end
+  def backtrace=(arg0); end
+  def binding_stack; end
+  def binding_stack=(arg0); end
+  def color(*args, &block); end
+  def color=(*args, &block); end
+  def commands(*args, &block); end
+  def commands=(*args, &block); end
+  def complete(str); end
+  def config; end
+  def current_binding; end
+  def current_context; end
+  def custom_completions; end
+  def custom_completions=(arg0); end
+  def editor(*args, &block); end
+  def editor=(*args, &block); end
+  def ensure_correct_encoding!(val); end
+  def eval(line, options = nil); end
+  def eval_string; end
+  def eval_string=(arg0); end
+  def evaluate_ruby(code); end
+  def exception_handler(*args, &block); end
+  def exception_handler=(*args, &block); end
+  def exec_hook(name, *args, &block); end
+  def exit_value; end
+  def extra_sticky_locals(*args, &block); end
+  def extra_sticky_locals=(*args, &block); end
+  def generate_prompt(prompt_proc, conf); end
+  def handle_line(line, options); end
+  def hooks(*args, &block); end
+  def hooks=(*args, &block); end
+  def initialize(options = nil); end
+  def inject_local(name, value, binding); end
+  def inject_sticky_locals!; end
+  def input(*args, &block); end
+  def input=(*args, &block); end
+  def input_ring; end
+  def last_dir; end
+  def last_dir=(arg0); end
+  def last_exception; end
+  def last_exception=(exception); end
+  def last_file; end
+  def last_file=(arg0); end
+  def last_result; end
+  def last_result=(arg0); end
+  def last_result_is_exception?; end
+  def memory_size; end
+  def memory_size=(size); end
+  def output; end
+  def output=(*args, &block); end
+  def output_ring; end
+  def pager; end
+  def pager=(*args, &block); end
+  def pop_prompt; end
+  def print(*args, &block); end
+  def print=(*args, &block); end
+  def process_command(val); end
+  def process_command_safely(val); end
+  def prompt; end
+  def prompt=(new_prompt); end
+  def prompt_stack; end
+  def push_binding(object); end
+  def push_initial_binding(target = nil); end
+  def push_prompt(new_prompt); end
+  def quiet?; end
+  def raise_up!(*args); end
+  def raise_up(*args); end
+  def raise_up_common(force, *args); end
+  def repl(target = nil); end
+  def reset_eval_string; end
+  def run_command(val); end
+  def select_prompt; end
+  def self.Code(obj); end
+  def self.Method(obj); end
+  def self.WrappedModule(obj); end
+  def self.auto_resize!; end
+  def self.binding_for(target); end
+  def self.cli; end
+  def self.cli=(arg0); end
+  def self.color(*args, &block); end
+  def self.color=(*args, &block); end
+  def self.commands(*args, &block); end
+  def self.commands=(*args, &block); end
+  def self.config; end
+  def self.config=(arg0); end
+  def self.configure; end
+  def self.critical_section; end
+  def self.current; end
+  def self.current_line; end
+  def self.current_line=(arg0); end
+  def self.custom_completions; end
+  def self.custom_completions=(arg0); end
+  def self.editor(*args, &block); end
+  def self.editor=(*args, &block); end
+  def self.eval_path; end
+  def self.eval_path=(arg0); end
+  def self.exception_handler(*args, &block); end
+  def self.exception_handler=(*args, &block); end
+  def self.extra_sticky_locals(*args, &block); end
+  def self.extra_sticky_locals=(*args, &block); end
+  def self.final_session_setup; end
+  def self.history(*args, &block); end
+  def self.history=(*args, &block); end
+  def self.hooks(*args, &block); end
+  def self.hooks=(*args, &block); end
+  def self.in_critical_section?; end
+  def self.init; end
+  def self.initial_session?; end
+  def self.initial_session_setup; end
+  def self.input(*args, &block); end
+  def self.input=(*args, &block); end
+  def self.last_internal_error; end
+  def self.last_internal_error=(arg0); end
+  def self.line_buffer; end
+  def self.line_buffer=(arg0); end
+  def self.load_file_at_toplevel(file); end
+  def self.load_file_through_repl(file_name); end
+  def self.load_history; end
+  def self.load_plugins(*args, &block); end
+  def self.load_rc_files; end
+  def self.load_requires; end
+  def self.load_traps; end
+  def self.load_win32console; end
+  def self.locate_plugins(*args, &block); end
+  def self.main; end
+  def self.memory_size(*args, &block); end
+  def self.memory_size=(*args, &block); end
+  def self.output(*args, &block); end
+  def self.output=(*args, &block); end
+  def self.pager(*args, &block); end
+  def self.pager=(*args, &block); end
+  def self.plugins(*args, &block); end
+  def self.print(*args, &block); end
+  def self.print=(*args, &block); end
+  def self.prompt(*args, &block); end
+  def self.prompt=(*args, &block); end
+  def self.quiet; end
+  def self.quiet=(arg0); end
+  def self.rc_files_to_load; end
+  def self.real_path_to(file); end
+  def self.reset_defaults; end
+  def self.run_command(command_string, options = nil); end
+  def self.start(target = nil, options = nil); end
+  def self.toplevel_binding; end
+  def self.toplevel_binding=(arg0); end
+  def self.view_clip(obj, options = nil); end
+  def set_last_result(result, code = nil); end
+  def should_print?; end
+  def show_result(result); end
+  def sticky_locals; end
+  def suppress_output; end
+  def suppress_output=(arg0); end
+  def update_input_history(code); end
+  extend Pry::Forwardable
+end
+class Pry::LastException < BasicObject
+  def bt_index; end
+  def bt_index=(arg0); end
+  def bt_source_location_for(index); end
+  def file; end
+  def inc_bt_index; end
+  def initialize(exception); end
+  def line; end
+  def method_missing(name, *args, &block); end
+  def respond_to_missing?(name, include_all = nil); end
+  def wrapped_exception; end
+end
+module Pry::Forwardable
+  def def_private_delegators(target, *private_delegates); end
+  include Forwardable
+end
+module Pry::Helpers
+  def self.tablify(things, line_length, pry_instance = nil); end
+  def self.tablify_or_one_line(heading, things, pry_instance = nil); end
+  def self.tablify_to_screen_width(things, options, pry_instance = nil); end
+end
+module Pry::Helpers::BaseHelpers
+  def colorize_code(code); end
+  def find_command(name, set = nil); end
+  def heading(text); end
+  def highlight(string, regexp, highlight_color = nil); end
+  def not_a_real_file?(file); end
+  def safe_send(obj, method, *args, &block); end
+  def silence_warnings; end
+  def stagger_output(text, _out = nil); end
+  def use_ansi_codes?; end
+  extend Pry::Helpers::BaseHelpers
+end
+module Pry::Helpers::DocumentationHelpers
+  def get_comment_content(comment); end
+  def process_comment_markup(comment); end
+  def process_rdoc(comment); end
+  def process_yardoc(comment); end
+  def process_yardoc_tag(comment, tag); end
+  def self.get_comment_content(comment); end
+  def self.process_comment_markup(comment); end
+  def self.process_rdoc(comment); end
+  def self.process_yardoc(comment); end
+  def self.process_yardoc_tag(comment, tag); end
+  def self.strip_comments_from_c_code(code); end
+  def self.strip_leading_whitespace(text); end
+  def strip_comments_from_c_code(code); end
+  def strip_leading_whitespace(text); end
+end
+module Pry::Helpers::OptionsHelpers
+  def method_object; end
+  def method_options(opt); end
+  def self.method_object; end
+  def self.method_options(opt); end
+end
+module Pry::Helpers::CommandHelpers
+  def absolute_index_number(line_number, array_length); end
+  def absolute_index_range(range_or_number, array_length); end
+  def get_method_or_raise(method_name, context, opts = nil); end
+  def internal_binding?(context); end
+  def one_index_number(line_number); end
+  def one_index_range(range); end
+  def one_index_range_or_number(range_or_number); end
+  def restrict_to_lines(content, lines); end
+  def set_file_and_dir_locals(file_name, pry = nil, ctx = nil); end
+  def temp_file(ext = nil); end
+  def unindent(dirty_text, left_padding = nil); end
+  extend Pry::Helpers::CommandHelpers
+  include Pry::Helpers::OptionsHelpers
+end
+module Pry::Helpers::Text
+  def black(text); end
+  def black_on_black(text); end
+  def black_on_blue(text); end
+  def black_on_cyan(text); end
+  def black_on_green(text); end
+  def black_on_magenta(text); end
+  def black_on_purple(text); end
+  def black_on_red(text); end
+  def black_on_white(text); end
+  def black_on_yellow(text); end
+  def blue(text); end
+  def blue_on_black(text); end
+  def blue_on_blue(text); end
+  def blue_on_cyan(text); end
+  def blue_on_green(text); end
+  def blue_on_magenta(text); end
+  def blue_on_purple(text); end
+  def blue_on_red(text); end
+  def blue_on_white(text); end
+  def blue_on_yellow(text); end
+  def bold(text); end
+  def bright_black(text); end
+  def bright_black_on_black(text); end
+  def bright_black_on_blue(text); end
+  def bright_black_on_cyan(text); end
+  def bright_black_on_green(text); end
+  def bright_black_on_magenta(text); end
+  def bright_black_on_purple(text); end
+  def bright_black_on_red(text); end
+  def bright_black_on_white(text); end
+  def bright_black_on_yellow(text); end
+  def bright_blue(text); end
+  def bright_blue_on_black(text); end
+  def bright_blue_on_blue(text); end
+  def bright_blue_on_cyan(text); end
+  def bright_blue_on_green(text); end
+  def bright_blue_on_magenta(text); end
+  def bright_blue_on_purple(text); end
+  def bright_blue_on_red(text); end
+  def bright_blue_on_white(text); end
+  def bright_blue_on_yellow(text); end
+  def bright_cyan(text); end
+  def bright_cyan_on_black(text); end
+  def bright_cyan_on_blue(text); end
+  def bright_cyan_on_cyan(text); end
+  def bright_cyan_on_green(text); end
+  def bright_cyan_on_magenta(text); end
+  def bright_cyan_on_purple(text); end
+  def bright_cyan_on_red(text); end
+  def bright_cyan_on_white(text); end
+  def bright_cyan_on_yellow(text); end
+  def bright_green(text); end
+  def bright_green_on_black(text); end
+  def bright_green_on_blue(text); end
+  def bright_green_on_cyan(text); end
+  def bright_green_on_green(text); end
+  def bright_green_on_magenta(text); end
+  def bright_green_on_purple(text); end
+  def bright_green_on_red(text); end
+  def bright_green_on_white(text); end
+  def bright_green_on_yellow(text); end
+  def bright_magenta(text); end
+  def bright_magenta_on_black(text); end
+  def bright_magenta_on_blue(text); end
+  def bright_magenta_on_cyan(text); end
+  def bright_magenta_on_green(text); end
+  def bright_magenta_on_magenta(text); end
+  def bright_magenta_on_purple(text); end
+  def bright_magenta_on_red(text); end
+  def bright_magenta_on_white(text); end
+  def bright_magenta_on_yellow(text); end
+  def bright_purple(text); end
+  def bright_purple_on_black(text); end
+  def bright_purple_on_blue(text); end
+  def bright_purple_on_cyan(text); end
+  def bright_purple_on_green(text); end
+  def bright_purple_on_magenta(text); end
+  def bright_purple_on_purple(text); end
+  def bright_purple_on_red(text); end
+  def bright_purple_on_white(text); end
+  def bright_purple_on_yellow(text); end
+  def bright_red(text); end
+  def bright_red_on_black(text); end
+  def bright_red_on_blue(text); end
+  def bright_red_on_cyan(text); end
+  def bright_red_on_green(text); end
+  def bright_red_on_magenta(text); end
+  def bright_red_on_purple(text); end
+  def bright_red_on_red(text); end
+  def bright_red_on_white(text); end
+  def bright_red_on_yellow(text); end
+  def bright_white(text); end
+  def bright_white_on_black(text); end
+  def bright_white_on_blue(text); end
+  def bright_white_on_cyan(text); end
+  def bright_white_on_green(text); end
+  def bright_white_on_magenta(text); end
+  def bright_white_on_purple(text); end
+  def bright_white_on_red(text); end
+  def bright_white_on_white(text); end
+  def bright_white_on_yellow(text); end
+  def bright_yellow(text); end
+  def bright_yellow_on_black(text); end
+  def bright_yellow_on_blue(text); end
+  def bright_yellow_on_cyan(text); end
+  def bright_yellow_on_green(text); end
+  def bright_yellow_on_magenta(text); end
+  def bright_yellow_on_purple(text); end
+  def bright_yellow_on_red(text); end
+  def bright_yellow_on_white(text); end
+  def bright_yellow_on_yellow(text); end
+  def cyan(text); end
+  def cyan_on_black(text); end
+  def cyan_on_blue(text); end
+  def cyan_on_cyan(text); end
+  def cyan_on_green(text); end
+  def cyan_on_magenta(text); end
+  def cyan_on_purple(text); end
+  def cyan_on_red(text); end
+  def cyan_on_white(text); end
+  def cyan_on_yellow(text); end
+  def default(text); end
+  def green(text); end
+  def green_on_black(text); end
+  def green_on_blue(text); end
+  def green_on_cyan(text); end
+  def green_on_green(text); end
+  def green_on_magenta(text); end
+  def green_on_purple(text); end
+  def green_on_red(text); end
+  def green_on_white(text); end
+  def green_on_yellow(text); end
+  def indent(text, chars); end
+  def magenta(text); end
+  def magenta_on_black(text); end
+  def magenta_on_blue(text); end
+  def magenta_on_cyan(text); end
+  def magenta_on_green(text); end
+  def magenta_on_magenta(text); end
+  def magenta_on_purple(text); end
+  def magenta_on_red(text); end
+  def magenta_on_white(text); end
+  def magenta_on_yellow(text); end
+  def no_color; end
+  def no_pager; end
+  def purple(text); end
+  def purple_on_black(text); end
+  def purple_on_blue(text); end
+  def purple_on_cyan(text); end
+  def purple_on_green(text); end
+  def purple_on_magenta(text); end
+  def purple_on_purple(text); end
+  def purple_on_red(text); end
+  def purple_on_white(text); end
+  def purple_on_yellow(text); end
+  def red(text); end
+  def red_on_black(text); end
+  def red_on_blue(text); end
+  def red_on_cyan(text); end
+  def red_on_green(text); end
+  def red_on_magenta(text); end
+  def red_on_purple(text); end
+  def red_on_red(text); end
+  def red_on_white(text); end
+  def red_on_yellow(text); end
+  def strip_color(text); end
+  def white(text); end
+  def white_on_black(text); end
+  def white_on_blue(text); end
+  def white_on_cyan(text); end
+  def white_on_green(text); end
+  def white_on_magenta(text); end
+  def white_on_purple(text); end
+  def white_on_red(text); end
+  def white_on_white(text); end
+  def white_on_yellow(text); end
+  def with_line_numbers(text, offset, color = nil); end
+  def yellow(text); end
+  def yellow_on_black(text); end
+  def yellow_on_blue(text); end
+  def yellow_on_cyan(text); end
+  def yellow_on_green(text); end
+  def yellow_on_magenta(text); end
+  def yellow_on_purple(text); end
+  def yellow_on_red(text); end
+  def yellow_on_white(text); end
+  def yellow_on_yellow(text); end
+  extend Pry::Helpers::Text
+end
+class Pry::Helpers::Table
+  def ==(other); end
+  def _max_width(things); end
+  def _rebuild_colorless_cache; end
+  def _recall_color_for(thing); end
+  def _recolumn; end
+  def column_count; end
+  def column_count=(count); end
+  def columns; end
+  def fits_on_line?(line_length); end
+  def initialize(items, args, pry_instance = nil); end
+  def items; end
+  def items=(items); end
+  def rows_to_s(style = nil); end
+  def to_a; end
+  def to_s; end
+end
+module Pry::Helpers::Platform
+  def self.jruby?; end
+  def self.jruby_19?; end
+  def self.linux?; end
+  def self.mac_osx?; end
+  def self.mri?; end
+  def self.mri_19?; end
+  def self.mri_2?; end
+  def self.windows?; end
+  def self.windows_ansi?; end
+end
+class Pry::BasicObject < BasicObject
+  include Kernel
+end
+class Pry::Prompt
+  def [](key); end
+  def description; end
+  def incomplete_proc; end
+  def initialize(name, description, prompt_procs); end
+  def name; end
+  def prompt_procs; end
+  def self.[](name); end
+  def self.add(name, description = nil, separators = nil); end
+  def self.all; end
+  def wait_proc; end
+end
+class Pry::PluginManager
+  def gem_list; end
+  def initialize; end
+  def load_plugins; end
+  def locate_plugins; end
+  def plugin_located?(plugin); end
+  def plugins; end
+end
+class Pry::PluginManager::NoPlugin
+  def initialize(name); end
+  def method_missing(*arg0); end
+  def respond_to_missing?(*arg0); end
+end
+class Pry::PluginManager::Plugin
+  def activate!; end
+  def active; end
+  def active=(arg0); end
+  def active?; end
+  def disable!; end
+  def enable!; end
+  def enabled; end
+  def enabled=(arg0); end
+  def enabled?; end
+  def gem_name; end
+  def gem_name=(arg0); end
+  def initialize(name, gem_name, spec, enabled); end
+  def load_cli_options; end
+  def name; end
+  def name=(arg0); end
+  def spec; end
+  def spec=(arg0); end
+  def supported?; end
+end
+class Pry::CodeObject
+  def command_lookup; end
+  def default_lookup; end
+  def empty_lookup; end
+  def initialize(str, pry_instance, options = nil); end
+  def looks_like_an_instance_method?(str); end
+  def lookup_super(obj, super_level); end
+  def method_or_class_lookup; end
+  def pry_instance; end
+  def pry_instance=(arg0); end
+  def safe_to_evaluate?(str); end
+  def self.lookup(str, pry_instance, options = nil); end
+  def sourcable_object?(obj); end
+  def str; end
+  def str=(arg0); end
+  def super_level; end
+  def super_level=(arg0); end
+  def target; end
+  def target=(arg0); end
+  def target_self; end
+  include Pry::Helpers::CommandHelpers
+end
+module Pry::CodeObject::Helpers
+  def c_method?; end
+  def c_module?; end
+  def command?; end
+  def module_with_yard_docs?; end
+  def real_method_object?; end
+end
+module Pry::RescuableException
+  def self.===(exception); end
+end
+module Pry::TooSafeException
+  def self.===(exception); end
+end
+module Pry::UserError
+end
+module Pry::FrozenObjectException
+  def self.===(exception); end
+end
+class Pry::CommandError < StandardError
+end
+class Pry::MethodNotFound < Pry::CommandError
+end
+class Pry::ObsoleteError < StandardError
+end
+class Pry::Hooks
+  def add_hook(event_name, hook_name, callable = nil, &block); end
+  def clear_event_hooks(event_name); end
+  def delete_hook(event_name, hook_name); end
+  def errors; end
+  def exec_hook(event_name, *args, &block); end
+  def get_hook(event_name, hook_name); end
+  def get_hooks(event_name); end
+  def hook_count(event_name); end
+  def hook_exists?(event_name, hook_name); end
+  def hooks; end
+  def initialize; end
+  def initialize_copy(_orig); end
+  def merge!(other); end
+  def merge(other); end
+  def self.default; end
+end
+class Pry::InputCompleter
+  def build_path(input); end
+  def call(str, options = nil); end
+  def ignored_modules; end
+  def initialize(input, pry = nil); end
+  def select_message(path, receiver, message, candidates); end
+end
+class Pry::Command
+  def _pry_; end
+  def _pry_=(arg0); end
+  def after_hooks; end
+  def arg_string; end
+  def arg_string=(arg0); end
+  def before_hooks; end
+  def block; end
+  def call_safely(*args); end
+  def call_with_hooks(*args); end
+  def captures; end
+  def captures=(arg0); end
+  def check_for_command_collision(command_match, arg_string); end
+  def command_block; end
+  def command_block=(arg0); end
+  def command_name; end
+  def command_options; end
+  def command_set; end
+  def command_set=(arg0); end
+  def commands; end
+  def complete(_search); end
+  def context; end
+  def context=(arg0); end
+  def description; end
+  def eval_string; end
+  def eval_string=(arg0); end
+  def find_hooks(event); end
+  def hooks; end
+  def hooks=(arg0); end
+  def initialize(context = nil); end
+  def interpolate_string(str); end
+  def match; end
+  def name; end
+  def normalize_method_args(method, args); end
+  def output; end
+  def output=(arg0); end
+  def pass_block(arg_string); end
+  def process_line(line); end
+  def pry_instance; end
+  def pry_instance=(arg0); end
+  def run(command_string, *args); end
+  def self.banner(arg = nil); end
+  def self.block; end
+  def self.block=(arg0); end
+  def self.command_name; end
+  def self.command_options(arg = nil); end
+  def self.command_options=(arg0); end
+  def self.command_regex; end
+  def self.convert_to_regex(obj); end
+  def self.default_options(match); end
+  def self.description(arg = nil); end
+  def self.description=(arg0); end
+  def self.doc; end
+  def self.file; end
+  def self.group(name = nil); end
+  def self.inspect; end
+  def self.line; end
+  def self.match(arg = nil); end
+  def self.match=(arg0); end
+  def self.match_score(val); end
+  def self.matches?(val); end
+  def self.name; end
+  def self.options(arg = nil); end
+  def self.options=(arg0); end
+  def self.source; end
+  def self.source_file; end
+  def self.source_line; end
+  def self.state; end
+  def self.subclass(match, description, options, helpers, &block); end
+  def source; end
+  def state; end
+  def target; end
+  def target=(arg0); end
+  def target_self; end
+  def tokenize(val); end
+  def use_unpatched_symbol; end
+  def void; end
+  extend Pry::CodeObject::Helpers
+  extend Pry::Helpers::DocumentationHelpers
+  include Pry::Helpers::BaseHelpers
+  include Pry::Helpers::CommandHelpers
+  include Pry::Helpers::Text
+end
+class Pry::ClassCommand < Pry::Command
+  def args; end
+  def args=(arg0); end
+  def call(*args); end
+  def complete(search); end
+  def help; end
+  def options(opt); end
+  def opts; end
+  def opts=(arg0); end
+  def process; end
+  def self.doc; end
+  def self.file; end
+  def self.inherited(klass); end
+  def self.line; end
+  def self.source; end
+  def self.source_file; end
+  def self.source_line; end
+  def self.source_location; end
+  def self.source_object; end
+  def setup; end
+  def slop; end
+  def subcommands(cmd); end
+end
+class Pry::BlockCommand < Pry::Command
+  def call(*args); end
+  def help; end
+end
+class Pry::NoCommandError < StandardError
+  def initialize(match, owner); end
+end
+class Pry::CommandSet
+  def [](pattern); end
+  def []=(pattern, command); end
+  def add_command(command); end
+  def alias_command(match, action, options = nil); end
+  def block_command(match, description = nil, options = nil, &block); end
+  def command(match, description = nil, options = nil, &block); end
+  def complete(search, context = nil); end
+  def create_command(match, description = nil, options = nil, &block); end
+  def delete(*searches); end
+  def desc(search, description = nil); end
+  def each(&block); end
+  def find_command(pattern); end
+  def find_command_by_match_or_listing(match_or_listing); end
+  def find_command_for_help(search); end
+  def helper_module; end
+  def helpers(&block); end
+  def import(*sets); end
+  def import_from(set, *matches); end
+  def initialize(*imported_sets, &block); end
+  def keys; end
+  def list_commands; end
+  def process_line(val, context = nil); end
+  def rename_command(new_match, search, options = nil); end
+  def to_h; end
+  def to_hash; end
+  def valid_command?(val); end
+  include Enumerable
+  include Pry::Helpers::BaseHelpers
+end
+class Pry::Result
+  def command?; end
+  def initialize(is_command, retval = nil); end
+  def retval; end
+  def void_command?; end
+end
+class Pry::SyntaxHighlighter
+  def self.highlight(code, language = nil); end
+  def self.keyword_token_color; end
+  def self.overwrite_coderay_comment_token!; end
+  def self.tokenize(code, language = nil); end
+end
+class Pry::Editor
+  def blocking_flag_for_editor(blocking); end
+  def build_editor_invocation_string(file, line, blocking); end
+  def edit_tempfile_with_content(initial_content, line = nil); end
+  def editor_name; end
+  def initialize(pry_instance); end
+  def invoke_editor(file, line, blocking = nil); end
+  def open_editor(editor_invocation); end
+  def open_editor_on_jruby(editor_invocation); end
+  def pry_instance; end
+  def self.default; end
+  def start_line_syntax_for_editor(file_name, line_number); end
+  include Pry::Helpers::CommandHelpers
+end
+class Pry::History
+  def <<(line); end
+  def clear; end
+  def filter(history); end
+  def history_file; end
+  def history_file_path; end
+  def history_line_count; end
+  def initialize(options = nil); end
+  def invalid_readline_line?(line); end
+  def load; end
+  def loader; end
+  def loader=(arg0); end
+  def original_lines; end
+  def push(line); end
+  def read_from_file; end
+  def save_to_file(line); end
+  def saver; end
+  def saver=(arg0); end
+  def self.default_file; end
+  def session_line_count; end
+  def should_ignore?(line); end
+  def to_a; end
+end
+class Pry::ColorPrinter < PP
+  def highlight_object_literal(object_literal); end
+  def inspect_object(object); end
+  def pp(object); end
+  def self.default(_output, value, pry_instance); end
+  def self.pp(obj, output = nil, max_width = nil); end
+  def text(str, max_width = nil); end
+end
+module Pry::ExceptionHandler
+  def self.cause_text(cause); end
+  def self.exception_text(exception); end
+  def self.handle_exception(output, exception, _pry_instance); end
+  def self.standard_error_text_for(exception); end
+end
+module Pry::SystemCommandHandler
+  def self.default(output, command, _pry_instance); end
+end
+module Pry::ControlDHandler
+  def self.default(pry_instance); end
+end
+class Pry::CommandState
+  def initialize; end
+  def reset(command_name); end
+  def self.default; end
+  def state_for(command_name); end
+end
+module Pry::Warning
+  def self.warn(message); end
+end
+module Pry::Env
+  def self.[](key); end
+end
+class Pry::Command::Ls < Pry::ClassCommand
+  def error_list; end
+  def no_user_opts?; end
+  def options(opt); end
+  def process; end
+  def raise_errors_if_arguments_are_weird; end
+end
+module Pry::Command::Ls::JRubyHacks
+  def rubbishness(name); end
+  def trim_jruby_aliases(methods); end
+end
+module Pry::Command::Ls::MethodsHelper
+  def all_methods(instance_methods = nil); end
+  def format(methods); end
+  def resolution_order; end
+  include Pry::Command::Ls::JRubyHacks
+end
+module Pry::Command::Ls::Interrogatable
+  def interrogatee_mod; end
+  def interrogating_a_module?; end
+end
+class Pry::Command::Ls::Grep
+  def initialize(grep_regexp); end
+  def regexp; end
+end
+class Pry::Command::Ls::Formatter
+  def color(type, str); end
+  def correct_opts?; end
+  def format_value(value); end
+  def grep; end
+  def grep=(arg0); end
+  def initialize(pry_instance); end
+  def output_section(heading, body); end
+  def output_self; end
+  def pry_instance; end
+  def write_out; end
+end
+class Pry::Command::Ls::Globals < Pry::Command::Ls::Formatter
+  def format(globals); end
+  def initialize(opts, pry_instance); end
+  def output_self; end
+end
+class Pry::Command::Ls::Constants < Pry::Command::Ls::Formatter
+  def correct_opts?; end
+  def format(mod, constants); end
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+  def output_self; end
+  def show_deprecated_constants?; end
+  include Pry::Command::Ls::Interrogatable
+end
+class Pry::Command::Ls::Methods < Pry::Command::Ls::Formatter
+  def below_ceiling; end
+  def correct_opts?; end
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+  def output_self; end
+  include Pry::Command::Ls::Interrogatable
+  include Pry::Command::Ls::MethodsHelper
+end
+class Pry::Command::Ls::SelfMethods < Pry::Command::Ls::Formatter
+  def correct_opts?; end
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+  def output_self; end
+  include Pry::Command::Ls::Interrogatable
+  include Pry::Command::Ls::MethodsHelper
+end
+class Pry::Command::Ls::InstanceVars < Pry::Command::Ls::Formatter
+  def correct_opts?; end
+  def format(type, vars); end
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+  def output_self; end
+  include Pry::Command::Ls::Interrogatable
+end
+class Pry::Command::Ls::LocalNames < Pry::Command::Ls::Formatter
+  def correct_opts?; end
+  def format(locals); end
+  def initialize(no_user_opts, args, pry_instance); end
+  def output_self; end
+end
+class Pry::Command::Ls::LocalVars < Pry::Command::Ls::Formatter
+  def colorized_assignment_style(lhs, rhs, desired_width = nil); end
+  def format(name_value_pairs); end
+  def initialize(opts, pry_instance); end
+  def output_self; end
+end
+class Pry::Command::Ls::LsEntity
+  def constants; end
+  def entities; end
+  def entities_table; end
+  def globals; end
+  def grep(entity); end
+  def initialize(opts); end
+  def instance_vars; end
+  def local_names; end
+  def local_vars; end
+  def methods; end
+  def pry_instance; end
+  def self_methods; end
+end
+class Pry::Config
+  def [](attr); end
+  def []=(attr, value); end
+  def auto_indent; end
+  def auto_indent=(arg0); end
+  def collision_warning; end
+  def collision_warning=(arg0); end
+  def color; end
+  def color=(arg0); end
+  def command_completions; end
+  def command_completions=(arg0); end
+  def command_prefix; end
+  def command_prefix=(arg0); end
+  def commands; end
+  def commands=(arg0); end
+  def completer; end
+  def completer=(arg0); end
+  def control_d_handler; end
+  def control_d_handler=(value); end
+  def correct_indent; end
+  def correct_indent=(arg0); end
+  def default_rc_file; end
+  def default_window_size; end
+  def default_window_size=(arg0); end
+  def disable_auto_reload; end
+  def disable_auto_reload=(arg0); end
+  def editor; end
+  def editor=(arg0); end
+  def exception_handler; end
+  def exception_handler=(arg0); end
+  def exception_whitelist; end
+  def exception_whitelist=(arg0); end
+  def exec_string; end
+  def exec_string=(arg0); end
+  def extra_sticky_locals; end
+  def extra_sticky_locals=(arg0); end
+  def file_completions; end
+  def file_completions=(arg0); end
+  def history; end
+  def history=(arg0); end
+  def history_file; end
+  def history_file=(arg0); end
+  def history_ignorelist; end
+  def history_ignorelist=(arg0); end
+  def history_load; end
+  def history_load=(arg0); end
+  def history_save; end
+  def history_save=(arg0); end
+  def hooks; end
+  def hooks=(arg0); end
+  def initialize; end
+  def initialize_dup(other); end
+  def input; end
+  def input=(arg0); end
+  def lazy_readline; end
+  def ls; end
+  def ls=(arg0); end
+  def memory_size; end
+  def memory_size=(arg0); end
+  def merge!(config_hash); end
+  def merge(config_hash); end
+  def method_missing(method_name, *args, &_block); end
+  def output; end
+  def output=(arg0); end
+  def output_prefix; end
+  def output_prefix=(arg0); end
+  def pager; end
+  def pager=(arg0); end
+  def print; end
+  def print=(arg0); end
+  def prompt; end
+  def prompt=(arg0); end
+  def prompt_name; end
+  def prompt_name=(arg0); end
+  def prompt_safe_contexts; end
+  def prompt_safe_contexts=(arg0); end
+  def quiet; end
+  def quiet=(arg0); end
+  def rc_file; end
+  def rc_file=(arg0); end
+  def requires; end
+  def requires=(arg0); end
+  def respond_to_missing?(method_name, include_all = nil); end
+  def should_load_local_rc; end
+  def should_load_local_rc=(arg0); end
+  def should_load_plugins; end
+  def should_load_plugins=(arg0); end
+  def should_load_rc; end
+  def should_load_rc=(arg0); end
+  def should_load_requires; end
+  def should_load_requires=(arg0); end
+  def should_trap_interrupts; end
+  def should_trap_interrupts=(arg0); end
+  def system; end
+  def system=(arg0); end
+  def unrescued_exceptions; end
+  def unrescued_exceptions=(arg0); end
+  def windows_console_warning; end
+  def windows_console_warning=(arg0); end
+  extend Pry::Config::Attributable
+end
+module Pry::Config::Attributable
+  def attribute(attr_name); end
+end
+class Pry::Config::Value
+  def call; end
+  def initialize(value); end
+end
+class Pry::Config::MemoizedValue
+  def call; end
+  def initialize(&block); end
+end
+class Pry::Config::LazyValue
+  def call; end
+  def initialize(&block); end
+end
+class Pry::Inspector
+end
+class Pry::Pager
+  def best_available; end
+  def enabled?; end
+  def initialize(pry_instance); end
+  def open; end
+  def output; end
+  def page(text); end
+  def pry_instance; end
+end
+class Pry::Pager::StopPaging < StandardError
+end
+class Pry::Pager::NullPager
+  def <<(str); end
+  def close; end
+  def height; end
+  def initialize(out); end
+  def print(str); end
+  def puts(str); end
+  def width; end
+  def write(str); end
+end
+class Pry::Pager::SimplePager < Pry::Pager::NullPager
+  def initialize(*arg0); end
+  def write(str); end
+end
+class Pry::Pager::SystemPager < Pry::Pager::NullPager
+  def close; end
+  def initialize(*arg0); end
+  def invoked_pager?; end
+  def pager; end
+  def self.available?; end
+  def self.default_pager; end
+  def write(str); end
+  def write_to_pager(text); end
+end
+class Pry::Pager::PageTracker
+  def initialize(rows, cols); end
+  def line_length(line); end
+  def page?; end
+  def record(str); end
+  def reset; end
+end
+class Pry::Indent
+  def correct_indentation(prompt, code, overhang = nil); end
+  def current_prefix; end
+  def end_of_statement?(last_token, last_kind); end
+  def in_string?; end
+  def indent(input); end
+  def indent_level; end
+  def indentation_delta(tokens); end
+  def initialize(pry_instance = nil); end
+  def module_nesting; end
+  def open_delimiters; end
+  def open_delimiters_line; end
+  def reset; end
+  def self.indent(str); end
+  def self.nesting_at(str, line_number); end
+  def stack; end
+  def tokenize(string); end
+  def track_delimiter(token); end
+  def track_module_nesting(token, kind); end
+  def track_module_nesting_end(token, kind = nil); end
+  include Pry::Helpers::BaseHelpers
+end
+class Pry::Indent::UnparseableNestingError < StandardError
+end
+class Pry::ObjectPath
+  def complete?(segment); end
+  def handle_failure(context, err); end
+  def initialize(path_string, current_stack); end
+  def resolve; end
+end
+class Pry::Output
+  def <<(*objs); end
+  def actual_screen_size; end
+  def ansicon_env_size; end
+  def decolorize_maybe(str); end
+  def env_size; end
+  def height; end
+  def initialize(pry_instance); end
+  def io_console_size; end
+  def method_missing(method_name, *args, &block); end
+  def nonzero_column?(size); end
+  def print(*objs); end
+  def pry_instance; end
+  def puts(*objs); end
+  def readline_size; end
+  def respond_to_missing?(method_name, include_private = nil); end
+  def size; end
+  def tty?; end
+  def width; end
+  def write(*objs); end
+end
+class Pry::InputLock
+  def __with_ownership; end
+  def enter_interruptible_region; end
+  def initialize; end
+  def interruptible_region; end
+  def leave_interruptible_region; end
+  def self.for(input); end
+  def self.global_lock; end
+  def self.global_lock=(arg0); end
+  def self.input_locks; end
+  def self.input_locks=(arg0); end
+  def with_ownership(&block); end
+end
+class Pry::InputLock::Interrupt < Exception
+end
+class Pry::REPL
+  def calculate_overhang(current_prompt, original_val, indented_val); end
+  def coolline_available?; end
+  def epilogue; end
+  def handle_read_errors; end
+  def initialize(pry, options = nil); end
+  def input(*args, &block); end
+  def input_readline(*args); end
+  def output(*args, &block); end
+  def piping?; end
+  def prologue; end
+  def pry; end
+  def pry=(arg0); end
+  def read; end
+  def read_line(current_prompt); end
+  def readline_available?; end
+  def repl; end
+  def self.start(options); end
+  def set_readline_output; end
+  def start; end
+  extend Pry::Forwardable
+end
+class Pry::Code
+  def <<(line); end
+  def ==(other); end
+  def after(lineno, lines = nil); end
+  def alter(&block); end
+  def around(lineno, lines = nil); end
+  def before(lineno, lines = nil); end
+  def between(start_line, end_line = nil); end
+  def code_type; end
+  def code_type=(arg0); end
+  def comment_describing(line_number); end
+  def expression_at(line_number, consume = nil); end
+  def grep(pattern); end
+  def highlighted; end
+  def initialize(lines = nil, start_line = nil, code_type = nil); end
+  def length; end
+  def max_lineno_width; end
+  def method_missing(method_name, *args, &block); end
+  def nesting_at(line_number); end
+  def print_to_output(output, color = nil); end
+  def push(line); end
+  def raw; end
+  def reject(&block); end
+  def respond_to_missing?(method_name, include_private = nil); end
+  def select(&block); end
+  def self.from_file(filename, code_type = nil); end
+  def self.from_method(meth, start_line = nil); end
+  def self.from_module(mod, candidate_rank = nil, start_line = nil); end
+  def take_lines(start_line, num_lines); end
+  def to_s; end
+  def with_indentation(spaces = nil); end
+  def with_line_numbers(y_n = nil); end
+  def with_marker(lineno = nil); end
+end
+class Pry::Ring
+  def <<(value); end
+  def [](index); end
+  def clear; end
+  def count; end
+  def initialize(max_size); end
+  def max_size; end
+  def size; end
+  def to_a; end
+  def transpose_buffer_tail; end
+end
+class Pry::Method
+  def ==(other); end
+  def alias?; end
+  def aliases; end
+  def bound_method?; end
+  def c_source; end
+  def comment; end
+  def doc; end
+  def dynamically_defined?; end
+  def initialize(method, known_info = nil); end
+  def is_a?(klass); end
+  def kind_of?(klass); end
+  def method_missing(method_name, *args, &block); end
+  def method_name_from_first_line(first_ln); end
+  def name; end
+  def name_with_owner; end
+  def original_name; end
+  def owner(*args, &block); end
+  def parameters(*args, &block); end
+  def pry_doc_info; end
+  def pry_method?; end
+  def receiver(*args, &block); end
+  def redefine(source); end
+  def respond_to?(method_name, include_all = nil); end
+  def respond_to_missing?(method_name, include_private = nil); end
+  def ruby_source; end
+  def self.all_from_class(klass, include_super = nil); end
+  def self.all_from_obj(obj, include_super = nil); end
+  def self.from_binding(binding); end
+  def self.from_class(klass, name, target = nil); end
+  def self.from_module(klass, name, target = nil); end
+  def self.from_obj(obj, name, target = nil); end
+  def self.from_str(name, target = nil, options = nil); end
+  def self.instance_method_definition?(name, definition_line); end
+  def self.instance_resolution_order(klass); end
+  def self.lookup_method_via_binding(obj, method_name, method_type, target = nil); end
+  def self.method_definition?(name, definition_line); end
+  def self.resolution_order(obj); end
+  def self.singleton_class_of(obj); end
+  def self.singleton_class_resolution_order(klass); end
+  def self.singleton_method_definition?(name, definition_line); end
+  def signature; end
+  def singleton_method?; end
+  def source; end
+  def source?; end
+  def source_file; end
+  def source_line; end
+  def source_range; end
+  def source_type; end
+  def super(times = nil); end
+  def super_using_ancestors(ancestors, times = nil); end
+  def unbound_method?; end
+  def undefined?; end
+  def visibility; end
+  def wrapped; end
+  def wrapped_owner; end
+  extend Pry::Forwardable
+  extend Pry::Helpers::BaseHelpers
+  include Pry::CodeObject::Helpers
+  include Pry::Helpers::BaseHelpers
+  include Pry::Helpers::DocumentationHelpers
+end
+class Pry::WrappedModule
+  def all_methods_for(mod); end
+  def all_relevant_methods_for(mod); end
+  def all_source_locations_by_popularity; end
+  def candidate(rank); end
+  def candidates; end
+  def class?; end
+  def constants(inherit = nil); end
+  def doc; end
+  def file; end
+  def initialize(mod); end
+  def line; end
+  def lines_for_file(file); end
+  def method_candidates; end
+  def method_defined_by_forwardable_module?(method); end
+  def method_missing(method_name, *args, &block); end
+  def method_prefix; end
+  def module?; end
+  def nested_module?(parent, name); end
+  def nonblank_name; end
+  def number_of_candidates; end
+  def primary_candidate; end
+  def respond_to_missing?(method_name, include_private = nil); end
+  def self.from_str(mod_name, target = nil); end
+  def self.safe_to_evaluate?(str, target); end
+  def singleton_class?; end
+  def singleton_instance; end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def super(times = nil); end
+  def wrapped; end
+  def yard_doc; end
+  def yard_docs?; end
+  def yard_file; end
+  def yard_line; end
+  include Pry::CodeObject::Helpers
+  include Pry::Helpers::BaseHelpers
+end
+class Pry::WrappedModule::Candidate
+  def class?(*args, &block); end
+  def class_regexes; end
+  def doc; end
+  def file; end
+  def first_line_of_module_definition(file, line); end
+  def first_method_source_location; end
+  def initialize(wrapper, rank); end
+  def last_method_source_location; end
+  def line; end
+  def lines_for_file(*a, &b); end
+  def method_candidates(*a, &b); end
+  def module?(*args, &block); end
+  def name(*a, &b); end
+  def nonblank_name(*args, &block); end
+  def number_of_candidates(*args, &block); end
+  def number_of_lines_in_first_chunk; end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def wrapped(*args, &block); end
+  def yard_docs?(*a, &b); end
+  extend Pry::Forwardable
+  include Pry::CodeObject::Helpers
+  include Pry::Helpers::DocumentationHelpers
+end
+class Pry::Slop
+  def [](key); end
+  def add_callback(label, &block); end
+  def autocreate(items, index); end
+  def banner(banner = nil); end
+  def banner=(banner); end
+  def build_option(objects, &block); end
+  def clean(object); end
+  def command(command, options = nil, &block); end
+  def commands_to_help; end
+  def config; end
+  def description(desc = nil); end
+  def description=(desc); end
+  def each(&block); end
+  def execute_multiple_switches(option, argument, index); end
+  def execute_option(option, argument, index, item = nil); end
+  def extract_long_flag(objects, config); end
+  def extract_option(flag); end
+  def extract_short_flag(objects, config); end
+  def fetch_command(command); end
+  def fetch_option(key); end
+  def get(key); end
+  def help; end
+  def initialize(config = nil, &block); end
+  def method_missing(method, *args, &block); end
+  def missing; end
+  def on(*objects, &block); end
+  def opt(*objects, &block); end
+  def option(*objects, &block); end
+  def options; end
+  def parse!(items = nil, &block); end
+  def parse(items = nil, &block); end
+  def present?(*keys); end
+  def process_item(items, index, &block); end
+  def respond_to_missing?(method_name, include_all = nil); end
+  def run(callable = nil, &block); end
+  def self.optspec(string, config = nil); end
+  def self.parse!(items = nil, config = nil, &block); end
+  def self.parse(items = nil, config = nil, &block); end
+  def separator(text); end
+  def strict?; end
+  def to_h(include_commands = nil); end
+  def to_hash(include_commands = nil); end
+  def to_s; end
+  include Enumerable
+end
+class Pry::Slop::Option
+  def accepts_optional_argument?; end
+  def argument?; end
+  def argument_in_value; end
+  def argument_in_value=(arg0); end
+  def as?; end
+  def autocreated?; end
+  def call(*objects); end
+  def callback?; end
+  def config; end
+  def count; end
+  def count=(arg0); end
+  def default?; end
+  def delimiter?; end
+  def description; end
+  def expects_argument?; end
+  def help; end
+  def initialize(slop, short, long, description, config = nil, &block); end
+  def inspect; end
+  def key; end
+  def limit?; end
+  def long; end
+  def match?; end
+  def optional?; end
+  def optional_argument?; end
+  def required?; end
+  def short; end
+  def tail?; end
+  def to_s; end
+  def types; end
+  def value; end
+  def value=(new_value); end
+  def value_to_float(value); end
+  def value_to_integer(value); end
+  def value_to_range(value); end
+end
+class Pry::Slop::Commands
+  def [](key); end
+  def arguments; end
+  def banner(banner = nil); end
+  def banner=(arg0); end
+  def commands; end
+  def config; end
+  def default(config = nil, &block); end
+  def each(&block); end
+  def execute_arguments!(items); end
+  def execute_global_opts!(items); end
+  def get(key); end
+  def global(config = nil, &block); end
+  def help; end
+  def initialize(config = nil, &block); end
+  def inspect; end
+  def on(command, config = nil, &block); end
+  def parse!(items = nil); end
+  def parse(items = nil); end
+  def present?(key); end
+  def to_hash; end
+  def to_s; end
+  include Enumerable
+end
+class Pry::Slop::Error < StandardError
+end
+class Pry::Slop::MissingArgumentError < Pry::Slop::Error
+end
+class Pry::Slop::MissingOptionError < Pry::Slop::Error
+end
+class Pry::Slop::InvalidArgumentError < Pry::Slop::Error
+end
+class Pry::Slop::InvalidOptionError < Pry::Slop::Error
+end
+class Pry::Slop::InvalidCommandError < Pry::Slop::Error
+end
+class Pry::CLI
+  def self.add_option_processor(&block); end
+  def self.add_options(&block); end
+  def self.add_plugin_options; end
+  def self.input_args; end
+  def self.input_args=(arg0); end
+  def self.option_processors; end
+  def self.option_processors=(arg0); end
+  def self.options; end
+  def self.options=(arg0); end
+  def self.parse_options(args = nil); end
+  def self.reset; end
+  def self.start(opts); end
+end
+class Pry::CLI::NoOptionsError < StandardError
+end
+class Object < BasicObject
+  def __binding__; end
+  def pry(object = nil, hash = nil); end
+end
+class BasicObject
+  def __binding__; end
+end
+class Pry::REPLFileLoader
+  def define_additional_commands; end
+  def initialize(file_name); end
+  def interactive_mode(pry_instance); end
+  def load; end
+  def non_interactive_mode(pry_instance, content); end
+end
+class Pry::Code::LOC
+  def ==(other); end
+  def add_line_number(max_width = nil, color = nil); end
+  def add_marker(marker_lineno); end
+  def colorize(code_type); end
+  def dup; end
+  def handle_multiline_entries_from_edit_command(line, max_width); end
+  def indent(distance); end
+  def initialize(line, lineno); end
+  def line; end
+  def lineno; end
+  def tuple; end
+end
+class Pry::Code::CodeRange
+  def end_line; end
+  def find_end_index(lines); end
+  def find_start_index(lines); end
+  def force_set_end_line; end
+  def indices(lines); end
+  def indices_range(lines); end
+  def initialize(start_line, end_line = nil); end
+  def set_end_line_from_range; end
+  def start_line; end
+end
+class Pry::CodeFile
+  def abs_path; end
+  def code; end
+  def code_path; end
+  def code_type; end
+  def from_load_path; end
+  def from_pry_init_pwd; end
+  def from_pwd; end
+  def initialize(filename, code_type = nil); end
+  def readable?(path); end
+  def type_from_filename(filename, default = nil); end
+end
+class Pry::Method::WeirdMethodLocator
+  def all_methods_for(obj); end
+  def expanded_source_location(source_location); end
+  def find_method; end
+  def find_method_in_superclass; end
+  def find_renamed_method; end
+  def index_to_line_number(index); end
+  def initialize(method, target); end
+  def lines_for_file(file); end
+  def lost_method?; end
+  def method; end
+  def method=(arg0); end
+  def normal_method?(method); end
+  def pry_file?; end
+  def renamed_method_source_location; end
+  def self.normal_method?(method, binding); end
+  def self.weird_method?(method, binding); end
+  def skip_superclass_search?; end
+  def target; end
+  def target=(arg0); end
+  def target_file; end
+  def target_line; end
+  def target_self; end
+  def valid_file?(file); end
+end
+class Pry::Method::Disowned < Pry::Method
+  def initialize(receiver, method_name); end
+  def method_missing(method_name, *args, &block); end
+  def name; end
+  def owner; end
+  def receiver; end
+  def respond_to_missing?(method_name, include_private = nil); end
+  def source?; end
+  def undefined?; end
+end
+class Pry::Method::Patcher
+  def cache_key; end
+  def definition_for_owner(line); end
+  def initialize(method); end
+  def method; end
+  def method=(arg0); end
+  def patch_in_ram(source); end
+  def redefine(source); end
+  def self.code_for(filename); end
+  def with_method_transaction; end
+  def wrap(source); end
+  def wrap_for_nesting(source); end
+  def wrap_for_owner(source); end
+end
+class Pry::Command::AmendLine < Pry::ClassCommand
+  def amend_input; end
+  def delete_from_array(array, range); end
+  def insert_into_array(array, range); end
+  def line_count; end
+  def line_range; end
+  def process; end
+  def replace_in_array(array, range); end
+  def start_and_end_line_number; end
+  def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
+end
+class Pry::Command::Bang < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::BangPry < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Cat < Pry::ClassCommand
+  def complete(search); end
+  def load_path_completions; end
+  def options(opt); end
+  def process; end
+end
+class Pry::Command::Cat::AbstractFormatter
+  def between_lines; end
+  def code_type; end
+  def decorate(content); end
+  def use_line_numbers?; end
+  include Pry::Helpers::BaseHelpers
+  include Pry::Helpers::CommandHelpers
+end
+class Pry::Command::Cat::InputExpressionFormatter < Pry::Command::Cat::AbstractFormatter
+  def format; end
+  def initialize(input_expressions, opts); end
+  def input_expressions; end
+  def input_expressions=(arg0); end
+  def normalized_expression_range; end
+  def numbered_input_items; end
+  def opts; end
+  def opts=(arg0); end
+  def selected_input_items; end
+end
+class Pry::Command::Cat::ExceptionFormatter < Pry::Command::Cat::AbstractFormatter
+  def backtrace_file; end
+  def backtrace_level; end
+  def backtrace_line; end
+  def check_for_errors; end
+  def code_window_size; end
+  def ex; end
+  def format; end
+  def header; end
+  def increment_backtrace_level; end
+  def initialize(exception, pry_instance, opts); end
+  def opts; end
+  def pry_instance; end
+  def start_and_end_line_for_code_window; end
+  include Pry::Helpers::Text
+end
+class Pry::Command::Cat::FileFormatter < Pry::Command::Cat::AbstractFormatter
+  def code_type; end
+  def code_window_size; end
+  def decorate(content); end
+  def detect_code_type_from_file(file_name); end
+  def file_and_line; end
+  def file_name; end
+  def file_with_embedded_line; end
+  def format; end
+  def initialize(file_with_embedded_line, pry_instance, opts); end
+  def line_number; end
+  def opts; end
+  def pry_instance; end
+end
+class Pry::Command::Cd < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::ChangeInspector < Pry::ClassCommand
+  def inspector_map; end
+  def process(inspector); end
+end
+class Pry::Command::ChangePrompt < Pry::ClassCommand
+  def change_prompt(prompt); end
+  def list_prompts; end
+  def options(opt); end
+  def process(prompt); end
+end
+class Pry::Command::ClearScreen < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::CodeCollector
+  def args; end
+  def bad_option_combination?; end
+  def code_object; end
+  def code_object_doc; end
+  def code_object_source_or_file; end
+  def content; end
+  def convert_to_range(range); end
+  def could_not_locate(name); end
+  def file; end
+  def file=(arg0); end
+  def file_content; end
+  def initialize(args, opts, pry_instance); end
+  def line_range; end
+  def obj_name; end
+  def opts; end
+  def pry_array_content_as_string(array, ranges); end
+  def pry_input_content; end
+  def pry_instance; end
+  def pry_output_content; end
+  def restrict_to_lines(content, range); end
+  def self.inject_options(opt); end
+  def self.input_expression_ranges; end
+  def self.input_expression_ranges=(arg0); end
+  def self.output_result_ranges; end
+  def self.output_result_ranges=(arg0); end
+  include Pry::Helpers::CommandHelpers
+end
+class Pry::Command::DisablePry < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Edit < Pry::ClassCommand
+  def apply_runtime_patch; end
+  def bad_option_combination?; end
+  def code_object; end
+  def ensure_file_name_is_valid(file_name); end
+  def file_and_line; end
+  def file_and_line_for_current_exception; end
+  def file_based_exception?; end
+  def file_edit; end
+  def filename_argument; end
+  def initial_temp_file_content; end
+  def input_expression; end
+  def never_reload?; end
+  def options(opt); end
+  def patch_exception?; end
+  def previously_patched?(code_object); end
+  def probably_a_file?(str); end
+  def process; end
+  def pry_method?(code_object); end
+  def reload?(file_name = nil); end
+  def reloadable?; end
+  def repl_edit; end
+  def repl_edit?; end
+  def runtime_patch?; end
+end
+class Pry::Command::Edit::ExceptionPatcher
+  def file_and_line; end
+  def file_and_line=(arg0); end
+  def initialize(pry_instance, state, exception_file_and_line); end
+  def perform_patch; end
+  def pry_instance; end
+  def pry_instance=(arg0); end
+  def state; end
+  def state=(arg0); end
+end
+module Pry::Command::Edit::FileAndLineLocator
+  def self.from_binding(target); end
+  def self.from_code_object(code_object, filename_argument); end
+  def self.from_exception(exception, backtrace_level); end
+  def self.from_filename_argument(filename_argument); end
+end
+class Pry::Command::Exit < Pry::ClassCommand
+  def process; end
+  def process_pop_and_return; end
+end
+class Pry::Command::ExitAll < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::ExitProgram < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::FindMethod < Pry::ClassCommand
+  def additional_info(header, method); end
+  def content_search(namespace); end
+  def matched_method_lines(header, method); end
+  def name_search(namespace); end
+  def options(opt); end
+  def pattern; end
+  def print_matches(matches); end
+  def print_matches_for_class(klass, grouped); end
+  def process; end
+  def recurse_namespace(klass, done = nil, &block); end
+  def search_all_methods(namespace); end
+  def search_class; end
+  def show_search_results(matches); end
+  extend Pry::Helpers::BaseHelpers
+end
+class Pry::Command::FixIndent < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Help < Pry::ClassCommand
+  def command_groups; end
+  def display_command(command); end
+  def display_filtered_commands(search); end
+  def display_filtered_search_results(search); end
+  def display_index(groups); end
+  def display_search(search); end
+  def group_sort_key(group_name); end
+  def help_text_for_commands(name, commands); end
+  def normalize(key); end
+  def process; end
+  def search_hash(search, hash); end
+  def sorted_commands(commands); end
+  def sorted_group_names(groups); end
+  def visible_commands; end
+end
+class Pry::Command::Hist < Pry::ClassCommand
+  def check_for_juxtaposed_replay(replay_sequence); end
+  def find_history; end
+  def options(opt); end
+  def process; end
+  def process_clear; end
+  def process_display; end
+  def process_replay; end
+  def process_save; end
+end
+class Pry::Command::ImportSet < Pry::ClassCommand
+  def process(_command_set_name); end
+end
+class Pry::Command::JumpTo < Pry::ClassCommand
+  def process(break_level); end
+end
+class Pry::Command::ListInspectors < Pry::ClassCommand
+  def inspector_map; end
+  def process; end
+  def selected_inspector?(inspector); end
+  def selected_text; end
+end
+class Pry::Command::Nesting < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Play < Pry::ClassCommand
+  def code_object; end
+  def content; end
+  def content_after_options; end
+  def content_at_expression; end
+  def default_file; end
+  def file_content; end
+  def options(opt); end
+  def perform_play; end
+  def process; end
+  def should_use_default_file?; end
+  def show_input; end
+end
+class Pry::Command::PryBacktrace < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Version < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::RaiseUp < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::ReloadCode < Pry::ClassCommand
+  def check_for_reloadability(code_object, identifier); end
+  def current_file; end
+  def process; end
+  def reload_current_file; end
+  def reload_object(identifier); end
+end
+class Pry::Command::Reset < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::Ri < Pry::ClassCommand
+  def process(spec); end
+end
+class Pry::Command::SaveFile < Pry::ClassCommand
+  def display_content; end
+  def file_name; end
+  def mode; end
+  def options(opt); end
+  def process; end
+  def save_file; end
+end
+class Pry::Command::ShellCommand < Pry::ClassCommand
+  def cd_path_env; end
+  def cd_path_exists?; end
+  def parse_destination(dest); end
+  def path_from_cd_path(dest); end
+  def process(cmd); end
+  def process_cd(dest); end
+  def special_case_path?(dest); end
+end
+class Pry::Command::ShellMode < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::ShowInfo < Pry::ClassCommand
+  def code_object_header(code_object, line_num); end
+  def code_object_with_accessible_source(code_object); end
+  def complete(input); end
+  def content_and_header_for_code_object(code_object); end
+  def content_and_headers_for_all_module_candidates(mod); end
+  def file_and_line_for(code_object); end
+  def header(code_object); end
+  def header_options; end
+  def initialize(*arg0); end
+  def method_header(code_object, line_num); end
+  def method_sections(code_object); end
+  def module_header(code_object, line_num); end
+  def no_definition_message; end
+  def obj_name; end
+  def options(opt); end
+  def process; end
+  def show_all_modules?(code_object); end
+  def start_line_for(code_object); end
+  def use_line_numbers?; end
+  def valid_superclass?(code_object); end
+  extend Pry::Helpers::BaseHelpers
+end
+class Pry::Command::ShowDoc < Pry::Command::ShowInfo
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+  include Pry::Helpers::DocumentationHelpers
+end
+class Pry::Command::ShowInput < Pry::ClassCommand
+  def process; end
+end
+class Pry::Command::ShowSource < Pry::Command::ShowInfo
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def options(opt); end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+  include Pry::Helpers::DocumentationHelpers
+end
+class Pry::Command::Stat < Pry::ClassCommand
+  def options(opt); end
+  def process; end
+end
+class Pry::Command::SwitchTo < Pry::ClassCommand
+  def process(selection); end
+end
+class Pry::Command::ToggleColor < Pry::ClassCommand
+  def color_toggle; end
+  def process; end
+end
+class Pry::Command::WatchExpression < Pry::ClassCommand
+  def add_expression(_arguments); end
+  def add_hook; end
+  def delete(index); end
+  def eval_and_print_changed(output); end
+  def expressions; end
+  def list; end
+  def options(opt); end
+  def process; end
+end
+class Pry::Command::WatchExpression::Expression
+  def changed?; end
+  def eval!; end
+  def initialize(pry_instance, target, source); end
+  def previous_value; end
+  def pry_instance; end
+  def source; end
+  def target; end
+  def target_eval(target, source); end
+  def to_s; end
+  def value; end
+end
+class Pry::Command::Whereami < Pry::ClassCommand
+  def bad_option_combination?; end
+  def class_code; end
+  def code; end
+  def code?; end
+  def code_window; end
+  def default_code; end
+  def expand_path(filename); end
+  def handle_internal_binding; end
+  def initialize(*arg0); end
+  def location; end
+  def marker; end
+  def method_code; end
+  def nothing_to_do?; end
+  def options(opt); end
+  def process; end
+  def self.method_size_cutoff; end
+  def self.method_size_cutoff=(arg0); end
+  def setup; end
+  def small_method?; end
+  def target_class; end
+  def top_level?; end
+  def use_line_numbers?; end
+  def valid_method?; end
+  def window_size; end
+end
+class Pry::Command::Wtf < Pry::ClassCommand
+  def format_backtrace(backtrace); end
+  def format_header(title, exception); end
+  def options(opt); end
+  def process; end
+  def read_line(file, line); end
+  def trim_backtrace(backtrace); end
+  def unwind_exceptions; end
+end
diff --git a/sorbet/rbi/gems/rake.rbi b/sorbet/rbi/gems/rake.rbi
new file mode 100644
index 0000000..fb5823d
--- /dev/null
+++ b/sorbet/rbi/gems/rake.rbi
@@ -0,0 +1,648 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi
+#
+# rake-13.0.1
+
+module Rake
+  def self.add_rakelib(*files); end
+  def self.application; end
+  def self.application=(app); end
+  def self.each_dir_parent(dir); end
+  def self.from_pathname(path); end
+  def self.load_rakefile(path); end
+  def self.original_dir; end
+  def self.suggested_thread_count; end
+  def self.with_application(block_application = nil); end
+  extend Rake::FileUtilsExt
+end
+module Rake::Version
+end
+class Module
+  def rake_extension(method); end
+end
+class String
+  def ext(newext = nil); end
+  def pathmap(spec = nil, &block); end
+  def pathmap_explode; end
+  def pathmap_partial(n); end
+  def pathmap_replace(patterns, &block); end
+end
+module Rake::Win32
+  def self.normalize(path); end
+  def self.win32_system_dir; end
+  def self.windows?; end
+end
+class Rake::Win32::Win32HomeError < RuntimeError
+end
+class Rake::LinkedList
+  def ==(other); end
+  def conj(item); end
+  def each; end
+  def empty?; end
+  def head; end
+  def initialize(head, tail = nil); end
+  def inspect; end
+  def self.cons(head, tail); end
+  def self.empty; end
+  def self.make(*args); end
+  def tail; end
+  def to_s; end
+  include Enumerable
+end
+class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList
+  def empty?; end
+  def initialize; end
+  def self.cons(head, tail); end
+end
+class Rake::CpuCounter
+  def count; end
+  def count_with_default(default = nil); end
+  def self.count; end
+end
+class Rake::Scope < Rake::LinkedList
+  def path; end
+  def path_with_task_name(task_name); end
+  def trim(n); end
+end
+class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList
+  def path; end
+  def path_with_task_name(task_name); end
+end
+class Rake::TaskArgumentError < ArgumentError
+end
+class Rake::RuleRecursionOverflowError < StandardError
+  def add_target(target); end
+  def initialize(*args); end
+  def message; end
+end
+module Rake::TaskManager
+  def [](task_name, scopes = nil); end
+  def add_location(task); end
+  def attempt_rule(task_name, task_pattern, args, extensions, block, level); end
+  def clear; end
+  def create_rule(*args, &block); end
+  def current_scope; end
+  def define_task(task_class, *args, &block); end
+  def enhance_with_matching_rule(task_name, level = nil); end
+  def find_location; end
+  def generate_did_you_mean_suggestions(task_name); end
+  def generate_message_for_undefined_task(task_name); end
+  def generate_name; end
+  def get_description(task); end
+  def in_namespace(name); end
+  def initialize; end
+  def intern(task_class, task_name); end
+  def last_description; end
+  def last_description=(arg0); end
+  def lookup(task_name, initial_scope = nil); end
+  def lookup_in_scope(name, scope); end
+  def make_sources(task_name, task_pattern, extensions); end
+  def resolve_args(args); end
+  def resolve_args_with_dependencies(args, hash); end
+  def resolve_args_without_dependencies(args); end
+  def self.record_task_metadata; end
+  def self.record_task_metadata=(arg0); end
+  def synthesize_file_task(task_name); end
+  def tasks; end
+  def tasks_in_scope(scope); end
+  def trace_rule(level, message); end
+end
+module Rake::Cloneable
+  def initialize_copy(source); end
+end
+module FileUtils
+  def create_shell_runner(cmd); end
+  def ruby(*args, **options, &block); end
+  def safe_ln(*args, **options); end
+  def set_verbose_option(options); end
+  def sh(*cmd, &block); end
+  def sh_show_command(cmd); end
+  def split_all(path); end
+end
+module Rake::FileUtilsExt
+  def cd(*args, **options, &block); end
+  def chdir(*args, **options, &block); end
+  def chmod(*args, **options, &block); end
+  def chmod_R(*args, **options, &block); end
+  def chown(*args, **options, &block); end
+  def chown_R(*args, **options, &block); end
+  def copy(*args, **options, &block); end
+  def cp(*args, **options, &block); end
+  def cp_lr(*args, **options, &block); end
+  def cp_r(*args, **options, &block); end
+  def install(*args, **options, &block); end
+  def link(*args, **options, &block); end
+  def ln(*args, **options, &block); end
+  def ln_s(*args, **options, &block); end
+  def ln_sf(*args, **options, &block); end
+  def makedirs(*args, **options, &block); end
+  def mkdir(*args, **options, &block); end
+  def mkdir_p(*args, **options, &block); end
+  def mkpath(*args, **options, &block); end
+  def move(*args, **options, &block); end
+  def mv(*args, **options, &block); end
+  def nowrite(value = nil); end
+  def rake_check_options(options, *optdecl); end
+  def rake_output_message(message); end
+  def remove(*args, **options, &block); end
+  def rm(*args, **options, &block); end
+  def rm_f(*args, **options, &block); end
+  def rm_r(*args, **options, &block); end
+  def rm_rf(*args, **options, &block); end
+  def rmdir(*args, **options, &block); end
+  def rmtree(*args, **options, &block); end
+  def safe_unlink(*args, **options, &block); end
+  def self.nowrite_flag; end
+  def self.nowrite_flag=(arg0); end
+  def self.verbose_flag; end
+  def self.verbose_flag=(arg0); end
+  def symlink(*args, **options, &block); end
+  def touch(*args, **options, &block); end
+  def verbose(value = nil); end
+  def when_writing(msg = nil); end
+  extend Rake::FileUtilsExt
+  include FileUtils
+end
+class Rake::FileList
+  def &(*args, &block); end
+  def *(other); end
+  def +(*args, &block); end
+  def -(*args, &block); end
+  def <<(obj); end
+  def <=>(*args, &block); end
+  def ==(array); end
+  def [](*args, &block); end
+  def []=(*args, &block); end
+  def add(*filenames); end
+  def add_matching(pattern); end
+  def all?(*args, &block); end
+  def any?(*args, &block); end
+  def append(*args, &block); end
+  def assoc(*args, &block); end
+  def at(*args, &block); end
+  def bsearch(*args, &block); end
+  def bsearch_index(*args, &block); end
+  def chain(*args, &block); end
+  def chunk(*args, &block); end
+  def chunk_while(*args, &block); end
+  def clear(*args, &block); end
+  def clear_exclude; end
+  def collect!(*args, &block); end
+  def collect(*args, &block); end
+  def collect_concat(*args, &block); end
+  def combination(*args, &block); end
+  def compact!(*args, &block); end
+  def compact(*args, &block); end
+  def concat(*args, &block); end
+  def count(*args, &block); end
+  def cycle(*args, &block); end
+  def delete(*args, &block); end
+  def delete_at(*args, &block); end
+  def delete_if(*args, &block); end
+  def detect(*args, &block); end
+  def difference(*args, &block); end
+  def dig(*args, &block); end
+  def drop(*args, &block); end
+  def drop_while(*args, &block); end
+  def each(*args, &block); end
+  def each_cons(*args, &block); end
+  def each_entry(*args, &block); end
+  def each_index(*args, &block); end
+  def each_slice(*args, &block); end
+  def each_with_index(*args, &block); end
+  def each_with_object(*args, &block); end
+  def egrep(pattern, *options); end
+  def empty?(*args, &block); end
+  def entries(*args, &block); end
+  def exclude(*patterns, &block); end
+  def excluded_from_list?(fn); end
+  def existing!; end
+  def existing; end
+  def ext(newext = nil); end
+  def extract_options!(*args, &block); end
+  def fetch(*args, &block); end
+  def fill(*args, &block); end
+  def filter!(*args, &block); end
+  def filter(*args, &block); end
+  def find(*args, &block); end
+  def find_all(*args, &block); end
+  def find_index(*args, &block); end
+  def first(*args, &block); end
+  def flat_map(*args, &block); end
+  def flatten!(*args, &block); end
+  def flatten(*args, &block); end
+  def grep(*args, &block); end
+  def grep_v(*args, &block); end
+  def group_by(*args, &block); end
+  def gsub!(pat, rep); end
+  def gsub(pat, rep); end
+  def import(array); end
+  def include(*filenames); end
+  def include?(*args, &block); end
+  def index(*args, &block); end
+  def initialize(*patterns); end
+  def inject(*args, &block); end
+  def insert(*args, &block); end
+  def inspect(*args, &block); end
+  def is_a?(klass); end
+  def join(*args, &block); end
+  def keep_if(*args, &block); end
+  def kind_of?(klass); end
+  def last(*args, &block); end
+  def lazy(*args, &block); end
+  def length(*args, &block); end
+  def map!(*args, &block); end
+  def map(*args, &block); end
+  def max(*args, &block); end
+  def max_by(*args, &block); end
+  def member?(*args, &block); end
+  def min(*args, &block); end
+  def min_by(*args, &block); end
+  def minmax(*args, &block); end
+  def minmax_by(*args, &block); end
+  def none?(*args, &block); end
+  def one?(*args, &block); end
+  def pack(*args, &block); end
+  def partition(&block); end
+  def pathmap(spec = nil, &block); end
+  def permutation(*args, &block); end
+  def pop(*args, &block); end
+  def prepend(*args, &block); end
+  def product(*args, &block); end
+  def push(*args, &block); end
+  def rassoc(*args, &block); end
+  def reduce(*args, &block); end
+  def reject!(*args, &block); end
+  def reject(*args, &block); end
+  def repeated_combination(*args, &block); end
+  def repeated_permutation(*args, &block); end
+  def replace(*args, &block); end
+  def resolve; end
+  def resolve_add(fn); end
+  def resolve_exclude; end
+  def reverse!(*args, &block); end
+  def reverse(*args, &block); end
+  def reverse_each(*args, &block); end
+  def rindex(*args, &block); end
+  def rotate!(*args, &block); end
+  def rotate(*args, &block); end
+  def sample(*args, &block); end
+  def select!(*args, &block); end
+  def select(*args, &block); end
+  def self.[](*args); end
+  def self.glob(pattern, *args); end
+  def shelljoin(*args, &block); end
+  def shift(*args, &block); end
+  def shuffle!(*args, &block); end
+  def shuffle(*args, &block); end
+  def size(*args, &block); end
+  def slice!(*args, &block); end
+  def slice(*args, &block); end
+  def slice_after(*args, &block); end
+  def slice_before(*args, &block); end
+  def slice_when(*args, &block); end
+  def sort!(*args, &block); end
+  def sort(*args, &block); end
+  def sort_by!(*args, &block); end
+  def sort_by(*args, &block); end
+  def sub!(pat, rep); end
+  def sub(pat, rep); end
+  def sum(*args, &block); end
+  def take(*args, &block); end
+  def take_while(*args, &block); end
+  def to_a; end
+  def to_ary; end
+  def to_default_s(*args, &block); end
+  def to_formatted_s(*args, &block); end
+  def to_h(*args, &block); end
+  def to_s; end
+  def to_sentence(*args, &block); end
+  def to_set(*args, &block); end
+  def to_xml(*args, &block); end
+  def transpose(*args, &block); end
+  def union(*args, &block); end
+  def uniq!(*args, &block); end
+  def uniq(*args, &block); end
+  def unshift(*args, &block); end
+  def values_at(*args, &block); end
+  def zip(*args, &block); end
+  def |(*args, &block); end
+  include Rake::Cloneable
+end
+class Rake::Promise
+  def chore; end
+  def complete?; end
+  def discard; end
+  def error?; end
+  def initialize(args, &block); end
+  def recorder; end
+  def recorder=(arg0); end
+  def result?; end
+  def stat(*args); end
+  def value; end
+  def work; end
+end
+class Rake::ThreadPool
+  def __queue__; end
+  def future(*args, &block); end
+  def gather_history; end
+  def history; end
+  def initialize(thread_count); end
+  def join; end
+  def process_queue_item; end
+  def safe_thread_count; end
+  def start_thread; end
+  def stat(event, data = nil); end
+  def statistics; end
+end
+module Rake::PrivateReader
+  def self.included(base); end
+end
+module Rake::PrivateReader::ClassMethods
+  def private_reader(*names); end
+end
+class Rake::ThreadHistoryDisplay
+  def initialize(stats); end
+  def items; end
+  def rename(hash, key, renames); end
+  def show; end
+  def stats; end
+  def threads; end
+  extend Rake::PrivateReader::ClassMethods
+  include Rake::PrivateReader
+end
+module Rake::TraceOutput
+  def trace_on(out, *strings); end
+end
+class Rake::CommandLineOptionError < StandardError
+end
+class Rake::Application
+  def add_import(fn); end
+  def add_loader(ext, loader); end
+  def collect_command_line_tasks(args); end
+  def default_task_name; end
+  def deprecate(old_usage, new_usage, call_site); end
+  def display_cause_details(ex); end
+  def display_error_message(ex); end
+  def display_exception_backtrace(ex); end
+  def display_exception_details(ex); end
+  def display_exception_details_seen; end
+  def display_exception_message_details(ex); end
+  def display_prerequisites; end
+  def display_tasks_and_comments; end
+  def dynamic_width; end
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def exit_because_of_exception(ex); end
+  def find_rakefile_location; end
+  def glob(path, &block); end
+  def handle_options(argv); end
+  def has_cause?(ex); end
+  def has_chain?(exception); end
+  def have_rakefile; end
+  def init(app_name = nil, argv = nil); end
+  def initialize; end
+  def invoke_task(task_string); end
+  def load_imports; end
+  def load_rakefile; end
+  def name; end
+  def options; end
+  def original_dir; end
+  def parse_task_string(string); end
+  def print_rakefile_directory(location); end
+  def rake_require(file_name, paths = nil, loaded = nil); end
+  def rakefile; end
+  def rakefile_location(backtrace = nil); end
+  def raw_load_rakefile; end
+  def run(argv = nil); end
+  def run_with_threads; end
+  def select_tasks_to_show(options, show_tasks, value); end
+  def select_trace_output(options, trace_option, value); end
+  def set_default_options; end
+  def sort_options(options); end
+  def standard_exception_handling; end
+  def standard_rake_options; end
+  def standard_system_dir; end
+  def system_dir; end
+  def terminal_columns; end
+  def terminal_columns=(arg0); end
+  def terminal_width; end
+  def thread_pool; end
+  def top_level; end
+  def top_level_tasks; end
+  def trace(*strings); end
+  def truncate(string, width); end
+  def truncate_output?; end
+  def tty_output=(arg0); end
+  def tty_output?; end
+  def unix?; end
+  def windows?; end
+  include Rake::TaskManager
+  include Rake::TraceOutput
+end
+class Rake::PseudoStatus
+  def >>(n); end
+  def exited?; end
+  def exitstatus; end
+  def initialize(code = nil); end
+  def stopped?; end
+  def to_i; end
+end
+class Rake::TaskArguments
+  def [](index); end
+  def each(&block); end
+  def extras; end
+  def fetch(*args, &block); end
+  def has_key?(key); end
+  def initialize(names, values, parent = nil); end
+  def inspect; end
+  def key?(key); end
+  def lookup(name); end
+  def method_missing(sym, *args); end
+  def names; end
+  def new_scope(names); end
+  def to_a; end
+  def to_hash; end
+  def to_s; end
+  def values_at(*keys); end
+  def with_defaults(defaults); end
+  include Enumerable
+end
+class Rake::InvocationChain < Rake::LinkedList
+  def append(invocation); end
+  def member?(invocation); end
+  def prefix; end
+  def self.append(invocation, chain); end
+  def to_s; end
+end
+class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList
+  def append(invocation); end
+  def member?(obj); end
+  def to_s; end
+end
+module Rake::InvocationExceptionMixin
+  def chain; end
+  def chain=(value); end
+end
+class Rake::Task
+  def actions; end
+  def add_chain_to(exception, new_chain); end
+  def add_comment(comment); end
+  def add_description(description); end
+  def all_prerequisite_tasks; end
+  def already_invoked; end
+  def application; end
+  def application=(arg0); end
+  def arg_description; end
+  def arg_names; end
+  def clear; end
+  def clear_actions; end
+  def clear_args; end
+  def clear_comments; end
+  def clear_prerequisites; end
+  def collect_prerequisites(seen); end
+  def comment; end
+  def comment=(comment); end
+  def enhance(deps = nil, &block); end
+  def execute(args = nil); end
+  def first_sentence(string); end
+  def format_trace_flags; end
+  def full_comment; end
+  def initialize(task_name, app); end
+  def inspect; end
+  def investigation; end
+  def invoke(*args); end
+  def invoke_prerequisites(task_args, invocation_chain); end
+  def invoke_prerequisites_concurrently(task_args, invocation_chain); end
+  def invoke_with_call_chain(task_args, invocation_chain); end
+  def locations; end
+  def lookup_prerequisite(prerequisite_name); end
+  def name; end
+  def name_with_args; end
+  def needed?; end
+  def order_only_prerequisites; end
+  def prereqs; end
+  def prerequisite_tasks; end
+  def prerequisites; end
+  def reenable; end
+  def scope; end
+  def self.[](task_name); end
+  def self.clear; end
+  def self.create_rule(*args, &block); end
+  def self.define_task(*args, &block); end
+  def self.format_deps(deps); end
+  def self.scope_name(scope, task_name); end
+  def self.task_defined?(task_name); end
+  def self.tasks; end
+  def set_arg_names(args); end
+  def source; end
+  def sources; end
+  def sources=(arg0); end
+  def timestamp; end
+  def to_s; end
+  def transform_comments(separator, &block); end
+  def |(deps); end
+end
+class Rake::EarlyTime
+  def <=>(other); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  def to_s; end
+  extend Singleton::SingletonClassMethods
+  include Comparable
+  include Singleton
+end
+class Rake::FileTask < Rake::Task
+  def needed?; end
+  def out_of_date?(stamp); end
+  def self.scope_name(scope, task_name); end
+  def timestamp; end
+end
+class Rake::FileCreationTask < Rake::FileTask
+  def needed?; end
+  def timestamp; end
+end
+class Rake::MultiTask < Rake::Task
+  def invoke_prerequisites(task_args, invocation_chain); end
+end
+module Rake::DSL
+  def cd(*args, **options, &block); end
+  def chdir(*args, **options, &block); end
+  def chmod(*args, **options, &block); end
+  def chmod_R(*args, **options, &block); end
+  def chown(*args, **options, &block); end
+  def chown_R(*args, **options, &block); end
+  def copy(*args, **options, &block); end
+  def cp(*args, **options, &block); end
+  def cp_lr(*args, **options, &block); end
+  def cp_r(*args, **options, &block); end
+  def desc(description); end
+  def directory(*args, &block); end
+  def file(*args, &block); end
+  def file_create(*args, &block); end
+  def import(*fns); end
+  def install(*args, **options, &block); end
+  def link(*args, **options, &block); end
+  def ln(*args, **options, &block); end
+  def ln_s(*args, **options, &block); end
+  def ln_sf(*args, **options, &block); end
+  def makedirs(*args, **options, &block); end
+  def mkdir(*args, **options, &block); end
+  def mkdir_p(*args, **options, &block); end
+  def mkpath(*args, **options, &block); end
+  def move(*args, **options, &block); end
+  def multitask(*args, &block); end
+  def mv(*args, **options, &block); end
+  def namespace(name = nil, &block); end
+  def nowrite(value = nil); end
+  def rake_check_options(options, *optdecl); end
+  def rake_output_message(message); end
+  def remove(*args, **options, &block); end
+  def rm(*args, **options, &block); end
+  def rm_f(*args, **options, &block); end
+  def rm_r(*args, **options, &block); end
+  def rm_rf(*args, **options, &block); end
+  def rmdir(*args, **options, &block); end
+  def rmtree(*args, **options, &block); end
+  def ruby(*args, **options, &block); end
+  def rule(*args, &block); end
+  def safe_ln(*args, **options); end
+  def safe_unlink(*args, **options, &block); end
+  def sh(*cmd, &block); end
+  def split_all(path); end
+  def symlink(*args, **options, &block); end
+  def task(*args, &block); end
+  def touch(*args, **options, &block); end
+  def verbose(value = nil); end
+  def when_writing(msg = nil); end
+  include Rake::FileUtilsExt
+end
+class Rake::DefaultLoader
+  def load(fn); end
+end
+class Rake::LateTime
+  def <=>(other); end
+  def self.allocate; end
+  def self.instance; end
+  def self.new(*arg0); end
+  def to_s; end
+  extend Singleton::SingletonClassMethods
+  include Comparable
+  include Singleton
+end
+class Rake::NameSpace
+  def [](name); end
+  def initialize(task_manager, scope_list); end
+  def scope; end
+  def tasks; end
+end
+module Rake::Backtrace
+  def self.collapse(backtrace); end
+end
diff --git a/sorbet/rbi/gems/rspec-core.rbi b/sorbet/rbi/gems/rspec-core.rbi
new file mode 100644
index 0000000..57d1881
--- /dev/null
+++ b/sorbet/rbi/gems/rspec-core.rbi
@@ -0,0 +1,1746 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi
+#
+# rspec-core-3.8.2
+
+module RSpec
+  def self.clear_examples; end
+  def self.configuration; end
+  def self.configuration=(arg0); end
+  def self.configure; end
+  def self.const_missing(name); end
+  def self.context(*args, &example_group_block); end
+  def self.current_example; end
+  def self.current_example=(example); end
+  def self.describe(*args, &example_group_block); end
+  def self.example_group(*args, &example_group_block); end
+  def self.fcontext(*args, &example_group_block); end
+  def self.fdescribe(*args, &example_group_block); end
+  def self.reset; end
+  def self.shared_context(name, *args, &block); end
+  def self.shared_examples(name, *args, &block); end
+  def self.shared_examples_for(name, *args, &block); end
+  def self.world; end
+  def self.world=(arg0); end
+  def self.xcontext(*args, &example_group_block); end
+  def self.xdescribe(*args, &example_group_block); end
+  extend RSpec::Core::Warnings
+end
+module RSpec::Core
+  def self.path_to_executable; end
+end
+module RSpec::Core::Version
+end
+module RSpec::Core::Warnings
+  def deprecate(deprecated, data = nil); end
+  def warn_deprecation(message, opts = nil); end
+  def warn_with(message, options = nil); end
+end
+class RSpec::Core::Set
+  def <<(key); end
+  def clear; end
+  def delete(key); end
+  def each(&block); end
+  def empty?; end
+  def include?(key); end
+  def initialize(array = nil); end
+  def merge(values); end
+  include Enumerable
+end
+module RSpec::Core::FlatMap
+  def flat_map(array, &block); end
+  def self.flat_map(array, &block); end
+end
+class RSpec::Core::FilterManager
+  def add_ids(rerun_path, scoped_ids); end
+  def add_location(file_path, line_numbers); end
+  def add_path_to_arrays_filter(filter_key, path, values); end
+  def empty?; end
+  def exclude(*args); end
+  def exclude_only(*args); end
+  def exclude_with_low_priority(*args); end
+  def exclusions; end
+  def file_scoped_include?(ex_metadata, ids, locations); end
+  def include(*args); end
+  def include_only(*args); end
+  def include_with_low_priority(*args); end
+  def inclusions; end
+  def initialize; end
+  def prune(examples); end
+  def prune_conditionally_filtered_examples(examples); end
+end
+class RSpec::Core::FilterRules
+  def [](key); end
+  def add(updated); end
+  def add_with_low_priority(updated); end
+  def clear; end
+  def delete(key); end
+  def description; end
+  def each_pair(&block); end
+  def empty?; end
+  def fetch(*args, &block); end
+  def include_example?(example); end
+  def initialize(rules = nil); end
+  def opposite; end
+  def opposite=(arg0); end
+  def rules; end
+  def self.build; end
+  def use_only(updated); end
+end
+class RSpec::Core::InclusionRules < RSpec::Core::FilterRules
+  def add(*args); end
+  def add_with_low_priority(*args); end
+  def apply_standalone_filter(updated); end
+  def include_example?(example); end
+  def is_standalone_filter?(rules); end
+  def replace_filters(new_rules); end
+  def split_file_scoped_rules; end
+  def standalone?; end
+end
+module RSpec::Core::DSL
+  def self.change_global_dsl(&changes); end
+  def self.example_group_aliases; end
+  def self.expose_example_group_alias(name); end
+  def self.expose_example_group_alias_globally(method_name); end
+  def self.expose_globally!; end
+  def self.exposed_globally?; end
+  def self.remove_globally!; end
+  def self.top_level; end
+  def self.top_level=(arg0); end
+end
+module RSpec::Core::Formatters
+  def self.register(formatter_class, *notifications); end
+end
+module RSpec::Core::Formatters::ConsoleCodes
+  def config_colors_to_methods; end
+  def console_code_for(code_or_symbol); end
+  def self.config_colors_to_methods; end
+  def self.console_code_for(code_or_symbol); end
+  def self.wrap(text, code_or_symbol); end
+  def wrap(text, code_or_symbol); end
+end
+class RSpec::Core::Formatters::SnippetExtractor
+  def beginning_line_number; end
+  def expression_lines; end
+  def expression_node; end
+  def expression_outmost_node?(node); end
+  def initialize(source, beginning_line_number, max_line_count = nil); end
+  def line_range_of_expression; end
+  def line_range_of_location_nodes_in_expression; end
+  def location_nodes_at_beginning_line; end
+  def max_line_count; end
+  def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count = nil); end
+  def self.extract_line_at(file_path, line_number); end
+  def self.least_indentation_from(lines); end
+  def self.source_from_file(path); end
+  def source; end
+  def unclosed_tokens_in_line_range(line_range); end
+end
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < StandardError
+end
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < StandardError
+end
+class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < StandardError
+end
+class RSpec::Core::Formatters::SyntaxHighlighter
+  def color_enabled_implementation; end
+  def highlight(lines); end
+  def implementation; end
+  def initialize(configuration); end
+  def self.attempt_to_add_rspec_terms_to_coderay_keywords; end
+end
+module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
+  def self.highlight_syntax(lines); end
+end
+module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+  def self.highlight_syntax(lines); end
+end
+class RSpec::Core::Formatters::ExceptionPresenter
+  def add_shared_group_lines(lines, colorizer); end
+  def backtrace_formatter; end
+  def colorized_formatted_backtrace(colorizer = nil); end
+  def colorized_message_lines(colorizer = nil); end
+  def description; end
+  def detail_formatter; end
+  def encoded_description(description); end
+  def encoded_string(string); end
+  def encoding_of(string); end
+  def example; end
+  def exception; end
+  def exception_backtrace; end
+  def exception_class_name(exception = nil); end
+  def exception_lines; end
+  def extra_detail_formatter; end
+  def extra_failure_lines; end
+  def failure_lines; end
+  def failure_slash_error_lines; end
+  def final_exception(exception, previous = nil); end
+  def find_failed_line; end
+  def formatted_backtrace(exception = nil); end
+  def formatted_cause(exception); end
+  def formatted_message_and_backtrace(colorizer); end
+  def fully_formatted(failure_number, colorizer = nil); end
+  def fully_formatted_lines(failure_number, colorizer); end
+  def indent_lines(lines, failure_number); end
+  def initialize(exception, example, options = nil); end
+  def message_color; end
+  def message_lines; end
+  def read_failed_lines; end
+end
+class RSpec::Core::Formatters::ExceptionPresenter::Factory
+  def build; end
+  def initialize(example); end
+  def multiple_exception_summarizer(exception, prior_detail_formatter, color); end
+  def multiple_exceptions_error?(exception); end
+  def options; end
+  def pending_options; end
+  def sub_failure_list_formatter(exception, message_color); end
+  def with_multiple_error_options_as_needed(exception, options); end
+end
+module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
+  def self.format_backtrace(*arg0); end
+end
+class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
+  def initialize(parent); end
+  def with_truncated_backtrace(child); end
+end
+class RSpec::Core::MultipleExceptionError < StandardError
+  def aggregation_block_label; end
+  def aggregation_metadata; end
+  def all_exceptions; end
+  def exception_count_description; end
+  def failures; end
+  def initialize(*exceptions); end
+  def message; end
+  def other_errors; end
+  def summary; end
+  include RSpec::Core::MultipleExceptionError::InterfaceTag
+end
+module RSpec::Core::MultipleExceptionError::InterfaceTag
+  def add(exception); end
+  def self.for(ex); end
+end
+module RSpec::Core::ShellEscape
+  def conditionally_quote(id); end
+  def escape(shell_command); end
+  def quote(argument); end
+  def self.conditionally_quote(id); end
+  def self.escape(shell_command); end
+  def self.quote(argument); end
+  def self.shell_allows_unquoted_ids?; end
+  def shell_allows_unquoted_ids?; end
+end
+module RSpec::Core::Formatters::Helpers
+  def self.format_duration(duration); end
+  def self.format_seconds(float, precision = nil); end
+  def self.organize_ids(ids); end
+  def self.pluralize(count, string); end
+  def self.strip_trailing_zeroes(string); end
+end
+module RSpec::Core::Notifications
+end
+module RSpec::Core::Notifications::NullColorizer
+  def self.wrap(line, _code_or_symbol); end
+  def wrap(line, _code_or_symbol); end
+end
+class RSpec::Core::Notifications::StartNotification < Struct
+  def count; end
+  def count=(_); end
+  def load_time; end
+  def load_time=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::ExampleNotification < Struct
+  def example; end
+  def example=(_); end
+  def self.[](*arg0); end
+  def self.for(example); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::ExamplesNotification
+  def examples; end
+  def failed_examples; end
+  def failure_notifications; end
+  def format_examples(examples); end
+  def fully_formatted_failed_examples(colorizer = nil); end
+  def fully_formatted_pending_examples(colorizer = nil); end
+  def initialize(reporter); end
+  def notifications; end
+  def pending_examples; end
+  def pending_notifications; end
+end
+class RSpec::Core::Notifications::FailedExampleNotification < RSpec::Core::Notifications::ExampleNotification
+  def colorized_formatted_backtrace(colorizer = nil); end
+  def colorized_message_lines(colorizer = nil); end
+  def description; end
+  def exception; end
+  def formatted_backtrace; end
+  def fully_formatted(failure_number, colorizer = nil); end
+  def fully_formatted_lines(failure_number, colorizer = nil); end
+  def initialize(example, exception_presenter = nil); end
+  def message_lines; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::PendingExampleFixedNotification < RSpec::Core::Notifications::FailedExampleNotification
+end
+class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < RSpec::Core::Notifications::FailedExampleNotification
+end
+class RSpec::Core::Notifications::SkippedExampleNotification < RSpec::Core::Notifications::ExampleNotification
+  def fully_formatted(pending_number, colorizer = nil); end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::GroupNotification < Struct
+  def group; end
+  def group=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::MessageNotification < Struct
+  def message; end
+  def message=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::SeedNotification < Struct
+  def fully_formatted; end
+  def seed; end
+  def seed=(_); end
+  def seed_used?; end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def used; end
+  def used=(_); end
+end
+class RSpec::Core::Notifications::SummaryNotification < Struct
+  def colorized_rerun_commands(colorizer = nil); end
+  def colorized_totals_line(colorizer = nil); end
+  def duplicate_rerun_locations; end
+  def duration; end
+  def duration=(_); end
+  def errors_outside_of_examples_count; end
+  def errors_outside_of_examples_count=(_); end
+  def example_count; end
+  def examples; end
+  def examples=(_); end
+  def failed_examples; end
+  def failed_examples=(_); end
+  def failure_count; end
+  def formatted_duration; end
+  def formatted_load_time; end
+  def fully_formatted(colorizer = nil); end
+  def load_time; end
+  def load_time=(_); end
+  def pending_count; end
+  def pending_examples; end
+  def pending_examples=(_); end
+  def rerun_argument_for(example); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def totals_line; end
+  include RSpec::Core::ShellEscape
+end
+class RSpec::Core::Notifications::ProfileNotification
+  def calculate_slowest_groups; end
+  def duration; end
+  def examples; end
+  def initialize(duration, examples, number_of_examples, example_groups); end
+  def number_of_examples; end
+  def percentage; end
+  def slow_duration; end
+  def slowest_examples; end
+  def slowest_groups; end
+end
+class RSpec::Core::Notifications::DeprecationNotification < Struct
+  def call_site; end
+  def call_site=(_); end
+  def deprecated; end
+  def deprecated=(_); end
+  def message; end
+  def message=(_); end
+  def replacement; end
+  def replacement=(_); end
+  def self.[](*arg0); end
+  def self.from_hash(data); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Notifications::NullNotification
+end
+class RSpec::Core::Notifications::CustomNotification < Struct
+  def self.for(options = nil); end
+end
+class RSpec::Core::Reporter
+  def abort_with(msg, exit_status); end
+  def close; end
+  def close_after; end
+  def deprecation(hash); end
+  def ensure_listeners_ready; end
+  def example_failed(example); end
+  def example_finished(example); end
+  def example_group_finished(group); end
+  def example_group_started(group); end
+  def example_passed(example); end
+  def example_pending(example); end
+  def example_started(example); end
+  def examples; end
+  def fail_fast_limit_met?; end
+  def failed_examples; end
+  def finish; end
+  def initialize(configuration); end
+  def message(message); end
+  def mute_profile_output?; end
+  def notify(event, notification); end
+  def notify_non_example_exception(exception, context_description); end
+  def pending_examples; end
+  def prepare_default(loader, output_stream, deprecation_stream); end
+  def publish(event, options = nil); end
+  def register_listener(listener, *notifications); end
+  def registered_listeners(notification); end
+  def report(expected_example_count); end
+  def seed_used?; end
+  def start(expected_example_count, time = nil); end
+  def stop; end
+end
+class RSpec::Core::NullReporter
+  def self.method_missing(*arg0); end
+end
+module RSpec::Core::Hooks
+  def after(*args, &block); end
+  def append_after(*args, &block); end
+  def append_before(*args, &block); end
+  def around(*args, &block); end
+  def before(*args, &block); end
+  def hooks; end
+  def prepend_after(*args, &block); end
+  def prepend_before(*args, &block); end
+end
+class RSpec::Core::Hooks::Hook < Struct
+  def block; end
+  def block=(_); end
+  def options; end
+  def options=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Hooks::BeforeHook < RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+class RSpec::Core::Hooks::AfterHook < RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+class RSpec::Core::Hooks::AfterContextHook < RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+class RSpec::Core::Hooks::AroundHook < RSpec::Core::Hooks::Hook
+  def execute_with(example, procsy); end
+  def hook_description; end
+end
+class RSpec::Core::Hooks::HookCollections
+  def all_hooks_for(position, scope); end
+  def ensure_hooks_initialized_for(position, scope); end
+  def extract_scope_from(args); end
+  def hooks_for(position, scope); end
+  def initialize(owner, filterable_item_repo_class); end
+  def known_scope?(scope); end
+  def matching_hooks_for(position, scope, example_or_group); end
+  def normalized_scope_for(scope); end
+  def owner_parent_groups; end
+  def process(host, parent_groups, globals, position, scope); end
+  def processable_hooks_for(position, scope, host); end
+  def register(prepend_or_append, position, *args, &block); end
+  def register_global_singleton_context_hooks(example, globals); end
+  def register_globals(host, globals); end
+  def run(position, scope, example_or_group); end
+  def run_around_example_hooks_for(example); end
+  def run_example_hooks_for(example, position, each_method); end
+  def run_owned_hooks_for(position, scope, example_or_group); end
+  def scope_and_options_from(*args); end
+end
+module RSpec::Core::MemoizedHelpers
+  def __init_memoized; end
+  def __memoized; end
+  def initialize(*arg0); end
+  def is_expected; end
+  def self.define_helpers_on(example_group); end
+  def self.get_constant_or_yield(example_group, name); end
+  def self.module_for(example_group); end
+  def should(matcher = nil, message = nil); end
+  def should_not(matcher = nil, message = nil); end
+  def subject; end
+end
+class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
+  def fetch_or_store(key); end
+  def initialize; end
+end
+class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
+  def fetch_or_store(key); end
+  def initialize; end
+end
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  def self.fetch_or_store(key, &_block); end
+  def self.isolate_for_context_hook(example_group_instance); end
+end
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  def self.article; end
+  def self.hook_expression; end
+  def self.hook_intention; end
+end
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  def self.article; end
+  def self.hook_expression; end
+  def self.hook_intention; end
+end
+module RSpec::Core::MemoizedHelpers::ClassMethods
+  def let!(name, &block); end
+  def let(name, &block); end
+  def subject!(name = nil, &block); end
+  def subject(name = nil, &block); end
+end
+module RSpec::Core::Metadata
+  def self.ascend(metadata); end
+  def self.ascending(metadata); end
+  def self.build_hash_from(args, warn_about_example_group_filtering = nil); end
+  def self.deep_hash_dup(object); end
+  def self.id_from(metadata); end
+  def self.location_tuple_from(metadata); end
+  def self.relative_path(line); end
+  def self.relative_path_regex; end
+end
+class RSpec::Core::Metadata::HashPopulator
+  def block; end
+  def build_description_from(parent_description = nil, my_description = nil); end
+  def build_scoped_id_for(file_path); end
+  def description_args; end
+  def description_separator(parent_part, child_part); end
+  def ensure_valid_user_keys; end
+  def file_path_and_line_number_from(backtrace); end
+  def initialize(metadata, user_metadata, index_provider, description_args, block); end
+  def metadata; end
+  def populate; end
+  def populate_location_attributes; end
+  def user_metadata; end
+end
+class RSpec::Core::Metadata::ExampleHash < RSpec::Core::Metadata::HashPopulator
+  def described_class; end
+  def full_description; end
+  def self.create(group_metadata, user_metadata, index_provider, description, block); end
+end
+class RSpec::Core::Metadata::ExampleGroupHash < RSpec::Core::Metadata::HashPopulator
+  def described_class; end
+  def full_description; end
+  def self.backwards_compatibility_default_proc(&example_group_selector); end
+  def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
+  def self.hash_with_backwards_compatibility_default_proc; end
+end
+module RSpec::Core::HashImitatable
+  def <(*args, &block); end
+  def <=(*args, &block); end
+  def >(*args, &block); end
+  def >=(*args, &block); end
+  def [](key); end
+  def []=(key, value); end
+  def all?(*args, &block); end
+  def any?(*args, &block); end
+  def assert_valid_keys(*args, &block); end
+  def assoc(*args, &block); end
+  def chain(*args, &block); end
+  def chunk(*args, &block); end
+  def chunk_while(*args, &block); end
+  def clear(*args, &block); end
+  def collect(*args, &block); end
+  def collect_concat(*args, &block); end
+  def compact!(*args, &block); end
+  def compact(*args, &block); end
+  def compare_by_identity(*args, &block); end
+  def compare_by_identity?(*args, &block); end
+  def count(*args, &block); end
+  def cycle(*args, &block); end
+  def deep_merge!(*args, &block); end
+  def deep_merge(*args, &block); end
+  def deep_stringify_keys!(*args, &block); end
+  def deep_stringify_keys(*args, &block); end
+  def deep_symbolize_keys!(*args, &block); end
+  def deep_symbolize_keys(*args, &block); end
+  def deep_transform_keys!(*args, &block); end
+  def deep_transform_keys(*args, &block); end
+  def default(*args, &block); end
+  def default=(*args, &block); end
+  def default_proc(*args, &block); end
+  def default_proc=(*args, &block); end
+  def delete(*args, &block); end
+  def delete_if(*args, &block); end
+  def detect(*args, &block); end
+  def dig(*args, &block); end
+  def directly_supports_attribute?(name); end
+  def drop(*args, &block); end
+  def drop_while(*args, &block); end
+  def each(*args, &block); end
+  def each_cons(*args, &block); end
+  def each_entry(*args, &block); end
+  def each_key(*args, &block); end
+  def each_pair(*args, &block); end
+  def each_slice(*args, &block); end
+  def each_value(*args, &block); end
+  def each_with_index(*args, &block); end
+  def each_with_object(*args, &block); end
+  def empty?(*args, &block); end
+  def entries(*args, &block); end
+  def except!(*args, &block); end
+  def except(*args, &block); end
+  def extra_hash_attributes; end
+  def extract!(*args, &block); end
+  def extractable_options?(*args, &block); end
+  def fetch(*args, &block); end
+  def fetch_values(*args, &block); end
+  def filter!(*args, &block); end
+  def filter(*args, &block); end
+  def find(*args, &block); end
+  def find_all(*args, &block); end
+  def find_index(*args, &block); end
+  def first(*args, &block); end
+  def flat_map(*args, &block); end
+  def flatten(*args, &block); end
+  def get_value(name); end
+  def grep(*args, &block); end
+  def grep_v(*args, &block); end
+  def group_by(*args, &block); end
+  def has_key?(*args, &block); end
+  def has_value?(*args, &block); end
+  def hash_for_delegation; end
+  def include?(*args, &block); end
+  def index(*args, &block); end
+  def inject(*args, &block); end
+  def invert(*args, &block); end
+  def issue_deprecation(_method_name, *_args); end
+  def keep_if(*args, &block); end
+  def key(*args, &block); end
+  def key?(*args, &block); end
+  def keys(*args, &block); end
+  def lazy(*args, &block); end
+  def length(*args, &block); end
+  def map(*args, &block); end
+  def max(*args, &block); end
+  def max_by(*args, &block); end
+  def member?(*args, &block); end
+  def merge!(*args, &block); end
+  def merge(*args, &block); end
+  def min(*args, &block); end
+  def min_by(*args, &block); end
+  def minmax(*args, &block); end
+  def minmax_by(*args, &block); end
+  def none?(*args, &block); end
+  def one?(*args, &block); end
+  def partition(*args, &block); end
+  def rassoc(*args, &block); end
+  def reduce(*args, &block); end
+  def rehash(*args, &block); end
+  def reject!(*args, &block); end
+  def reject(*args, &block); end
+  def replace(*args, &block); end
+  def reverse_each(*args, &block); end
+  def select!(*args, &block); end
+  def select(*args, &block); end
+  def self.included(klass); end
+  def set_value(name, value); end
+  def shift(*args, &block); end
+  def size(*args, &block); end
+  def slice!(*args, &block); end
+  def slice(*args, &block); end
+  def slice_after(*args, &block); end
+  def slice_before(*args, &block); end
+  def slice_when(*args, &block); end
+  def sort(*args, &block); end
+  def sort_by(*args, &block); end
+  def store(*args, &block); end
+  def stringify_keys!(*args, &block); end
+  def stringify_keys(*args, &block); end
+  def sum(*args, &block); end
+  def symbolize_keys!(*args, &block); end
+  def symbolize_keys(*args, &block); end
+  def take(*args, &block); end
+  def take_while(*args, &block); end
+  def to_a(*args, &block); end
+  def to_h; end
+  def to_hash(*args, &block); end
+  def to_options!(*args, &block); end
+  def to_options(*args, &block); end
+  def to_proc(*args, &block); end
+  def to_set(*args, &block); end
+  def transform_keys!(*args, &block); end
+  def transform_keys(*args, &block); end
+  def transform_values!(*args, &block); end
+  def transform_values(*args, &block); end
+  def uniq(*args, &block); end
+  def update(*args, &block); end
+  def value?(*args, &block); end
+  def values(*args, &block); end
+  def values_at(*args, &block); end
+  def zip(*args, &block); end
+end
+module RSpec::Core::HashImitatable::ClassMethods
+  def attr_accessor(*names); end
+  def hash_attribute_names; end
+end
+class RSpec::Core::LegacyExampleGroupHash
+  def directly_supports_attribute?(name); end
+  def get_value(name); end
+  def initialize(metadata); end
+  def set_value(name, value); end
+  def to_h; end
+  extend RSpec::Core::HashImitatable::ClassMethods
+  include RSpec::Core::HashImitatable
+end
+module RSpec::Core::MetadataFilter
+  def self.apply?(predicate, filters, metadata); end
+  def self.filter_applies?(key, filter_value, metadata); end
+  def self.filter_applies_to_any_value?(key, value, metadata); end
+  def self.filters_apply?(key, value, metadata); end
+  def self.id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
+  def self.location_filter_applies?(locations, metadata); end
+  def self.proc_filter_applies?(key, proc, metadata); end
+  def self.silence_metadata_example_group_deprecations; end
+end
+module RSpec::Core::FilterableItemRepository
+end
+class RSpec::Core::FilterableItemRepository::UpdateOptimized
+  def append(item, metadata); end
+  def delete(item, metadata); end
+  def initialize(applies_predicate); end
+  def items_and_filters; end
+  def items_for(request_meta); end
+  def prepend(item, metadata); end
+end
+class RSpec::Core::FilterableItemRepository::QueryOptimized < RSpec::Core::FilterableItemRepository::UpdateOptimized
+  def append(item, metadata); end
+  def applicable_metadata_from(metadata); end
+  def delete(item, metadata); end
+  def find_items_for(request_meta); end
+  def handle_mutation(metadata); end
+  def initialize(applies_predicate); end
+  def items_for(metadata); end
+  def prepend(item, metadata); end
+  def proc_keys_from(metadata); end
+  def reconstruct_caches; end
+end
+module RSpec::Core::Pending
+  def pending(message = nil); end
+  def self.mark_fixed!(example); end
+  def self.mark_pending!(example, message_or_bool); end
+  def self.mark_skipped!(example, message_or_bool); end
+  def skip(message = nil); end
+end
+class RSpec::Core::Pending::SkipDeclaredInExample < StandardError
+  def argument; end
+  def initialize(argument); end
+end
+class RSpec::Core::Pending::PendingExampleFixedError < StandardError
+end
+class RSpec::Core::Formatters::Loader
+  def add(formatter_to_use, *paths); end
+  def built_in_formatter(key); end
+  def custom_formatter(formatter_ref); end
+  def default_formatter; end
+  def default_formatter=(arg0); end
+  def duplicate_formatter_exists?(new_formatter); end
+  def existing_formatter_implements?(notification); end
+  def find_formatter(formatter_to_use); end
+  def formatters; end
+  def initialize(reporter); end
+  def notifications_for(formatter_class); end
+  def open_stream(path_or_wrapper); end
+  def path_for(const_ref); end
+  def prepare_default(output_stream, deprecation_stream); end
+  def register(formatter, notifications); end
+  def reporter; end
+  def self.formatters; end
+  def setup_default(output_stream, deprecation_stream); end
+  def string_const?(str); end
+  def underscore(camel_cased_word); end
+  def underscore_with_fix_for_non_standard_rspec_naming(string); end
+end
+module RSpec::Core::Ordering
+end
+class RSpec::Core::Ordering::Identity
+  def order(items); end
+end
+class RSpec::Core::Ordering::Random
+  def initialize(configuration); end
+  def jenkins_hash_digest(string); end
+  def order(items); end
+  def used?; end
+end
+class RSpec::Core::Ordering::Custom
+  def initialize(callable); end
+  def order(list); end
+end
+class RSpec::Core::Ordering::Registry
+  def fetch(name, &fallback); end
+  def initialize(configuration); end
+  def register(sym, strategy); end
+  def used_random_seed?; end
+end
+class RSpec::Core::Ordering::ConfigurationManager
+  def force(hash); end
+  def initialize; end
+  def order=(type); end
+  def ordering_registry; end
+  def register_ordering(name, strategy = nil); end
+  def seed; end
+  def seed=(seed); end
+  def seed_used?; end
+end
+class RSpec::Core::World
+  def all_example_groups; end
+  def all_examples; end
+  def announce_exclusion_filter(announcements); end
+  def announce_filters; end
+  def announce_inclusion_filter(announcements); end
+  def descending_declaration_line_numbers_by_file; end
+  def everything_filtered_message; end
+  def example_count(groups = nil); end
+  def example_groups; end
+  def exclusion_filter; end
+  def fail_if_config_and_cli_options_invalid; end
+  def filter_manager; end
+  def filtered_examples; end
+  def inclusion_filter; end
+  def initialize(configuration = nil); end
+  def non_example_failure; end
+  def non_example_failure=(arg0); end
+  def num_example_groups_defined_in(file); end
+  def ordered_example_groups; end
+  def preceding_declaration_line(absolute_file_name, filter_line); end
+  def prepare_example_filtering; end
+  def record(example_group); end
+  def registered_example_group_files; end
+  def report_filter_message(message); end
+  def reporter; end
+  def reset; end
+  def shared_example_group_registry; end
+  def source_from_file(path); end
+  def syntax_highlighter; end
+  def traverse_example_group_trees_until(&block); end
+  def wants_to_quit; end
+  def wants_to_quit=(arg0); end
+end
+module RSpec::Core::World::Null
+  def self.all_example_groups; end
+  def self.example_groups; end
+  def self.non_example_failure; end
+  def self.non_example_failure=(_); end
+  def self.registered_example_group_files; end
+  def self.traverse_example_group_trees_until; end
+end
+class RSpec::Core::BacktraceFormatter
+  def backtrace_line(line); end
+  def exclude?(line); end
+  def exclusion_patterns; end
+  def exclusion_patterns=(arg0); end
+  def filter_gem(gem_name); end
+  def format_backtrace(backtrace, options = nil); end
+  def full_backtrace=(arg0); end
+  def full_backtrace?; end
+  def inclusion_patterns; end
+  def inclusion_patterns=(arg0); end
+  def initialize; end
+  def matches?(patterns, line); end
+end
+module RSpec::Core::RubyProject
+  def add_dir_to_load_path(dir); end
+  def add_to_load_path(*dirs); end
+  def ascend_until; end
+  def determine_root; end
+  def find_first_parent_containing(dir); end
+  def root; end
+  def self.add_dir_to_load_path(dir); end
+  def self.add_to_load_path(*dirs); end
+  def self.ascend_until; end
+  def self.determine_root; end
+  def self.find_first_parent_containing(dir); end
+  def self.root; end
+end
+class RSpec::Core::Formatters::DeprecationFormatter
+  def count; end
+  def deprecation(notification); end
+  def deprecation_message_for(data); end
+  def deprecation_stream; end
+  def deprecation_summary(_notification); end
+  def initialize(deprecation_stream, summary_stream); end
+  def output; end
+  def printer; end
+  def summary_stream; end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < Struct
+  def deprecation_type_for(data); end
+  def initialize(data); end
+  def output_formatted(str); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def to_s; end
+  def too_many_warnings_message; end
+  def type; end
+  def type=(_); end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < Struct
+  def initialize(data); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def to_s; end
+  def too_many_warnings_message; end
+  def type; end
+  def type=(_); end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
+  def deprecation_formatter; end
+  def deprecation_stream; end
+  def deprecation_summary; end
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+  def print_deprecation_message(data); end
+  def summary_stream; end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
+  def deprecation_formatter; end
+  def deprecation_stream; end
+  def deprecation_summary; end
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+  def print_deferred_deprecation_warnings; end
+  def print_deprecation_message(data); end
+  def stash_deprecation_message(deprecation_message); end
+  def summary_stream; end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
+  def puts(message); end
+  def summarize(summary_stream, deprecation_count); end
+end
+class RSpec::Core::Formatters::DeprecationFormatter::FileStream
+  def initialize(file); end
+  def puts(*args); end
+  def summarize(summary_stream, deprecation_count); end
+end
+class RSpec::Core::DeprecationError < StandardError
+end
+class RSpec::Core::OutputWrapper
+  def <<(*args, &block); end
+  def advise(*args, &block); end
+  def as_json(*args, &block); end
+  def autoclose=(*args, &block); end
+  def autoclose?(*args, &block); end
+  def binmode(*args, &block); end
+  def binmode?(*args, &block); end
+  def bytes(*args, &block); end
+  def chars(*args, &block); end
+  def close(*args, &block); end
+  def close_on_exec=(*args, &block); end
+  def close_on_exec?(*args, &block); end
+  def close_read(*args, &block); end
+  def close_write(*args, &block); end
+  def closed?(*args, &block); end
+  def codepoints(*args, &block); end
+  def each(*args, &block); end
+  def each_byte(*args, &block); end
+  def each_char(*args, &block); end
+  def each_codepoint(*args, &block); end
+  def each_line(*args, &block); end
+  def eof(*args, &block); end
+  def eof?(*args, &block); end
+  def external_encoding(*args, &block); end
+  def fcntl(*args, &block); end
+  def fdatasync(*args, &block); end
+  def fileno(*args, &block); end
+  def flush(*args, &block); end
+  def fsync(*args, &block); end
+  def getbyte(*args, &block); end
+  def getc(*args, &block); end
+  def gets(*args, &block); end
+  def initialize(output); end
+  def inspect(*args, &block); end
+  def internal_encoding(*args, &block); end
+  def ioctl(*args, &block); end
+  def isatty(*args, &block); end
+  def lineno(*args, &block); end
+  def lineno=(*args, &block); end
+  def lines(*args, &block); end
+  def method_missing(name, *args, &block); end
+  def output; end
+  def output=(arg0); end
+  def pathconf(*args, &block); end
+  def pid(*args, &block); end
+  def pos(*args, &block); end
+  def pos=(*args, &block); end
+  def pread(*args, &block); end
+  def print(*args, &block); end
+  def printf(*args, &block); end
+  def putc(*args, &block); end
+  def puts(*args, &block); end
+  def pwrite(*args, &block); end
+  def read(*args, &block); end
+  def read_nonblock(*args, &block); end
+  def readbyte(*args, &block); end
+  def readchar(*args, &block); end
+  def readline(*args, &block); end
+  def readlines(*args, &block); end
+  def readpartial(*args, &block); end
+  def reopen(*args, &block); end
+  def respond_to?(name, priv = nil); end
+  def rewind(*args, &block); end
+  def seek(*args, &block); end
+  def set_encoding(*args, &block); end
+  def stat(*args, &block); end
+  def sync(*args, &block); end
+  def sync=(*args, &block); end
+  def sysread(*args, &block); end
+  def sysseek(*args, &block); end
+  def syswrite(*args, &block); end
+  def tell(*args, &block); end
+  def to_i(*args, &block); end
+  def to_io(*args, &block); end
+  def tty?(*args, &block); end
+  def ungetbyte(*args, &block); end
+  def ungetc(*args, &block); end
+  def write(*args, &block); end
+  def write_nonblock(*args, &block); end
+end
+class RSpec::Core::Configuration
+  def absolute_pattern?(pattern); end
+  def add_formatter(formatter, output = nil); end
+  def add_hook_to_existing_matching_groups(meta, scope, &block); end
+  def add_setting(name, opts = nil); end
+  def after(scope = nil, *meta, &block); end
+  def alias_example_group_to(new_name, *args); end
+  def alias_example_to(name, *args); end
+  def alias_it_behaves_like_to(new_name, report_label = nil); end
+  def alias_it_should_behave_like_to(new_name, report_label = nil); end
+  def append_after(scope = nil, *meta, &block); end
+  def append_before(scope = nil, *meta, &block); end
+  def apply_derived_metadata_to(metadata); end
+  def around(scope = nil, *meta, &block); end
+  def assert_no_example_groups_defined(config_option); end
+  def backtrace_exclusion_patterns; end
+  def backtrace_exclusion_patterns=(patterns); end
+  def backtrace_formatter; end
+  def backtrace_inclusion_patterns; end
+  def backtrace_inclusion_patterns=(patterns); end
+  def before(scope = nil, *meta, &block); end
+  def bisect_runner; end
+  def bisect_runner=(value); end
+  def bisect_runner_class; end
+  def clear_values_derived_from_example_status_persistence_file_path; end
+  def color; end
+  def color=(arg0); end
+  def color_enabled?(output = nil); end
+  def color_mode; end
+  def color_mode=(arg0); end
+  def command; end
+  def conditionally_disable_expectations_monkey_patching; end
+  def conditionally_disable_mocks_monkey_patching; end
+  def configure_example(example, example_hooks); end
+  def configure_expectation_framework; end
+  def configure_group(group); end
+  def configure_group_with(group, module_list, application_method); end
+  def configure_mock_framework; end
+  def default_color; end
+  def default_color=(arg0); end
+  def default_color?; end
+  def default_formatter; end
+  def default_formatter=(value); end
+  def default_path; end
+  def default_path=(path); end
+  def default_path?; end
+  def define_built_in_hooks; end
+  def define_derived_metadata(*filters, &block); end
+  def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end
+  def deprecation_stream; end
+  def deprecation_stream=(value); end
+  def detail_color; end
+  def detail_color=(arg0); end
+  def detail_color?; end
+  def disable_monkey_patching!; end
+  def disable_monkey_patching; end
+  def disable_monkey_patching=(arg0); end
+  def drb; end
+  def drb=(arg0); end
+  def drb?; end
+  def drb_port; end
+  def drb_port=(arg0); end
+  def drb_port?; end
+  def dry_run; end
+  def dry_run=(arg0); end
+  def dry_run?; end
+  def error_stream; end
+  def error_stream=(arg0); end
+  def error_stream?; end
+  def example_status_persistence_file_path; end
+  def example_status_persistence_file_path=(value); end
+  def exclude_pattern; end
+  def exclude_pattern=(value); end
+  def exclusion_filter; end
+  def exclusion_filter=(filter); end
+  def expect_with(*frameworks); end
+  def expectation_framework=(framework); end
+  def expectation_frameworks; end
+  def expose_current_running_example_as(method_name); end
+  def expose_dsl_globally=(value); end
+  def expose_dsl_globally?; end
+  def extend(mod, *filters); end
+  def extract_location(path); end
+  def fail_fast; end
+  def fail_fast=(arg0); end
+  def fail_fast?; end
+  def fail_if_no_examples; end
+  def fail_if_no_examples=(arg0); end
+  def fail_if_no_examples?; end
+  def failure_color; end
+  def failure_color=(arg0); end
+  def failure_color?; end
+  def failure_exit_code; end
+  def failure_exit_code=(arg0); end
+  def failure_exit_code?; end
+  def file_glob_from(path, pattern); end
+  def files_or_directories_to_run=(*files); end
+  def files_to_run; end
+  def files_to_run=(arg0); end
+  def filter; end
+  def filter=(filter); end
+  def filter_gems_from_backtrace(*gem_names); end
+  def filter_manager; end
+  def filter_manager=(arg0); end
+  def filter_run(*args); end
+  def filter_run_excluding(*args); end
+  def filter_run_including(*args); end
+  def filter_run_when_matching(*args); end
+  def fixed_color; end
+  def fixed_color=(arg0); end
+  def fixed_color?; end
+  def force(hash); end
+  def format_docstrings(&block); end
+  def format_docstrings_block; end
+  def formatter=(formatter, output = nil); end
+  def formatter_loader; end
+  def formatters; end
+  def full_backtrace=(true_or_false); end
+  def full_backtrace?; end
+  def full_description; end
+  def full_description=(description); end
+  def gather_directories(path); end
+  def get_files_to_run(paths); end
+  def get_matching_files(path, pattern); end
+  def handle_suite_hook(scope, meta); end
+  def hooks; end
+  def in_project_source_dir_regex; end
+  def include(mod, *filters); end
+  def include_context(shared_group_name, *filters); end
+  def inclusion_filter; end
+  def inclusion_filter=(filter); end
+  def initialize; end
+  def last_run_statuses; end
+  def libs; end
+  def libs=(libs); end
+  def load_file_handling_errors(method, file); end
+  def load_spec_files; end
+  def loaded_spec_files; end
+  def max_displayed_failure_line_count; end
+  def max_displayed_failure_line_count=(arg0); end
+  def max_displayed_failure_line_count?; end
+  def metadata_applies_to_group?(meta, group); end
+  def mock_framework; end
+  def mock_framework=(framework); end
+  def mock_with(framework); end
+  def on_example_group_definition(&block); end
+  def on_example_group_definition_callbacks; end
+  def on_existing_matching_groups(meta); end
+  def only_failures; end
+  def only_failures?; end
+  def only_failures_but_not_configured?; end
+  def order=(*args, &block); end
+  def ordering_manager; end
+  def ordering_registry(*args, &block); end
+  def output_stream; end
+  def output_stream=(value); end
+  def output_to_tty?(output = nil); end
+  def output_wrapper; end
+  def paths_to_check(paths); end
+  def pattern; end
+  def pattern=(value); end
+  def pattern_might_load_specs_from_vendored_dirs?; end
+  def pending_color; end
+  def pending_color=(arg0); end
+  def pending_color?; end
+  def prepend(mod, *filters); end
+  def prepend_after(scope = nil, *meta, &block); end
+  def prepend_before(scope = nil, *meta, &block); end
+  def profile_examples; end
+  def profile_examples=(arg0); end
+  def profile_examples?; end
+  def project_source_dirs; end
+  def project_source_dirs=(arg0); end
+  def project_source_dirs?; end
+  def raise_errors_for_deprecations!; end
+  def raise_on_warning=(value); end
+  def register_ordering(*args, &block); end
+  def reporter; end
+  def requires; end
+  def requires=(paths); end
+  def reset; end
+  def reset_filters; end
+  def reset_reporter; end
+  def rspec_expectations_loaded?; end
+  def rspec_mocks_loaded?; end
+  def run_all_when_everything_filtered; end
+  def run_all_when_everything_filtered=(arg0); end
+  def run_all_when_everything_filtered?; end
+  def run_suite_hooks(hook_description, hooks); end
+  def safe_extend(mod, host); end
+  def safe_include(mod, host); end
+  def safe_prepend(mod, host); end
+  def seed(*args, &block); end
+  def seed=(*args, &block); end
+  def seed_used?(*args, &block); end
+  def self.add_read_only_setting(name, opts = nil); end
+  def self.add_setting(name, opts = nil); end
+  def self.define_aliases(name, alias_name); end
+  def self.define_predicate_for(*names); end
+  def self.define_reader(name); end
+  def self.delegate_to_ordering_manager(*methods); end
+  def shared_context_metadata_behavior; end
+  def shared_context_metadata_behavior=(value); end
+  def silence_filter_announcements; end
+  def silence_filter_announcements=(arg0); end
+  def silence_filter_announcements?; end
+  def spec_files_with_failures; end
+  def start_time; end
+  def start_time=(arg0); end
+  def start_time?; end
+  def static_config_filter_manager; end
+  def static_config_filter_manager=(arg0); end
+  def success_color; end
+  def success_color=(arg0); end
+  def success_color?; end
+  def threadsafe; end
+  def threadsafe=(arg0); end
+  def threadsafe?; end
+  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
+  def tty; end
+  def tty=(arg0); end
+  def tty?; end
+  def update_pattern_attr(name, value); end
+  def value_for(key); end
+  def warnings=(value); end
+  def warnings?; end
+  def when_first_matching_example_defined(*filters); end
+  def with_suite_hooks; end
+  def world; end
+  def world=(arg0); end
+  include RSpec::Core::Configuration::Readers
+  include RSpec::Core::Hooks
+end
+module RSpec::Core::Configuration::Readers
+  def default_color; end
+  def default_path; end
+  def deprecation_stream; end
+  def detail_color; end
+  def drb; end
+  def drb_port; end
+  def dry_run; end
+  def error_stream; end
+  def example_status_persistence_file_path; end
+  def exclude_pattern; end
+  def fail_fast; end
+  def fail_if_no_examples; end
+  def failure_color; end
+  def failure_exit_code; end
+  def fixed_color; end
+  def libs; end
+  def max_displayed_failure_line_count; end
+  def only_failures; end
+  def output_stream; end
+  def pattern; end
+  def pending_color; end
+  def profile_examples; end
+  def project_source_dirs; end
+  def requires; end
+  def run_all_when_everything_filtered; end
+  def shared_context_metadata_behavior; end
+  def silence_filter_announcements; end
+  def start_time; end
+  def success_color; end
+  def threadsafe; end
+  def tty; end
+end
+class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < StandardError
+end
+class RSpec::Core::Configuration::DeprecationReporterBuffer
+  def deprecation(*args); end
+  def initialize; end
+  def play_onto(reporter); end
+end
+module RSpec::Core::Configuration::ExposeCurrentExample
+end
+class RSpec::Core::Parser
+  def add_tag_filter(options, filter_type, tag_name, value = nil); end
+  def configure_only_failures(options); end
+  def initialize(original_args); end
+  def original_args; end
+  def parse(source = nil); end
+  def parser(options); end
+  def self.parse(args, source = nil); end
+  def set_fail_fast(options, value); end
+end
+class RSpec::Core::ConfigurationOptions
+  def args; end
+  def args_from_options_file(path); end
+  def command_line_options; end
+  def configure(config); end
+  def configure_filter_manager(filter_manager); end
+  def custom_options; end
+  def custom_options_file; end
+  def env_options; end
+  def file_options; end
+  def force?(key); end
+  def global_options; end
+  def global_options_file; end
+  def home_options_file_path; end
+  def initialize(args); end
+  def load_formatters_into(config); end
+  def local_options; end
+  def local_options_file; end
+  def options; end
+  def options_file_as_erb_string(path); end
+  def options_from(path); end
+  def order(keys); end
+  def organize_options; end
+  def parse_args_ignoring_files_or_dirs_to_run(args, source); end
+  def process_options_into(config); end
+  def project_options; end
+  def project_options_file; end
+  def resolve_xdg_config_home; end
+  def xdg_options_file_if_exists; end
+  def xdg_options_file_path; end
+end
+class RSpec::Core::Runner
+  def configuration; end
+  def configure(err, out); end
+  def initialize(options, configuration = nil, world = nil); end
+  def options; end
+  def persist_example_statuses; end
+  def run(err, out); end
+  def run_specs(example_groups); end
+  def self.autorun; end
+  def self.autorun_disabled?; end
+  def self.disable_autorun!; end
+  def self.handle_interrupt; end
+  def self.installed_at_exit?; end
+  def self.invoke; end
+  def self.perform_at_exit; end
+  def self.run(args, err = nil, out = nil); end
+  def self.running_in_drb?; end
+  def self.trap_interrupt; end
+  def setup(err, out); end
+  def world; end
+end
+module RSpec::Core::Invocations
+end
+class RSpec::Core::Invocations::InitializeProject
+  def call(*_args); end
+end
+class RSpec::Core::Invocations::DRbWithFallback
+  def call(options, err, out); end
+end
+class RSpec::Core::Invocations::Bisect
+  def bisect_formatter_klass_for(argument); end
+  def call(options, err, out); end
+end
+class RSpec::Core::Invocations::PrintVersion
+  def call(_options, _err, out); end
+end
+class RSpec::Core::Invocations::PrintHelp < Struct
+  def call(_options, _err, out); end
+  def hidden_options; end
+  def hidden_options=(_); end
+  def parser; end
+  def parser=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::Example
+  def assign_generated_description; end
+  def clock; end
+  def clock=(arg0); end
+  def description; end
+  def display_exception; end
+  def display_exception=(ex); end
+  def duplicate_with(metadata_overrides = nil); end
+  def example_group; end
+  def example_group_instance; end
+  def exception; end
+  def execution_result; end
+  def fail_with_exception(reporter, exception); end
+  def file_path; end
+  def finish(reporter); end
+  def full_description; end
+  def generate_description; end
+  def hooks; end
+  def id; end
+  def initialize(example_group_class, description, user_metadata, example_block = nil); end
+  def inspect; end
+  def inspect_output; end
+  def instance_exec(*args, &block); end
+  def location; end
+  def location_description; end
+  def location_rerun_argument; end
+  def metadata; end
+  def mocks_need_verification?; end
+  def pending; end
+  def pending?; end
+  def record_finished(status, reporter); end
+  def reporter; end
+  def rerun_argument; end
+  def run(example_group_instance, reporter); end
+  def run_after_example; end
+  def run_before_example; end
+  def self.delegate_to_metadata(key); end
+  def self.parse_id(id); end
+  def set_aggregate_failures_exception(exception); end
+  def set_exception(exception); end
+  def skip; end
+  def skip_with_exception(reporter, exception); end
+  def skipped?; end
+  def start(reporter); end
+  def to_s; end
+  def update_inherited_metadata(updates); end
+  def verify_mocks; end
+  def with_around_and_singleton_context_hooks; end
+  def with_around_example_hooks; end
+end
+class RSpec::Core::Example::Procsy
+  def <<(*a, &b); end
+  def ===(*a, &b); end
+  def >>(*a, &b); end
+  def [](*a, &b); end
+  def arity(*a, &b); end
+  def binding(*a, &b); end
+  def call(*args, &block); end
+  def clock(*a, &b); end
+  def clock=(*a, &b); end
+  def clone(*a, &b); end
+  def curry(*a, &b); end
+  def description(*a, &b); end
+  def dup(*a, &b); end
+  def duplicate_with(*a, &b); end
+  def example; end
+  def example_group(*a, &b); end
+  def example_group_instance(*a, &b); end
+  def exception(*a, &b); end
+  def executed?; end
+  def execution_result(*a, &b); end
+  def file_path(*a, &b); end
+  def full_description(*a, &b); end
+  def hash(*a, &b); end
+  def id(*a, &b); end
+  def initialize(example, &block); end
+  def inspect; end
+  def inspect_output(*a, &b); end
+  def lambda?(*a, &b); end
+  def location(*a, &b); end
+  def location_rerun_argument(*a, &b); end
+  def metadata(*a, &b); end
+  def parameters(*a, &b); end
+  def pending(*a, &b); end
+  def pending?(*a, &b); end
+  def reporter(*a, &b); end
+  def rerun_argument(*a, &b); end
+  def run(*args, &block); end
+  def skip(*a, &b); end
+  def skipped?(*a, &b); end
+  def source_location(*a, &b); end
+  def to_proc; end
+  def update_inherited_metadata(*a, &b); end
+  def wrap(&block); end
+  def yield(*a, &b); end
+end
+class RSpec::Core::Example::ExecutionResult
+  def calculate_run_time(finished_at); end
+  def ensure_timing_set(clock); end
+  def example_skipped?; end
+  def exception; end
+  def exception=(arg0); end
+  def finished_at; end
+  def finished_at=(arg0); end
+  def get_value(name); end
+  def hash_for_delegation; end
+  def issue_deprecation(_method_name, *_args); end
+  def pending_exception; end
+  def pending_exception=(arg0); end
+  def pending_fixed; end
+  def pending_fixed=(arg0); end
+  def pending_fixed?; end
+  def pending_message; end
+  def pending_message=(arg0); end
+  def record_finished(status, finished_at); end
+  def run_time; end
+  def run_time=(arg0); end
+  def set_value(name, value); end
+  def started_at; end
+  def started_at=(arg0); end
+  def status; end
+  def status=(arg0); end
+  extend RSpec::Core::HashImitatable::ClassMethods
+  include RSpec::Core::HashImitatable
+end
+class RSpec::Core::SuiteHookContext < RSpec::Core::Example
+  def initialize(hook_description, reporter); end
+  def set_exception(exception); end
+end
+class RSpec::Core::SharedExampleGroupModule < Module
+  def definition; end
+  def include_in(klass, inclusion_line, args, customization_block); end
+  def included(klass); end
+  def initialize(description, definition, metadata); end
+  def inspect; end
+  def to_s; end
+end
+module RSpec::Core::SharedExampleGroup
+  def shared_context(name, *args, &block); end
+  def shared_examples(name, *args, &block); end
+  def shared_examples_for(name, *args, &block); end
+end
+module RSpec::Core::SharedExampleGroup::TopLevelDSL
+  def self.definitions; end
+  def self.expose_globally!; end
+  def self.exposed_globally?; end
+  def self.remove_globally!; end
+end
+class RSpec::Core::SharedExampleGroup::Registry
+  def add(context, name, *metadata_args, &block); end
+  def ensure_block_has_source_location(_block); end
+  def find(lookup_contexts, name); end
+  def formatted_location(block); end
+  def legacy_add(context, name, *metadata_args, &block); end
+  def shared_example_groups; end
+  def valid_name?(candidate); end
+  def warn_if_key_taken(context, key, new_block); end
+end
+class RSpec::Core::ExampleGroup
+  def described_class; end
+  def initialize(inspect_output = nil); end
+  def inspect; end
+  def method_missing(name, *args); end
+  def self.add_example(example); end
+  def self.before_context_ivars; end
+  def self.children; end
+  def self.context(*args, &example_group_block); end
+  def self.currently_executing_a_context_hook?; end
+  def self.declaration_locations; end
+  def self.define_example_group_method(name, metadata = nil); end
+  def self.define_example_method(name, extra_options = nil); end
+  def self.define_nested_shared_group_method(new_name, report_label = nil); end
+  def self.delegate_to_metadata(*names); end
+  def self.descendant_filtered_examples; end
+  def self.descendants; end
+  def self.describe(*args, &example_group_block); end
+  def self.described_class; end
+  def self.description; end
+  def self.each_instance_variable_for_example(group); end
+  def self.ensure_example_groups_are_configured; end
+  def self.example(*all_args, &block); end
+  def self.example_group(*args, &example_group_block); end
+  def self.examples; end
+  def self.fcontext(*args, &example_group_block); end
+  def self.fdescribe(*args, &example_group_block); end
+  def self.fexample(*all_args, &block); end
+  def self.file_path; end
+  def self.filtered_examples; end
+  def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
+  def self.fit(*all_args, &block); end
+  def self.focus(*all_args, &block); end
+  def self.for_filtered_examples(reporter, &block); end
+  def self.fspecify(*all_args, &block); end
+  def self.id; end
+  def self.idempotently_define_singleton_method(name, &definition); end
+  def self.include_context(name, *args, &block); end
+  def self.include_examples(name, *args, &block); end
+  def self.it(*all_args, &block); end
+  def self.it_behaves_like(name, *args, &customization_block); end
+  def self.it_should_behave_like(name, *args, &customization_block); end
+  def self.location; end
+  def self.metadata; end
+  def self.method_missing(name, *args); end
+  def self.next_runnable_index_for(file); end
+  def self.ordering_strategy; end
+  def self.parent_groups; end
+  def self.pending(*all_args, &block); end
+  def self.remove_example(example); end
+  def self.reset_memoized; end
+  def self.run(reporter = nil); end
+  def self.run_after_context_hooks(example_group_instance); end
+  def self.run_before_context_hooks(example_group_instance); end
+  def self.run_examples(reporter); end
+  def self.set_it_up(description, args, registration_collection, &example_group_block); end
+  def self.set_ivars(instance, ivars); end
+  def self.skip(*all_args, &block); end
+  def self.specify(*all_args, &block); end
+  def self.store_before_context_ivars(example_group_instance); end
+  def self.subclass(parent, description, args, registration_collection, &example_group_block); end
+  def self.superclass_before_context_ivars; end
+  def self.superclass_metadata; end
+  def self.top_level?; end
+  def self.top_level_description; end
+  def self.traverse_tree_until(&block); end
+  def self.update_inherited_metadata(updates); end
+  def self.with_replaced_metadata(meta); end
+  def self.xcontext(*args, &example_group_block); end
+  def self.xdescribe(*args, &example_group_block); end
+  def self.xexample(*all_args, &block); end
+  def self.xit(*all_args, &block); end
+  def self.xspecify(*all_args, &block); end
+  extend RSpec::Core::Hooks
+  extend RSpec::Core::MemoizedHelpers::ClassMethods
+  extend RSpec::Core::SharedExampleGroup
+  include RSpec::Core::MemoizedHelpers
+  include RSpec::Core::Pending
+end
+class RSpec::Core::ExampleGroup::WrongScopeError < NoMethodError
+end
+class RSpec::Core::AnonymousExampleGroup < RSpec::Core::ExampleGroup
+  def self.metadata; end
+end
+class RSpec::Core::SharedExampleGroupInclusionStackFrame
+  def description; end
+  def formatted_inclusion_location; end
+  def inclusion_location; end
+  def initialize(shared_group_name, inclusion_location); end
+  def self.current_backtrace; end
+  def self.shared_example_group_inclusions; end
+  def self.with_frame(name, location); end
+  def shared_group_name; end
+end
+module RSpec::ExampleGroups
+  def self.assign_const(group); end
+  def self.base_name_for(group); end
+  def self.constant_scope_for(group); end
+  def self.disambiguate(name, const_scope); end
+  def self.remove_all_constants; end
+  extend RSpec::Support::RecursiveConstMethods
+end
+module RSpec::Support
+  def self.require_rspec_core(f); end
+end
+class RSpec::Core::Time
+  def self.now; end
+end
+class Module
+  def context(*a, &b); end
+  def describe(*a, &b); end
+  def example_group(*a, &b); end
+  def fcontext(*a, &b); end
+  def fdescribe(*a, &b); end
+  def shared_context(name, *args, &block); end
+  def shared_examples(name, *args, &block); end
+  def shared_examples_for(name, *args, &block); end
+  def xcontext(*a, &b); end
+  def xdescribe(*a, &b); end
+end
+module RSpec::Core::SharedContext
+  def __shared_context_recordings; end
+  def after(*args, &block); end
+  def append_after(*args, &block); end
+  def append_before(*args, &block); end
+  def around(*args, &block); end
+  def before(*args, &block); end
+  def context(*args, &block); end
+  def describe(*args, &block); end
+  def hooks(*args, &block); end
+  def included(group); end
+  def let!(*args, &block); end
+  def let(*args, &block); end
+  def prepend_after(*args, &block); end
+  def prepend_before(*args, &block); end
+  def self.record(methods); end
+  def subject!(*args, &block); end
+  def subject(*args, &block); end
+end
+class RSpec::Core::SharedContext::Recording < Struct
+  def args; end
+  def args=(_); end
+  def block; end
+  def block=(_); end
+  def method_name; end
+  def method_name=(_); end
+  def playback_onto(group); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Core::ExampleStatusPersister
+  def dump_statuses(unparsed_previous_runs); end
+  def initialize(examples, file_name); end
+  def persist; end
+  def self.load_from(file_name); end
+  def self.persist(examples, file_name); end
+  def statuses_from_this_run; end
+end
+class RSpec::Core::ExampleStatusMerger
+  def delete_previous_examples_that_no_longer_exist; end
+  def example_must_no_longer_exist?(ex_id); end
+  def hash_from(example_list); end
+  def initialize(this_run, from_previous_runs); end
+  def loaded_spec_files; end
+  def merge; end
+  def self.merge(this_run, from_previous_runs); end
+  def sort_value_from(example); end
+  def spec_file_from(ex_id); end
+end
+class RSpec::Core::ExampleStatusDumper
+  def column_widths; end
+  def dump; end
+  def formatted_header_rows; end
+  def formatted_row_from(row_values); end
+  def formatted_value_rows; end
+  def headers; end
+  def initialize(examples); end
+  def rows; end
+  def self.dump(examples); end
+end
+class RSpec::Core::ExampleStatusParser
+  def headers; end
+  def initialize(string); end
+  def parse; end
+  def parse_row(line); end
+  def self.parse(string); end
+  def split_line(line); end
+end
+class RSpec::Core::Profiler
+  def example_group_finished(notification); end
+  def example_group_started(notification); end
+  def example_groups; end
+  def example_started(notification); end
+  def initialize; end
+end
diff --git a/sorbet/rbi/gems/rspec-expectations.rbi b/sorbet/rbi/gems/rspec-expectations.rbi
new file mode 100644
index 0000000..0394362
--- /dev/null
+++ b/sorbet/rbi/gems/rspec-expectations.rbi
@@ -0,0 +1,1121 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi
+#
+# rspec-expectations-3.8.4
+
+module RSpec
+end
+module RSpec::Matchers
+  def a_block_changing(*args, &block); end
+  def a_block_outputting(*args, &block); end
+  def a_block_raising(*args, &block); end
+  def a_block_throwing(*args, &block); end
+  def a_block_yielding_control(*args, &block); end
+  def a_block_yielding_successive_args(*args, &block); end
+  def a_block_yielding_with_args(*args, &block); end
+  def a_block_yielding_with_no_args(*args, &block); end
+  def a_collection_containing_exactly(*args, &block); end
+  def a_collection_ending_with(*args, &block); end
+  def a_collection_including(*args, &block); end
+  def a_collection_starting_with(*args, &block); end
+  def a_falsey_value(*args, &block); end
+  def a_falsy_value(*args, &block); end
+  def a_hash_including(*args, &block); end
+  def a_kind_of(*args, &block); end
+  def a_nil_value(*args, &block); end
+  def a_range_covering(*args, &block); end
+  def a_string_ending_with(*args, &block); end
+  def a_string_including(*args, &block); end
+  def a_string_matching(*args, &block); end
+  def a_string_starting_with(*args, &block); end
+  def a_truthy_value(*args, &block); end
+  def a_value(*args, &block); end
+  def a_value_between(*args, &block); end
+  def a_value_within(*args, &block); end
+  def aggregate_failures(label = nil, metadata = nil, &block); end
+  def all(expected); end
+  def an_instance_of(*args, &block); end
+  def an_object_eq_to(*args, &block); end
+  def an_object_eql_to(*args, &block); end
+  def an_object_equal_to(*args, &block); end
+  def an_object_existing(*args, &block); end
+  def an_object_having_attributes(*args, &block); end
+  def an_object_matching(*args, &block); end
+  def an_object_responding_to(*args, &block); end
+  def an_object_satisfying(*args, &block); end
+  def be(*args); end
+  def be_a(klass); end
+  def be_a_kind_of(expected); end
+  def be_an(klass); end
+  def be_an_instance_of(expected); end
+  def be_between(min, max); end
+  def be_falsey; end
+  def be_falsy(*args, &block); end
+  def be_instance_of(expected); end
+  def be_kind_of(expected); end
+  def be_nil; end
+  def be_truthy; end
+  def be_within(delta); end
+  def change(receiver = nil, message = nil, &block); end
+  def changing(*args, &block); end
+  def contain_exactly(*items); end
+  def containing_exactly(*args, &block); end
+  def cover(*values); end
+  def covering(*args, &block); end
+  def end_with(*expected); end
+  def ending_with(*args, &block); end
+  def eq(expected); end
+  def eq_to(*args, &block); end
+  def eql(expected); end
+  def eql_to(*args, &block); end
+  def equal(expected); end
+  def equal_to(*args, &block); end
+  def exist(*args); end
+  def existing(*args, &block); end
+  def expect(value = nil, &block); end
+  def have_attributes(expected); end
+  def having_attributes(*args, &block); end
+  def include(*expected); end
+  def including(*args, &block); end
+  def match(expected); end
+  def match_array(items); end
+  def match_regex(*args, &block); end
+  def matching(*args, &block); end
+  def method_missing(method, *args, &block); end
+  def output(expected = nil); end
+  def raise_error(error = nil, message = nil, &block); end
+  def raise_exception(error = nil, message = nil, &block); end
+  def raising(*args, &block); end
+  def respond_to(*names); end
+  def respond_to_missing?(method, *arg1); end
+  def responding_to(*args, &block); end
+  def satisfy(description = nil, &block); end
+  def satisfying(*args, &block); end
+  def self.alias_matcher(*args, &block); end
+  def self.clear_generated_description; end
+  def self.configuration; end
+  def self.generated_description; end
+  def self.is_a_describable_matcher?(obj); end
+  def self.is_a_matcher?(obj); end
+  def self.last_description; end
+  def self.last_expectation_handler; end
+  def self.last_expectation_handler=(arg0); end
+  def self.last_matcher; end
+  def self.last_matcher=(arg0); end
+  def start_with(*expected); end
+  def starting_with(*args, &block); end
+  def throw_symbol(expected_symbol = nil, expected_arg = nil); end
+  def throwing(*args, &block); end
+  def within(*args, &block); end
+  def yield_control; end
+  def yield_successive_args(*args); end
+  def yield_with_args(*args); end
+  def yield_with_no_args; end
+  def yielding_control(*args, &block); end
+  def yielding_successive_args(*args, &block); end
+  def yielding_with_args(*args, &block); end
+  def yielding_with_no_args(*args, &block); end
+  extend RSpec::Matchers::DSL
+end
+module RSpec::Matchers::EnglishPhrasing
+  def self.list(obj); end
+  def self.split_words(sym); end
+end
+module RSpec::Matchers::Composable
+  def &(matcher); end
+  def ===(value); end
+  def and(matcher); end
+  def description_of(object); end
+  def or(matcher); end
+  def self.should_enumerate?(item); end
+  def self.surface_descriptions_in(item); end
+  def self.unreadable_io?(object); end
+  def should_enumerate?(item); end
+  def surface_descriptions_in(item); end
+  def unreadable_io?(object); end
+  def values_match?(expected, actual); end
+  def with_matchers_cloned(object); end
+  def |(matcher); end
+end
+class RSpec::Matchers::Composable::DescribableItem < Struct
+  def inspect; end
+  def item; end
+  def item=(_); end
+  def pretty_print(pp); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+module RSpec::Matchers::BuiltIn
+end
+class RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual; end
+  def actual_formatted; end
+  def assert_ivars(*expected_ivars); end
+  def description; end
+  def diffable?; end
+  def expected; end
+  def expected_formatted; end
+  def expects_call_stack_jump?; end
+  def initialize(expected = nil); end
+  def match_unless_raises(*exceptions); end
+  def matcher_name; end
+  def matcher_name=(arg0); end
+  def matches?(actual); end
+  def present_ivars; end
+  def rescued_exception; end
+  def self.matcher_name; end
+  def self.underscore(camel_cased_word); end
+  def supports_block_expectations?; end
+  include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  include RSpec::Matchers::Composable
+end
+module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  def improve_hash_formatting(inspect_string); end
+  def self.improve_hash_formatting(inspect_string); end
+end
+module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  def failure_message; end
+  def failure_message_when_negated; end
+  def self.has_default_failure_messages?(matcher); end
+end
+module RSpec::Matchers::DSL
+  def alias_matcher(new_name, old_name, options = nil, &description_override); end
+  def define(name, &declarations); end
+  def define_negated_matcher(negated_name, base_name, &description_override); end
+  def matcher(name, &declarations); end
+  def warn_about_block_args(name, declarations); end
+end
+module RSpec::Matchers::DSL::Macros
+  def assign_attributes(attr_names); end
+  def chain(method_name, *attr_names, &definition); end
+  def define_user_override(method_name, user_def, &our_def); end
+  def description(&definition); end
+  def diffable; end
+  def failure_message(&definition); end
+  def failure_message_when_negated(&definition); end
+  def match(options = nil, &match_block); end
+  def match_unless_raises(expected_exception = nil, &match_block); end
+  def match_when_negated(&match_block); end
+  def supports_block_expectations; end
+end
+module RSpec::Matchers::DSL::Macros::Deprecated
+  def failure_message_for_should(&definition); end
+  def failure_message_for_should_not(&definition); end
+  def match_for_should(&definition); end
+  def match_for_should_not(&definition); end
+end
+module RSpec::Matchers::DSL::DefaultImplementations
+  def chained_method_clause_sentences; end
+  def description; end
+  def diffable?; end
+  def expects_call_stack_jump?; end
+  def supports_block_expectations?; end
+  include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+end
+class RSpec::Matchers::DSL::Matcher
+  def actual; end
+  def actual_arg_for(block); end
+  def block_arg; end
+  def expected; end
+  def expected_as_array; end
+  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
+  def inspect; end
+  def method_missing(method, *args, &block); end
+  def name; end
+  def rescued_exception; end
+  def respond_to_missing?(method, include_private = nil); end
+  extend RSpec::Matchers::DSL::Macros
+  extend RSpec::Matchers::DSL::Macros::Deprecated
+  include RSpec::Matchers
+  include RSpec::Matchers::Composable
+  include RSpec::Matchers::DSL::DefaultImplementations
+end
+class RSpec::Matchers::MatcherDelegator
+  def base_matcher; end
+  def initialize(base_matcher); end
+  def initialize_copy(other); end
+  def method_missing(*args, &block); end
+  def respond_to_missing?(name, include_all = nil); end
+  include RSpec::Matchers::Composable
+end
+class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(base_matcher, description_block); end
+  def method_missing(*arg0); end
+end
+class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher
+end
+class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher
+  def does_not_match?(*args, &block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(*args, &block); end
+  def optimal_failure_message(same, inverted); end
+end
+class RSpec::Matchers::ExpectedsForMultipleDiffs
+  def diffs(differ, actual); end
+  def initialize(expected_list); end
+  def message_with_diff(message, differ, actual); end
+  def self.diff_label_for(matcher); end
+  def self.for_many_matchers(matchers); end
+  def self.from(expected); end
+  def self.truncated(description); end
+end
+module RSpec::Support
+  def self.require_rspec_expectations(f); end
+  def self.require_rspec_matchers(f); end
+end
+module RSpec::Expectations
+  def self.configuration; end
+  def self.differ; end
+  def self.fail_with(message, expected = nil, actual = nil); end
+end
+class RSpec::Expectations::ExpectationTarget
+  def initialize(value); end
+  def self.for(value, block); end
+  def target; end
+  include RSpec::Expectations::ExpectationTarget::InstanceMethods
+end
+module RSpec::Expectations::ExpectationTarget::UndefinedValue
+end
+module RSpec::Expectations::ExpectationTarget::InstanceMethods
+  def not_to(matcher = nil, message = nil, &block); end
+  def prevent_operator_matchers(verb); end
+  def to(matcher = nil, message = nil, &block); end
+  def to_not(matcher = nil, message = nil, &block); end
+end
+class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget
+  def enforce_block_expectation(matcher); end
+  def not_to(matcher, message = nil, &block); end
+  def supports_block_expectations?(matcher); end
+  def to(matcher, message = nil, &block); end
+  def to_not(matcher, message = nil, &block); end
+end
+module RSpec::Expectations::Syntax
+  def default_should_host; end
+  def disable_expect(syntax_host = nil); end
+  def disable_should(syntax_host = nil); end
+  def enable_expect(syntax_host = nil); end
+  def enable_should(syntax_host = nil); end
+  def expect_enabled?(syntax_host = nil); end
+  def self.default_should_host; end
+  def self.disable_expect(syntax_host = nil); end
+  def self.disable_should(syntax_host = nil); end
+  def self.enable_expect(syntax_host = nil); end
+  def self.enable_should(syntax_host = nil); end
+  def self.expect_enabled?(syntax_host = nil); end
+  def self.should_enabled?(syntax_host = nil); end
+  def self.warn_about_should!; end
+  def self.warn_about_should_unless_configured(method_name); end
+  def should_enabled?(syntax_host = nil); end
+  def warn_about_should!; end
+  def warn_about_should_unless_configured(method_name); end
+end
+class BasicObject
+  def should(matcher = nil, message = nil, &block); end
+  def should_not(matcher = nil, message = nil, &block); end
+end
+class RSpec::Expectations::Configuration
+  def add_should_and_should_not_to(*modules); end
+  def backtrace_formatter; end
+  def backtrace_formatter=(arg0); end
+  def color?; end
+  def false_positives_handler; end
+  def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end
+  def include_chain_clauses_in_custom_matcher_descriptions?; end
+  def initialize; end
+  def max_formatted_output_length=(length); end
+  def on_potential_false_positives; end
+  def on_potential_false_positives=(behavior); end
+  def reset_syntaxes_to_default; end
+  def syntax; end
+  def syntax=(values); end
+  def warn_about_potential_false_positives=(boolean); end
+  def warn_about_potential_false_positives?; end
+end
+module RSpec::Expectations::Configuration::NullBacktraceFormatter
+  def self.format_backtrace(backtrace); end
+end
+class InvalidName___Class_0x00___Differ_11
+end
+module RSpec::Expectations::ExpectationHelper
+  def self.check_message(msg); end
+  def self.handle_failure(matcher, message, failure_message_method); end
+  def self.modern_matcher_from(matcher); end
+  def self.with_matcher(handler, matcher, message); end
+end
+class RSpec::Expectations::PositiveExpectationHandler
+  def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
+  def self.opposite_should_method; end
+  def self.should_method; end
+  def self.verb; end
+end
+class RSpec::Expectations::NegativeExpectationHandler
+  def self.does_not_match?(matcher, actual, &block); end
+  def self.handle_matcher(actual, initial_matcher, message = nil, &block); end
+  def self.opposite_should_method; end
+  def self.should_method; end
+  def self.verb; end
+end
+class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator
+  def initialize(matcher); end
+  def self.wrap(matcher); end
+end
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter
+  def failure_message; end
+  def failure_message_when_negated; end
+  def self.interface_matches?(matcher); end
+end
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter
+  def failure_message; end
+  def failure_message_when_negated; end
+  def self.interface_matches?(matcher); end
+end
+module RSpec::Expectations::Version
+end
+class RSpec::Expectations::ExpectationNotMetError < Exception
+end
+class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError
+  def aggregation_block_label; end
+  def aggregation_metadata; end
+  def all_exceptions; end
+  def block_description; end
+  def enumerated(exceptions, index_offset); end
+  def enumerated_errors; end
+  def enumerated_failures; end
+  def exception_count_description; end
+  def failures; end
+  def indentation; end
+  def indented(failure_message, index); end
+  def index_label(index); end
+  def initialize(failure_aggregator); end
+  def longest_index_label_width; end
+  def message; end
+  def other_errors; end
+  def pluralize(noun, count); end
+  def summary; end
+  def width_of_label(index); end
+end
+class RSpec::Expectations::BlockSnippetExtractor
+  def beginning_line_number; end
+  def block_token_extractor; end
+  def body_content_lines; end
+  def file_path; end
+  def initialize(proc, method_name); end
+  def method_name; end
+  def proc; end
+  def raw_body_lines; end
+  def raw_body_snippet; end
+  def self.try_extracting_single_line_body_of(proc, method_name); end
+  def source; end
+  def source_location; end
+end
+class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError
+end
+class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error
+end
+class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error
+end
+class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct
+  def after_beginning_of_args_state(token); end
+  def after_beginning_of_body_state(token); end
+  def after_method_call_state(token); end
+  def after_opener_state(token); end
+  def beginning_line_number; end
+  def beginning_line_number=(_); end
+  def block_locator; end
+  def body_tokens; end
+  def correct_block?(body_tokens); end
+  def finalize_pending_tokens!; end
+  def finish!; end
+  def finish_or_find_next_block_if_incorrect!; end
+  def handle_closer_token(token); end
+  def handle_opener_token(token); end
+  def initial_state(token); end
+  def initialize(*arg0); end
+  def invoke_state_handler(token); end
+  def method_name; end
+  def method_name=(_); end
+  def opener_token?(token); end
+  def opener_token_stack; end
+  def parse!; end
+  def pending_tokens; end
+  def pipe_token?(token); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def source; end
+  def source=(_); end
+  def state; end
+end
+class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct
+  def beginning_line_number; end
+  def beginning_line_number=(_); end
+  def block_body_node; end
+  def block_wrapper_node; end
+  def body_content_locations; end
+  def candidate_block_wrapper_nodes; end
+  def candidate_method_ident_nodes; end
+  def method_call_location; end
+  def method_ident_node; end
+  def method_ident_node?(node); end
+  def method_name; end
+  def method_name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def source; end
+  def source=(_); end
+end
+class RSpec::Expectations::FailureAggregator
+  def aggregate; end
+  def assign_backtrace(failure); end
+  def block_label; end
+  def call(failure, options); end
+  def failures; end
+  def initialize(block_label, metadata); end
+  def metadata; end
+  def notify_aggregated_failures; end
+  def other_errors; end
+end
+class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher
+  def match(expected, actual); end
+end
+class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def match(expected, actual); end
+end
+class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher
+  def comparable?; end
+  def compare; end
+  def description; end
+  def exclusive; end
+  def failure_message; end
+  def inclusive; end
+  def initialize(min, max); end
+  def matches?(actual); end
+  def not_comparable_clause; end
+end
+class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+  def match(_, actual); end
+end
+class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+  def match(_, actual); end
+end
+class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+  def match(_, actual); end
+end
+module RSpec::Matchers::BuiltIn::BeHelpers
+  def args_to_s; end
+  def args_to_sentence; end
+  def expected_to_sentence; end
+  def inspected_args; end
+  def parenthesize(string); end
+end
+class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher
+  def <(operand); end
+  def <=(operand); end
+  def ==(operand); end
+  def ===(operand); end
+  def =~(operand); end
+  def >(operand); end
+  def >=(operand); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(*args); end
+  def match(_, actual); end
+  include RSpec::Matchers::BuiltIn::BeHelpers
+end
+class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(operand, operator); end
+  def matches?(actual); end
+  include RSpec::Matchers::BuiltIn::BeHelpers
+end
+class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def does_not_match?(actual, &block); end
+  def failure_message; end
+  def failure_message_expecting(value); end
+  def failure_message_when_negated; end
+  def initialize(*args, &block); end
+  def matches?(actual, &block); end
+  def parse_expected(expected); end
+  def predicate; end
+  def predicate_accessible?; end
+  def predicate_matches?; end
+  def prefix_and_expected(symbol); end
+  def prefix_to_sentence; end
+  def present_tense_predicate; end
+  def private_predicate?; end
+  def validity_message; end
+  include RSpec::Matchers::BuiltIn::BeHelpers
+end
+class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(delta); end
+  def matches?(actual); end
+  def needs_expected; end
+  def not_numeric_clause; end
+  def numeric?; end
+  def of(expected); end
+  def percent_of(expected); end
+end
+class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher
+  def by(expected_delta); end
+  def by_at_least(minimum); end
+  def by_at_most(maximum); end
+  def change_details; end
+  def description; end
+  def does_not_match?(event_proc); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def from(value); end
+  def initialize(receiver = nil, message = nil, &block); end
+  def matches?(event_proc); end
+  def negative_failure_reason; end
+  def perform_change(event_proc); end
+  def positive_failure_reason; end
+  def raise_block_syntax_error; end
+  def supports_block_expectations?; end
+  def to(value); end
+end
+class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def does_not_match?(_event_proc); end
+  def failure_message; end
+  def failure_reason; end
+  def initialize(change_details, expected_delta, relativity, &comparer); end
+  def matches?(event_proc); end
+  def supports_block_expectations?; end
+end
+class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher
+  def after_value_failure; end
+  def before_value_failure; end
+  def description; end
+  def did_change_failure; end
+  def did_not_change_failure; end
+  def failure_message; end
+  def initialize(change_details, from, to); end
+  def matches?(event_proc); end
+  def matches_after?; end
+  def not_given_a_block_failure; end
+  def perform_change(event_proc); end
+  def supports_block_expectations?; end
+end
+class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
+  def change_description; end
+  def does_not_match?(event_proc); end
+  def failure_message_when_negated; end
+  def initialize(change_details, expected_before); end
+  def to(value); end
+end
+class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange
+  def change_description; end
+  def does_not_match?(_event_proc); end
+  def from(value); end
+  def initialize(change_details, expected_after); end
+end
+class RSpec::Matchers::BuiltIn::ChangeDetails
+  def actual_after; end
+  def actual_delta; end
+  def changed?; end
+  def evaluate_value_proc; end
+  def extract_value_block_snippet; end
+  def initialize(matcher_name, receiver = nil, message = nil, &block); end
+  def message_notation(receiver, message); end
+  def perform_change(event_proc); end
+  def value_representation; end
+end
+class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher
+  def compound_failure_message; end
+  def description; end
+  def diffable?; end
+  def diffable_matcher_list; end
+  def diffable_matcher_list_for(matcher); end
+  def does_not_match?(_actual); end
+  def evaluator; end
+  def expected; end
+  def expects_call_stack_jump?; end
+  def indent_multiline_message(message); end
+  def initialize(matcher_1, matcher_2); end
+  def initialize_copy(other); end
+  def match(_expected, actual); end
+  def matcher_1; end
+  def matcher_1_matches?; end
+  def matcher_2; end
+  def matcher_2_matches?; end
+  def matcher_is_diffable?(matcher); end
+  def matcher_supports_block_expectations?(matcher); end
+  def supports_block_expectations?; end
+end
+class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
+  def initialize(actual, *arg1); end
+  def matcher_matches?(matcher); end
+end
+class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
+  def initialize(actual, matcher_1, matcher_2); end
+  def inner_matcher_block(outer_args); end
+  def matcher_matches?(matcher); end
+  def order_block_matchers; end
+  def self.matcher_expects_call_stack_jump?(matcher); end
+end
+class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound
+  def conjunction; end
+  def failure_message; end
+  def match(*arg0); end
+end
+class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound
+  def conjunction; end
+  def failure_message; end
+  def match(*arg0); end
+end
+class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual_collection_line; end
+  def best_solution; end
+  def convert_actual_to_an_array; end
+  def describe_collection(collection, surface_descriptions = nil); end
+  def description; end
+  def expected_collection_line; end
+  def extra_elements_line; end
+  def extra_items; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def generate_failure_message; end
+  def match(_expected, _actual); end
+  def match_when_sorted?; end
+  def message_line(prefix, collection, surface_descriptions = nil); end
+  def missing_elements_line; end
+  def missing_items; end
+  def pairings_maximizer; end
+  def safe_sort(array); end
+  def to_a_disallowed?(object); end
+end
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
+  def actual_to_expected_matched_indexes; end
+  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
+  def best_solution_for_pairing(expected_index, actual_index); end
+  def categorize_indexes(indexes_to_categorize, other_indexes); end
+  def expected_to_actual_matched_indexes; end
+  def find_best_solution; end
+  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
+  def reciprocal_single_match?(matches, index, other_list); end
+  def solution; end
+end
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct
+  def +(derived_candidate_solution); end
+  def candidate?; end
+  def ideal?; end
+  def indeterminate_actual_indexes; end
+  def indeterminate_actual_indexes=(_); end
+  def indeterminate_expected_indexes; end
+  def indeterminate_expected_indexes=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def unmatched_actual_indexes; end
+  def unmatched_actual_indexes=(_); end
+  def unmatched_expected_indexes; end
+  def unmatched_expected_indexes=(_); end
+  def unmatched_item_count; end
+  def worse_than?(other); end
+end
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
+  def self.worse_than?(_other); end
+end
+class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher
+  def does_not_match?(range); end
+  def initialize(*expected); end
+  def matches?(range); end
+end
+class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def failure_message; end
+  def initialize(*expected); end
+  def match(_expected, actual); end
+  def subsets_comparable?; end
+end
+class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith
+  def element_matches?; end
+  def subset_matches?; end
+end
+class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith
+  def element_matches?; end
+  def subset_matches?; end
+end
+class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def diffable?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def match(expected, actual); end
+end
+class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher
+  def diffable?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def match(expected, actual); end
+end
+class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual_inspected; end
+  def detailed_failure_message; end
+  def diffable?; end
+  def expected_is_a_literal_singleton?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def inspect_object(o); end
+  def match(expected, actual); end
+  def simple_failure_message; end
+end
+class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(*expected); end
+  def matches?(actual); end
+end
+class Anonymous_Struct_12 < Struct
+  def actual; end
+  def actual=(_); end
+  def expected; end
+  def expected=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_12
+  def actual_exists?; end
+  def deprecated(predicate, actual); end
+  def existence_values; end
+  def predicates; end
+  def uniq_truthy_values; end
+  def valid_test?; end
+  def validity_message; end
+end
+class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::BaseMatcher
+  def args_description; end
+  def description; end
+  def does_not_match?(actual, &block); end
+  def failure_message; end
+  def failure_message_args_description; end
+  def failure_message_when_negated; end
+  def initialize(method_name, *args, &block); end
+  def matches?(actual, &block); end
+  def method_description; end
+  def predicate; end
+  def predicate_accessible?; end
+  def predicate_exists?; end
+  def predicate_matches?; end
+  def private_predicate?; end
+  def validity_message; end
+end
+class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual; end
+  def actual_has_attribute?(attribute_key, attribute_value); end
+  def cache_all_values; end
+  def description; end
+  def diffable?; end
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def formatted_values; end
+  def initialize(expected); end
+  def matches?(actual); end
+  def perform_match(predicate); end
+  def respond_to_attributes?; end
+  def respond_to_failed; end
+  def respond_to_failure_message_or; end
+  def respond_to_matcher; end
+end
+class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual_collection_includes?(expected_item); end
+  def actual_hash_has_key?(expected_key); end
+  def actual_hash_includes?(expected_key, expected_value); end
+  def comparing_hash_keys?(expected_item); end
+  def comparing_hash_to_a_subset?(expected_item); end
+  def convert_to_hash?(obj); end
+  def description; end
+  def diff_would_wrongly_highlight_matched_item?; end
+  def diffable?; end
+  def does_not_match?(actual); end
+  def excluded_from_actual; end
+  def expected; end
+  def expecteds; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def format_failure_message(preposition); end
+  def initialize(*expecteds); end
+  def matches?(actual); end
+  def perform_match(actual, &block); end
+  def readable_list_of(items); end
+end
+class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher
+  def add_new_line_if_needed(message); end
+  def description; end
+  def does_not_match?(_actual); end
+  def failed_objects; end
+  def failure_message; end
+  def failure_message_for_item(index, failure_message); end
+  def indent_multiline_message(message); end
+  def index_failed_objects; end
+  def initialize(matcher); end
+  def initialize_copy(other); end
+  def iterable?; end
+  def match(_expected, _actual); end
+  def matcher; end
+end
+class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher
+  def can_safely_call_match?(expected, actual); end
+  def description; end
+  def diffable?; end
+  def initialize(expected); end
+  def match(expected, actual); end
+  def match_captures(expected, actual); end
+  def with_captures(*captures); end
+end
+class RSpec::Matchers::BuiltIn::ReliableMatchData
+  def captures; end
+  def initialize(match_data); end
+  def match_data; end
+  def names; end
+end
+class RSpec::Matchers::BuiltIn::OperatorMatcher
+  def !=(_expected); end
+  def !~(_expected); end
+  def <(expected); end
+  def <=(expected); end
+  def ==(expected); end
+  def ===(expected); end
+  def =~(expected); end
+  def >(expected); end
+  def >=(expected); end
+  def description; end
+  def eval_match(actual, operator, expected); end
+  def fail_with_message(message); end
+  def has_non_generic_implementation_of?(op); end
+  def initialize(actual); end
+  def self.get(klass, operator); end
+  def self.register(klass, operator, matcher); end
+  def self.registry; end
+  def self.unregister(klass, operator); end
+  def self.use_custom_matcher_or_delegate(operator); end
+end
+class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
+  def __delegate_operator(actual, operator, expected); end
+end
+class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher
+  def __delegate_operator(actual, operator, expected); end
+end
+class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher
+  def actual_output_description; end
+  def captured?; end
+  def description; end
+  def diffable?; end
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(expected); end
+  def matches?(block); end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+  def supports_block_expectations?; end
+  def to_stderr; end
+  def to_stderr_from_any_process; end
+  def to_stdout; end
+  def to_stdout_from_any_process; end
+end
+module RSpec::Matchers::BuiltIn::NullCapture
+  def self.capture(_block); end
+  def self.name; end
+end
+module RSpec::Matchers::BuiltIn::CaptureStdout
+  def self.capture(block); end
+  def self.name; end
+end
+module RSpec::Matchers::BuiltIn::CaptureStderr
+  def self.capture(block); end
+  def self.name; end
+end
+class Anonymous_Struct_13 < Struct
+  def name; end
+  def name=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def stream; end
+  def stream=(_); end
+end
+class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_13
+  def capture(block); end
+end
+class RSpec::Matchers::BuiltIn::RaiseError
+  def block_matches?; end
+  def description; end
+  def does_not_match?(given_proc); end
+  def error_and_message_match?; end
+  def eval_block; end
+  def expectation_matched?; end
+  def expected_error; end
+  def expecting_specific_exception?; end
+  def expects_call_stack_jump?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def format_backtrace(backtrace); end
+  def given_error; end
+  def handle_warning(message); end
+  def initialize(expected_error_or_message = nil, expected_message = nil, &block); end
+  def matches?(given_proc, negative_expectation = nil, &block); end
+  def raise_message_already_set; end
+  def ready_to_eval_block?; end
+  def supports_block_expectations?; end
+  def verify_message; end
+  def warn_about_bare_error; end
+  def warn_about_negative_false_positive(expression); end
+  def warn_for_false_positives; end
+  def warning; end
+  def warning_about_bare_error; end
+  def with_message(expected_message); end
+  include RSpec::Matchers::Composable
+end
+class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher
+  def and_any_keywords; end
+  def and_keywords(*keywords); end
+  def and_unlimited_arguments; end
+  def argument; end
+  def arguments; end
+  def description; end
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def find_failing_method_names(actual, filter_method); end
+  def initialize(*names); end
+  def matches?(actual); end
+  def matches_arity?(actual, name); end
+  def pp_names; end
+  def with(n); end
+  def with_any_keywords; end
+  def with_arity; end
+  def with_arity_string; end
+  def with_keywords(*keywords); end
+  def with_keywords_string; end
+  def with_unlimited_arguments; end
+end
+class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher
+  def block_representation; end
+  def description; end
+  def extract_block_snippet; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(description = nil, &block); end
+  def matches?(actual, &block); end
+end
+class RSpec::Matchers::BuiltIn::ThrowSymbol
+  def actual_result; end
+  def caught; end
+  def description; end
+  def does_not_match?(given_proc); end
+  def expected(symbol_desc = nil); end
+  def expects_call_stack_jump?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(expected_symbol = nil, expected_arg = nil); end
+  def matches?(given_proc); end
+  def supports_block_expectations?; end
+  def throw_description(symbol, arg); end
+  include RSpec::Matchers::Composable
+end
+class RSpec::Matchers::BuiltIn::YieldProbe
+  def assert_used!; end
+  def assert_valid_expect_block!; end
+  def has_block?; end
+  def initialize(block, &callback); end
+  def num_yields; end
+  def num_yields=(arg0); end
+  def probe; end
+  def self.probe(block, &callback); end
+  def single_yield_args; end
+  def to_proc; end
+  def yielded_args; end
+  def yielded_args=(arg0); end
+  def yielded_once?(matcher_name); end
+end
+class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher
+  def at_least(number); end
+  def at_most(number); end
+  def does_not_match?(block); end
+  def exactly(number); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def failure_reason; end
+  def human_readable_count(count); end
+  def human_readable_expectation_type; end
+  def initialize; end
+  def matches?(block); end
+  def once; end
+  def set_expected_yields_count(relativity, n); end
+  def supports_block_expectations?; end
+  def thrice; end
+  def times; end
+  def twice; end
+end
+class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+  def supports_block_expectations?; end
+end
+class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher
+  def all_args_match?; end
+  def args_currently_match?; end
+  def description; end
+  def does_not_match?(block); end
+  def expected_arg_description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(*args); end
+  def matches?(block); end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+  def supports_block_expectations?; end
+end
+class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def does_not_match?(block); end
+  def expected_arg_description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(*args); end
+  def matches?(block); end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+  def supports_block_expectations?; end
+end
diff --git a/sorbet/rbi/gems/rspec-mocks.rbi b/sorbet/rbi/gems/rspec-mocks.rbi
new file mode 100644
index 0000000..06357fc
--- /dev/null
+++ b/sorbet/rbi/gems/rspec-mocks.rbi
@@ -0,0 +1,1095 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi
+#
+# rspec-mocks-3.8.1
+
+module RSpec
+end
+module RSpec::Mocks
+  def self.allow_message(subject, message, opts = nil, &block); end
+  def self.configuration; end
+  def self.error_generator; end
+  def self.expect_message(subject, message, opts = nil, &block); end
+  def self.setup; end
+  def self.space; end
+  def self.teardown; end
+  def self.verify; end
+  def self.with_temporary_scope; end
+end
+class RSpec::Mocks::InstanceMethodStasher
+  def handle_restoration_failures; end
+  def initialize(object, method); end
+  def method_defined_directly_on_klass?; end
+  def method_defined_on_klass?(klass = nil); end
+  def method_is_stashed?; end
+  def method_owned_by_klass?; end
+  def original_method; end
+  def restore; end
+  def stash; end
+end
+class RSpec::Mocks::MethodDouble
+  def add_default_stub(*args, &implementation); end
+  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
+  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(error_generator, expectation_ordering, expected_from, opts = nil, &implementation); end
+  def build_expectation(error_generator, expectation_ordering); end
+  def clear; end
+  def configure_method; end
+  def define_proxy_method; end
+  def definition_target; end
+  def expectations; end
+  def initialize(object, method_name, proxy); end
+  def message_expectation_class; end
+  def method_name; end
+  def method_stasher; end
+  def new_rspec_prepended_module; end
+  def object; end
+  def object_singleton_class; end
+  def original_implementation_callable; end
+  def original_method; end
+  def proxy_method_invoked(_obj, *args, &block); end
+  def raise_method_not_stubbed_error; end
+  def remove_method_from_definition_target; end
+  def remove_stub; end
+  def remove_stub_if_present; end
+  def reset; end
+  def restore_original_method; end
+  def restore_original_visibility; end
+  def save_original_implementation_callable!; end
+  def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil); end
+  def show_frozen_warning; end
+  def stubs; end
+  def usable_rspec_prepended_module; end
+  def verify; end
+  def visibility; end
+end
+class RSpec::Mocks::MethodDouble::RSpecPrependedModule < Module
+end
+module RSpec::Mocks::ArgumentMatchers
+  def a_kind_of(klass); end
+  def an_instance_of(klass); end
+  def any_args; end
+  def anything; end
+  def array_including(*args); end
+  def boolean; end
+  def duck_type(*args); end
+  def hash_excluding(*args); end
+  def hash_including(*args); end
+  def hash_not_including(*args); end
+  def instance_of(klass); end
+  def kind_of(klass); end
+  def no_args; end
+  def self.anythingize_lonely_keys(*args); end
+end
+class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def self.inherited(subklass); end
+  def self.new(*arg0); end
+end
+class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(_other); end
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(value); end
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(predicate, actual); end
+  def description(name); end
+  def formatted_expected_hash; end
+  def initialize(expected); end
+end
+class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
+end
+class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
+  def ===(actual); end
+  def description; end
+  def formatted_expected_values; end
+  def initialize(expected); end
+end
+class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
+  def ===(value); end
+  def description; end
+  def initialize(*methods_to_respond_to); end
+end
+class RSpec::Mocks::ArgumentMatchers::InstanceOf
+  def ===(actual); end
+  def description; end
+  def initialize(klass); end
+end
+class RSpec::Mocks::ArgumentMatchers::KindOf
+  def ===(actual); end
+  def description; end
+  def initialize(klass); end
+end
+class RSpec::Mocks::ObjectReference
+  def self.anonymous_module?(mod); end
+  def self.for(object_module_or_name, allow_direct_object_refs = nil); end
+  def self.name_of(mod); end
+end
+class RSpec::Mocks::DirectObjectReference
+  def const_to_replace; end
+  def defined?; end
+  def description; end
+  def initialize(object); end
+  def target; end
+  def when_loaded; end
+end
+class RSpec::Mocks::NamedObjectReference
+  def const_to_replace; end
+  def defined?; end
+  def description; end
+  def initialize(const_name); end
+  def object; end
+  def target; end
+  def when_loaded; end
+end
+module RSpec::Mocks::ExampleMethods
+  def allow(target); end
+  def allow_any_instance_of(klass); end
+  def allow_message_expectations_on_nil; end
+  def class_double(doubled_class, *args); end
+  def class_spy(*args); end
+  def double(*args); end
+  def expect_any_instance_of(klass); end
+  def have_received(method_name, &block); end
+  def hide_const(constant_name); end
+  def instance_double(doubled_class, *args); end
+  def instance_spy(*args); end
+  def object_double(object_or_name, *args); end
+  def object_spy(*args); end
+  def receive(method_name, &block); end
+  def receive_message_chain(*messages, &block); end
+  def receive_messages(message_return_value_hash); end
+  def self.declare_double(type, *args); end
+  def self.declare_verifying_double(type, ref, *args); end
+  def self.extended(object); end
+  def self.included(klass); end
+  def spy(*args); end
+  def stub_const(constant_name, value, options = nil); end
+  def without_partial_double_verification; end
+  include RSpec::Mocks::ArgumentMatchers
+end
+module RSpec::Mocks::ExampleMethods::ExpectHost
+  def expect(target); end
+end
+class RSpec::Mocks::Proxy
+  def add_message_expectation(method_name, opts = nil, &block); end
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(method_name, opts = nil, &implementation); end
+  def as_null_object; end
+  def build_expectation(method_name); end
+  def check_for_unexpected_arguments(expectation); end
+  def ensure_implemented(*_args); end
+  def find_almost_matching_expectation(method_name, *args); end
+  def find_almost_matching_stub(method_name, *args); end
+  def find_best_matching_expectation_for(method_name); end
+  def find_matching_expectation(method_name, *args); end
+  def find_matching_method_stub(method_name, *args); end
+  def has_negative_expectation?(message); end
+  def initialize(object, order_group, options = nil); end
+  def message_received(message, *args, &block); end
+  def messages_arg_list; end
+  def method_double_for(message); end
+  def method_double_if_exists_for_message(message); end
+  def null_object?; end
+  def object; end
+  def original_method_handle_for(_message); end
+  def prepended_modules_of_singleton_class; end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_unexpected_message_error(method_name, args); end
+  def received_message?(method_name, *args, &block); end
+  def record_message_received(message, *args, &block); end
+  def remove_stub(method_name); end
+  def remove_stub_if_present(method_name); end
+  def replay_received_message_on(expectation, &block); end
+  def reset; end
+  def self.prepended_modules_of(klass); end
+  def verify; end
+  def visibility_for(_method_name); end
+end
+class RSpec::Mocks::Proxy::SpecificMessage < Struct
+  def ==(expectation); end
+  def args; end
+  def args=(_); end
+  def message; end
+  def message=(_); end
+  def object; end
+  def object=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Mocks::TestDoubleProxy < RSpec::Mocks::Proxy
+  def reset; end
+end
+class RSpec::Mocks::PartialDoubleProxy < RSpec::Mocks::Proxy
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def any_instance_class_recorder_observing_method?(klass, method_name); end
+  def message_received(message, *args, &block); end
+  def original_method_handle_for(message); end
+  def reset; end
+  def visibility_for(method_name); end
+end
+module RSpec::Mocks::PartialClassDoubleProxyMethods
+  def initialize(source_space, *args); end
+  def method_double_from_ancestor_for(message); end
+  def original_method_handle_for(message); end
+  def original_unbound_method_handle_from_ancestor_for(message); end
+  def superclass_proxy; end
+end
+class RSpec::Mocks::PartialClassDoubleProxy < RSpec::Mocks::PartialDoubleProxy
+  include RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+class RSpec::Mocks::ProxyForNil < RSpec::Mocks::PartialDoubleProxy
+  def add_message_expectation(method_name, opts = nil, &block); end
+  def add_stub(method_name, opts = nil, &implementation); end
+  def disallow_expectations; end
+  def disallow_expectations=(arg0); end
+  def initialize(order_group); end
+  def raise_error(method_name); end
+  def set_expectation_behavior; end
+  def warn(method_name); end
+  def warn_about_expectations; end
+  def warn_about_expectations=(arg0); end
+  def warn_or_raise!(method_name); end
+end
+module RSpec::Mocks::TestDouble
+  def ==(other); end
+  def __build_mock_proxy(order_group); end
+  def __build_mock_proxy_unless_expired(order_group); end
+  def __disallow_further_usage!; end
+  def __mock_proxy; end
+  def __raise_expired_error; end
+  def as_null_object; end
+  def assign_stubs(stubs); end
+  def freeze; end
+  def initialize(name = nil, stubs = nil); end
+  def initialize_copy(other); end
+  def inspect; end
+  def method_missing(message, *args, &block); end
+  def null_object?; end
+  def respond_to?(message, incl_private = nil); end
+  def to_s; end
+end
+class RSpec::Mocks::Double
+  include RSpec::Mocks::TestDouble
+end
+module RSpec::Mocks::TestDoubleFormatter
+  def self.format(dbl, unwrap = nil); end
+  def self.name_desc(dbl); end
+  def self.type_desc(dbl); end
+  def self.verified_module_desc(dbl); end
+end
+class RSpec::Mocks::ArgumentListMatcher
+  def args_match?(*args); end
+  def ensure_expected_args_valid!; end
+  def expected_args; end
+  def initialize(*expected_args); end
+  def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
+  def resolve_expected_args_based_on(actual_args); end
+end
+class RSpec::Mocks::SimpleMessageExpectation
+  def called_max_times?; end
+  def initialize(message, response, error_generator, backtrace_line = nil); end
+  def invoke(*_); end
+  def matches?(message, *_); end
+  def unadvise(_); end
+  def verify_messages_received; end
+end
+class RSpec::Mocks::MessageExpectation
+  def and_call_original; end
+  def and_raise(*args); end
+  def and_return(first_value, *values); end
+  def and_throw(*args); end
+  def and_wrap_original(&block); end
+  def and_yield(*args, &block); end
+  def at_least(n, &block); end
+  def at_most(n, &block); end
+  def exactly(n, &block); end
+  def inspect; end
+  def never; end
+  def once(&block); end
+  def ordered(&block); end
+  def thrice(&block); end
+  def times(&block); end
+  def to_s; end
+  def twice(&block); end
+  def with(*args, &block); end
+  include RSpec::Mocks::MessageExpectation::ImplementationDetails
+end
+module RSpec::Mocks::MessageExpectation::ImplementationDetails
+  def actual_received_count_matters?; end
+  def additional_expected_calls; end
+  def advise(*args); end
+  def and_yield_receiver_to_implementation; end
+  def argument_list_matcher=(arg0); end
+  def called_max_times?; end
+  def description_for(verb); end
+  def ensure_expected_ordering_received!; end
+  def error_generator; end
+  def error_generator=(arg0); end
+  def exception_source_id; end
+  def expectation_count_type; end
+  def expected_args; end
+  def expected_from=(arg0); end
+  def expected_messages_received?; end
+  def expected_received_count=(arg0); end
+  def generate_error; end
+  def has_been_invoked?; end
+  def ignoring_args?; end
+  def implementation; end
+  def implementation=(arg0); end
+  def increase_actual_received_count!; end
+  def initial_implementation_action=(action); end
+  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = nil, opts = nil, &implementation_block); end
+  def inner_implementation_action=(action); end
+  def invoke(parent_stub, *args, &block); end
+  def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
+  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
+  def matches?(message, *args); end
+  def matches_at_least_count?; end
+  def matches_at_most_count?; end
+  def matches_exact_count?; end
+  def matches_name_but_not_args(message, *args); end
+  def message; end
+  def negative?; end
+  def negative_expectation_for?(message); end
+  def ordered?; end
+  def orig_object; end
+  def raise_already_invoked_error_if_necessary(calling_customization); end
+  def raise_out_of_order_error; end
+  def raise_unexpected_message_args_error(args_for_multiple_calls); end
+  def safe_invoke(parent_stub, *args, &block); end
+  def set_expected_received_count(relativity, n); end
+  def similar_messages; end
+  def terminal_implementation_action=(action); end
+  def type; end
+  def unadvise(args); end
+  def verify_messages_received; end
+  def warn_about_stub_override; end
+  def wrap_original(method_name, &block); end
+  def yield_receiver_to_implementation_block?; end
+end
+class RSpec::Mocks::AndYieldImplementation
+  def call(*_args_to_ignore, &block); end
+  def initialize(args_to_yield, eval_context, error_generator); end
+end
+class RSpec::Mocks::AndReturnImplementation
+  def call(*_args_to_ignore, &_block); end
+  def initialize(values_to_return); end
+end
+class RSpec::Mocks::Implementation
+  def actions; end
+  def call(*args, &block); end
+  def initial_action; end
+  def initial_action=(arg0); end
+  def inner_action; end
+  def inner_action=(arg0); end
+  def present?; end
+  def terminal_action; end
+  def terminal_action=(arg0); end
+end
+class RSpec::Mocks::AndWrapOriginalImplementation
+  def call(*args, &block); end
+  def cannot_modify_further_error; end
+  def initial_action=(_value); end
+  def initialize(method, block); end
+  def inner_action; end
+  def inner_action=(_value); end
+  def present?; end
+  def terminal_action=(_value); end
+end
+class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < StandardError
+end
+class RSpec::Mocks::OrderGroup
+  def clear; end
+  def consume; end
+  def empty?; end
+  def expectation_for(message); end
+  def expectations_invoked_in_order?; end
+  def expected_invocations; end
+  def handle_order_constraint(expectation); end
+  def initialize; end
+  def invoked(message); end
+  def invoked_expectations; end
+  def ready_for?(expectation); end
+  def register(expectation); end
+  def remaining_expectations; end
+  def verify_invocation_order(expectation); end
+end
+class RSpec::Mocks::MockExpectationError < Exception
+end
+class RSpec::Mocks::ExpiredTestDoubleError < RSpec::Mocks::MockExpectationError
+end
+class RSpec::Mocks::OutsideOfExampleError < StandardError
+end
+class RSpec::Mocks::MockExpectationAlreadyInvokedError < Exception
+end
+class RSpec::Mocks::CannotSupportArgMutationsError < StandardError
+end
+class RSpec::Mocks::UnsupportedMatcherError < StandardError
+end
+class RSpec::Mocks::NegationUnsupportedError < StandardError
+end
+class RSpec::Mocks::VerifyingDoubleNotDefinedError < StandardError
+end
+class RSpec::Mocks::ErrorGenerator
+  def __raise(message, backtrace_line = nil, source_id = nil); end
+  def arg_list(args); end
+  def count_message(count, expectation_count_type = nil); end
+  def default_error_message(expectation, expected_args, actual_args); end
+  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
+  def diff_message(expected_args, actual_args); end
+  def differ; end
+  def error_message(expectation, args_for_multiple_calls); end
+  def expectation_on_nil_message(method_name); end
+  def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
+  def format_args(args); end
+  def format_received_args(args_for_multiple_calls); end
+  def group_count(index, args); end
+  def grouped_args(args); end
+  def initialize(target = nil); end
+  def intro(unwrapped = nil); end
+  def list_of_exactly_one_string?(args); end
+  def method_call_args_description(args, generic_prefix = nil, matcher_prefix = nil); end
+  def notify(*args); end
+  def opts; end
+  def opts=(arg0); end
+  def prepend_to_backtrace(exception, line); end
+  def raise_already_invoked_error(message, calling_customization); end
+  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
+  def raise_double_negation_error(wrapped_expression); end
+  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = nil, source_id = nil); end
+  def raise_expectation_on_mocked_method(method); end
+  def raise_expectation_on_nil_error(method_name); end
+  def raise_expectation_on_unstubbed_method(method); end
+  def raise_expired_test_double_error; end
+  def raise_have_received_disallowed(type, reason); end
+  def raise_invalid_arguments_error(verifier); end
+  def raise_method_not_stubbed_error(method_name); end
+  def raise_missing_block_error(args_to_yield); end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_non_public_error(method_name, visibility); end
+  def raise_only_valid_on_a_partial_double(method); end
+  def raise_out_of_order_error(message); end
+  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = nil); end
+  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = nil); end
+  def raise_unexpected_message_error(message, args); end
+  def raise_unimplemented_error(doubled_module, method_name, object); end
+  def raise_verifying_double_not_defined_error(ref); end
+  def raise_wrong_arity_error(args_to_yield, signature); end
+  def received_part_of_expectation_error(actual_received_count, args); end
+  def times(count); end
+  def unexpected_arguments_message(expected_args_string, actual_args_string); end
+  def unpack_string_args(formatted_expected_args, actual_args); end
+end
+class RSpec::Mocks::RootSpace
+  def any_instance_proxy_for(*_args); end
+  def any_instance_recorder_for(*_args); end
+  def any_instance_recorders_from_ancestry_of(_object); end
+  def new_scope; end
+  def proxy_for(*_args); end
+  def raise_lifecycle_message; end
+  def register_constant_mutator(_mutator); end
+  def registered?(_object); end
+  def reset_all; end
+  def superclass_proxy_for(*_args); end
+  def verify_all; end
+end
+class RSpec::Mocks::Space
+  def any_instance_mutex; end
+  def any_instance_proxy_for(klass); end
+  def any_instance_recorder_for(klass, only_return_existing = nil); end
+  def any_instance_recorder_not_found_for(id, klass); end
+  def any_instance_recorders; end
+  def any_instance_recorders_from_ancestry_of(object); end
+  def class_proxy_with_callback_verification_strategy(object, strategy); end
+  def constant_mutator_for(name); end
+  def ensure_registered(object); end
+  def id_for(object); end
+  def initialize; end
+  def new_mutex; end
+  def new_scope; end
+  def proxies; end
+  def proxies_of(klass); end
+  def proxy_for(object); end
+  def proxy_mutex; end
+  def proxy_not_found_for(id, object); end
+  def register_constant_mutator(mutator); end
+  def registered?(object); end
+  def reset_all; end
+  def superclass_proxy_for(klass); end
+  def superclass_proxy_not_found_for(id, object); end
+  def verify_all; end
+end
+class RSpec::Mocks::NestedSpace < RSpec::Mocks::Space
+  def any_instance_recorder_not_found_for(id, klass); end
+  def constant_mutator_for(name); end
+  def initialize(parent); end
+  def proxies_of(klass); end
+  def proxy_not_found_for(id, object); end
+  def registered?(object); end
+end
+class RSpec::Mocks::Constant
+  def hidden=(arg0); end
+  def hidden?; end
+  def initialize(name); end
+  def inspect; end
+  def mutated?; end
+  def name; end
+  def original_value; end
+  def original_value=(arg0); end
+  def previously_defined=(arg0); end
+  def previously_defined?; end
+  def self.original(name); end
+  def self.unmutated(name); end
+  def stubbed=(arg0); end
+  def stubbed?; end
+  def to_s; end
+  def valid_name=(arg0); end
+  def valid_name?; end
+  extend RSpec::Support::RecursiveConstMethods
+end
+class RSpec::Mocks::ConstantMutator
+  def self.hide(constant_name); end
+  def self.mutate(mutator); end
+  def self.raise_on_invalid_const; end
+  def self.stub(constant_name, value, options = nil); end
+  extend RSpec::Support::RecursiveConstMethods
+end
+class RSpec::Mocks::ConstantMutator::BaseMutator
+  def full_constant_name; end
+  def idempotently_reset; end
+  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
+  def original_value; end
+  def to_constant; end
+  include RSpec::Support::RecursiveConstMethods
+end
+class RSpec::Mocks::ConstantMutator::ConstantHider < RSpec::Mocks::ConstantMutator::BaseMutator
+  def mutate; end
+  def reset; end
+  def to_constant; end
+end
+class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < RSpec::Mocks::ConstantMutator::BaseMutator
+  def initialize(*args); end
+  def mutate; end
+  def reset; end
+  def should_transfer_nested_constants?; end
+  def to_constant; end
+  def transfer_nested_constants; end
+  def verify_constants_to_transfer!; end
+end
+class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < RSpec::Mocks::ConstantMutator::BaseMutator
+  def mutate; end
+  def name_for(parent, name); end
+  def reset; end
+  def to_constant; end
+end
+module RSpec::Mocks::TargetDelegationClassMethods
+  def delegate_not_to(matcher_method, options = nil); end
+  def delegate_to(matcher_method); end
+  def disallow_negation(method_name); end
+end
+module RSpec::Mocks::TargetDelegationInstanceMethods
+  def define_matcher(matcher, name, &block); end
+  def matcher_allowed?(matcher); end
+  def raise_negation_unsupported(method_name, matcher); end
+  def raise_unsupported_matcher(method_name, matcher); end
+  def target; end
+end
+class RSpec::Mocks::TargetBase
+  def initialize(target); end
+  extend RSpec::Mocks::TargetDelegationClassMethods
+  include RSpec::Mocks::TargetDelegationInstanceMethods
+end
+module RSpec::Mocks::ExpectationTargetMethods
+  def expression; end
+  def not_to(matcher, &block); end
+  def to(matcher, &block); end
+  def to_not(matcher, &block); end
+  extend RSpec::Mocks::TargetDelegationClassMethods
+  include RSpec::Mocks::TargetDelegationInstanceMethods
+end
+class RSpec::Mocks::ExpectationTarget < RSpec::Mocks::TargetBase
+  include RSpec::Mocks::ExpectationTargetMethods
+end
+class RSpec::Mocks::AllowanceTarget < RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
+end
+class RSpec::Mocks::AnyInstanceAllowanceTarget < RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
+end
+class RSpec::Mocks::AnyInstanceExpectationTarget < RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, &block); end
+  def to(matcher, &block); end
+  def to_not(matcher, &block); end
+end
+module RSpec::Mocks::Syntax
+  def self.default_should_syntax_host; end
+  def self.disable_expect(syntax_host = nil); end
+  def self.disable_should(syntax_host = nil); end
+  def self.enable_expect(syntax_host = nil); end
+  def self.enable_should(syntax_host = nil); end
+  def self.expect_enabled?(syntax_host = nil); end
+  def self.should_enabled?(syntax_host = nil); end
+  def self.warn_about_should!; end
+  def self.warn_unless_should_configured(method_name, replacement = nil); end
+end
+class BasicObject
+  def as_null_object; end
+  def null_object?; end
+  def received_message?(message, *args, &block); end
+  def should_not_receive(message, &block); end
+  def should_receive(message, opts = nil, &block); end
+  def stub(message_or_hash, opts = nil, &block); end
+  def stub_chain(*chain, &blk); end
+  def unstub(message); end
+end
+class Class < Module
+  def any_instance; end
+end
+class RSpec::Mocks::Configuration
+  def add_stub_and_should_receive_to(*modules); end
+  def allow_message_expectations_on_nil; end
+  def allow_message_expectations_on_nil=(arg0); end
+  def before_verifying_doubles(&block); end
+  def color?; end
+  def initialize; end
+  def patch_marshal_to_support_partial_doubles=(val); end
+  def reset_syntaxes_to_default; end
+  def syntax; end
+  def syntax=(*values); end
+  def temporarily_suppress_partial_double_verification; end
+  def temporarily_suppress_partial_double_verification=(arg0); end
+  def transfer_nested_constants=(arg0); end
+  def transfer_nested_constants?; end
+  def verify_doubled_constant_names=(arg0); end
+  def verify_doubled_constant_names?; end
+  def verify_partial_doubles=(val); end
+  def verify_partial_doubles?; end
+  def verifying_double_callbacks; end
+  def when_declaring_verifying_double(&block); end
+  def yield_receiver_to_any_instance_implementation_blocks=(arg0); end
+  def yield_receiver_to_any_instance_implementation_blocks?; end
+end
+class RSpec::Mocks::VerifyingMessageExpectation < RSpec::Mocks::MessageExpectation
+  def initialize(*args); end
+  def method_reference; end
+  def method_reference=(arg0); end
+  def validate_expected_arguments!; end
+  def with(*args, &block); end
+end
+class RSpec::Mocks::MethodReference
+  def defined?; end
+  def implemented?; end
+  def initialize(object_reference, method_name); end
+  def original_method; end
+  def self.for(object_reference, method_name); end
+  def self.instance_method_visibility_for(klass, method_name); end
+  def self.method_defined_at_any_visibility?(klass, method_name); end
+  def self.method_visibility_for(object, method_name); end
+  def unimplemented?; end
+  def visibility; end
+  def with_signature; end
+end
+class RSpec::Mocks::InstanceMethodReference < RSpec::Mocks::MethodReference
+  def find_method(mod); end
+  def method_defined?(mod); end
+  def method_implemented?(mod); end
+  def visibility_from(mod); end
+end
+class RSpec::Mocks::ObjectMethodReference < RSpec::Mocks::MethodReference
+  def find_method(object); end
+  def method_defined?(object); end
+  def method_implemented?(object); end
+  def self.for(object_reference, method_name); end
+  def visibility_from(object); end
+end
+class RSpec::Mocks::ClassNewMethodReference < RSpec::Mocks::ObjectMethodReference
+  def self.applies_to?(method_name); end
+  def with_signature; end
+end
+class RSpec::Mocks::CallbackInvocationStrategy
+  def call(doubled_module); end
+end
+class RSpec::Mocks::NoCallbackInvocationStrategy
+  def call(_doubled_module); end
+end
+module RSpec::Mocks::VerifyingProxyMethods
+  def add_message_expectation(method_name, opts = nil, &block); end
+  def add_simple_stub(method_name, *args); end
+  def add_stub(method_name, opts = nil, &implementation); end
+  def ensure_implemented(method_name); end
+  def ensure_publicly_implemented(method_name, _object); end
+end
+class RSpec::Mocks::VerifyingProxy < RSpec::Mocks::TestDoubleProxy
+  def initialize(object, order_group, doubled_module, method_reference_class); end
+  def method_reference; end
+  def validate_arguments!(method_name, args); end
+  def visibility_for(method_name); end
+  include RSpec::Mocks::VerifyingProxyMethods
+end
+class RSpec::Mocks::VerifyingPartialDoubleProxy < RSpec::Mocks::PartialDoubleProxy
+  def ensure_implemented(_method_name); end
+  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = nil); end
+  def method_reference; end
+  include RSpec::Mocks::VerifyingProxyMethods
+end
+class RSpec::Mocks::VerifyingPartialClassDoubleProxy < RSpec::Mocks::VerifyingPartialDoubleProxy
+  include RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+class RSpec::Mocks::VerifyingMethodDouble < RSpec::Mocks::MethodDouble
+  def add_expectation(*args, &block); end
+  def add_stub(*args, &block); end
+  def initialize(object, method_name, proxy, method_reference); end
+  def message_expectation_class; end
+  def proxy_method_invoked(obj, *args, &block); end
+  def validate_arguments!(actual_args); end
+end
+class RSpec::Mocks::VerifyingExistingMethodDouble < RSpec::Mocks::VerifyingMethodDouble
+  def initialize(object, method_name, proxy); end
+  def self.for(object, method_name, proxy); end
+  def unimplemented?; end
+  def with_signature; end
+end
+class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < RSpec::Mocks::VerifyingExistingMethodDouble
+  def with_signature; end
+end
+module RSpec::Mocks::VerifyingDouble
+  def __send__(name, *args, &block); end
+  def initialize(doubled_module, *args); end
+  def method_missing(message, *args, &block); end
+  def respond_to?(message, include_private = nil); end
+  def send(name, *args, &block); end
+end
+module RSpec::Mocks::VerifyingDouble::SilentIO
+  def self.method_missing(*arg0); end
+  def self.respond_to?(*arg0); end
+end
+class RSpec::Mocks::InstanceVerifyingDouble
+  def __build_mock_proxy(order_group); end
+  include RSpec::Mocks::TestDouble
+  include RSpec::Mocks::VerifyingDouble
+end
+module RSpec::Mocks::ObjectVerifyingDoubleMethods
+  def __build_mock_proxy(order_group); end
+  def as_stubbed_const(options = nil); end
+  include RSpec::Mocks::TestDouble
+  include RSpec::Mocks::VerifyingDouble
+end
+class RSpec::Mocks::ObjectVerifyingDouble
+  include RSpec::Mocks::ObjectVerifyingDoubleMethods
+end
+class RSpec::Mocks::ClassVerifyingDouble < Module
+  include RSpec::Mocks::ObjectVerifyingDoubleMethods
+end
+module RSpec::Mocks::Version
+end
+module RSpec::Support
+  def self.require_rspec_mocks(f); end
+end
+module RSpec::Mocks::Matchers
+end
+module RSpec::Mocks::Matchers::Matcher
+end
+module RSpec::Mocks::AnyInstance
+  def self.error_generator; end
+end
+class RSpec::Mocks::AnyInstance::Chain
+  def constrained_to_any_of?(*constraints); end
+  def expectation_fulfilled!; end
+  def initialize(recorder, *args, &block); end
+  def last_message; end
+  def matches_args?(*args); end
+  def messages; end
+  def negated?; end
+  def never; end
+  def playback!(instance); end
+  def record(rspec_method_name, *args, &block); end
+  def with(*args, &block); end
+  include RSpec::Mocks::AnyInstance::Chain::Customizations
+end
+module RSpec::Mocks::AnyInstance::Chain::Customizations
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def exactly(*args, &block); end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def self.record(method_name); end
+  def thrice(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def with(*args, &block); end
+end
+class RSpec::Mocks::AnyInstance::ErrorGenerator < RSpec::Mocks::ErrorGenerator
+  def raise_does_not_implement_error(klass, method_name); end
+  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
+  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
+  def raise_second_instance_received_message_error(unfulfilled_expectations); end
+end
+class RSpec::Mocks::AnyInstance::StubChain < RSpec::Mocks::AnyInstance::Chain
+  def create_message_expectation_on(instance); end
+  def expectation_fulfilled?; end
+  def invocation_order; end
+  def verify_invocation_order(rspec_method_name, *_args, &_block); end
+end
+class RSpec::Mocks::AnyInstance::StubChainChain < RSpec::Mocks::AnyInstance::StubChain
+  def create_message_expectation_on(instance); end
+  def initialize(*args); end
+  def invocation_order; end
+end
+class RSpec::Mocks::AnyInstance::ExpectChainChain < RSpec::Mocks::AnyInstance::StubChain
+  def create_message_expectation_on(instance); end
+  def expectation_fulfilled?; end
+  def initialize(*args); end
+  def invocation_order; end
+  def playback!(instance); end
+end
+class RSpec::Mocks::AnyInstance::ExpectationChain < RSpec::Mocks::AnyInstance::Chain
+  def expectation_fulfilled?; end
+  def initialize(*args, &block); end
+  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
+end
+class RSpec::Mocks::AnyInstance::PositiveExpectationChain < RSpec::Mocks::AnyInstance::ExpectationChain
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+end
+class RSpec::Mocks::AnyInstance::MessageChains
+  def [](method_name); end
+  def add(method_name, chain); end
+  def all_expectations_fulfilled?; end
+  def each_unfulfilled_expectation_matching(method_name, *args); end
+  def has_expectation?(method_name); end
+  def initialize; end
+  def playback!(instance, method_name); end
+  def raise_if_second_instance_to_receive_message(instance); end
+  def received_expected_message!(method_name); end
+  def remove_stub_chains_for!(method_name); end
+  def unfulfilled_expectations; end
+end
+class RSpec::Mocks::AnyInstance::Recorder
+  def allow_no_prepended_module_definition_of(method_name); end
+  def already_observing?(method_name); end
+  def ancestor_is_an_observer?(method_name); end
+  def backup_method!(method_name); end
+  def build_alias_method_name(method_name); end
+  def expect_chain(*method_names_and_optional_return_values, &block); end
+  def initialize(klass); end
+  def instance_that_received(method_name); end
+  def klass; end
+  def mark_invoked!(method_name); end
+  def message_chains; end
+  def normalize_chain(*args); end
+  def notify_received_message(_object, message, args, _blk); end
+  def observe!(method_name); end
+  def playback!(instance, method_name); end
+  def public_protected_or_private_method_defined?(method_name); end
+  def received_expected_message!(method_name); end
+  def remove_dummy_method!(method_name); end
+  def restore_method!(method_name); end
+  def restore_original_method!(method_name); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stop_all_observation!; end
+  def stop_observing!(method_name); end
+  def stub(method_name, &block); end
+  def stub_chain(*method_names_and_optional_return_values, &block); end
+  def stubs; end
+  def super_class_observers_for(method_name); end
+  def super_class_observing?(method_name); end
+  def unstub(method_name); end
+  def verify; end
+end
+class RSpec::Mocks::AnyInstance::Proxy
+  def expect_chain(*chain, &block); end
+  def initialize(recorder, target_proxies); end
+  def klass; end
+  def perform_proxying(method_name, args, block, &target_proxy_block); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stub(method_name_or_method_map, &block); end
+  def stub_chain(*chain, &block); end
+  def unstub(method_name); end
+end
+class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
+  def initialize(targets); end
+  def method_missing(*args, &block); end
+  def respond_to_missing?(method_name, include_private = nil); end
+end
+class RSpec::Mocks::MessageChain
+  def block; end
+  def chain; end
+  def chain_on(object, *chain, &block); end
+  def find_matching_expectation; end
+  def find_matching_stub; end
+  def format_chain(*chain, &blk); end
+  def initialize(object, *chain, &blk); end
+  def object; end
+  def setup_chain; end
+end
+class RSpec::Mocks::ExpectChain < RSpec::Mocks::MessageChain
+  def expectation(object, message, &return_block); end
+  def self.expect_chain_on(object, *chain, &blk); end
+end
+class RSpec::Mocks::StubChain < RSpec::Mocks::MessageChain
+  def expectation(object, message, &return_block); end
+  def self.stub_chain_on(object, *chain, &blk); end
+end
+class RSpec::Mocks::MarshalExtension
+  def self.patch!; end
+  def self.unpatch!; end
+end
+class RSpec::Mocks::Matchers::HaveReceived
+  def apply_constraints_to(expectation); end
+  def at_least(*args); end
+  def at_most(*args); end
+  def capture_failure_message; end
+  def count_constraint; end
+  def description; end
+  def disallow(type, reason = nil); end
+  def does_not_match?(subject); end
+  def ensure_count_unconstrained; end
+  def exactly(*args); end
+  def expect; end
+  def expected_messages_received_in_order?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def initialize(method_name, &block); end
+  def matches?(subject, &block); end
+  def mock_proxy; end
+  def name; end
+  def notify_failure_message; end
+  def once(*args); end
+  def ordered(*args); end
+  def setup_allowance(_subject, &_block); end
+  def setup_any_instance_allowance(_subject, &_block); end
+  def setup_any_instance_expectation(_subject, &_block); end
+  def setup_any_instance_negative_expectation(_subject, &_block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(subject, &block); end
+  def thrice(*args); end
+  def times(*args); end
+  def twice(*args); end
+  def with(*args); end
+  include RSpec::Mocks::Matchers::Matcher
+end
+class RSpec::Mocks::Matchers::ExpectationCustomization
+  def block; end
+  def block=(arg0); end
+  def initialize(method_name, args, block); end
+  def playback_onto(expectation); end
+end
+class RSpec::Mocks::Matchers::Receive
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def describable; end
+  def description; end
+  def does_not_match?(subject, &block); end
+  def exactly(*args, &block); end
+  def initialize(message, block); end
+  def matches?(subject, &block); end
+  def move_block_to_last_customization(block); end
+  def name; end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def ordered(*args, &block); end
+  def setup_allowance(subject, &block); end
+  def setup_any_instance_allowance(subject, &block); end
+  def setup_any_instance_expectation(subject, &block); end
+  def setup_any_instance_method_substitute(subject, method, block); end
+  def setup_any_instance_negative_expectation(subject, &block); end
+  def setup_expectation(subject, &block); end
+  def setup_method_substitute(host, method, block, *args); end
+  def setup_mock_proxy_method_substitute(subject, method, block); end
+  def setup_negative_expectation(subject, &block); end
+  def thrice(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def warn_if_any_instance(expression, subject); end
+  def with(*args, &block); end
+  include RSpec::Mocks::Matchers::Matcher
+end
+class RSpec::Mocks::Matchers::Receive::DefaultDescribable
+  def description_for(verb); end
+  def initialize(message); end
+end
+class RSpec::Mocks::Matchers::ReceiveMessageChain
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_yield(*args, &block); end
+  def description; end
+  def does_not_match?(*_args); end
+  def formatted_chain; end
+  def initialize(chain, &block); end
+  def matches?(subject, &block); end
+  def name; end
+  def replay_customizations(chain); end
+  def setup_allowance(subject, &block); end
+  def setup_any_instance_allowance(subject, &block); end
+  def setup_any_instance_expectation(subject, &block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(*_args); end
+  def with(*args, &block); end
+  include RSpec::Mocks::Matchers::Matcher
+end
+class RSpec::Mocks::Matchers::ReceiveMessages
+  def any_instance_of(subject); end
+  def description; end
+  def does_not_match?(_subject); end
+  def each_message_on(host); end
+  def initialize(message_return_value_hash); end
+  def matches?(subject); end
+  def name; end
+  def proxy_on(subject); end
+  def setup_allowance(subject); end
+  def setup_any_instance_allowance(subject); end
+  def setup_any_instance_expectation(subject); end
+  def setup_expectation(subject); end
+  def setup_negative_expectation(_subject); end
+  def warn_about_block; end
+  include RSpec::Mocks::Matchers::Matcher
+end
diff --git a/sorbet/rbi/gems/rspec-support.rbi b/sorbet/rbi/gems/rspec-support.rbi
new file mode 100644
index 0000000..d2fe35d
--- /dev/null
+++ b/sorbet/rbi/gems/rspec-support.rbi
@@ -0,0 +1,269 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi
+#
+# rspec-support-3.8.2
+
+module RSpec
+  extend RSpec::Support::Warnings
+end
+module RSpec::Support
+  def self.class_of(object); end
+  def self.define_optimized_require_for_rspec(lib, &require_relative); end
+  def self.deregister_matcher_definition(&block); end
+  def self.failure_notifier; end
+  def self.failure_notifier=(callable); end
+  def self.is_a_matcher?(object); end
+  def self.matcher_definitions; end
+  def self.method_handle_for(object, method_name); end
+  def self.notify_failure(failure, options = nil); end
+  def self.register_matcher_definition(&block); end
+  def self.require_rspec_support(f); end
+  def self.rspec_description_for_object(object); end
+  def self.thread_local_data; end
+  def self.warning_notifier; end
+  def self.warning_notifier=(arg0); end
+  def self.with_failure_notifier(callable); end
+end
+module RSpec::Support::Version
+end
+class RSpec::Support::ComparableVersion
+  def <=>(other); end
+  def initialize(string); end
+  def segments; end
+  def string; end
+  include Comparable
+end
+module RSpec::Support::OS
+  def self.windows?; end
+  def self.windows_file_path?; end
+  def windows?; end
+  def windows_file_path?; end
+end
+module RSpec::Support::Ruby
+  def jruby?; end
+  def jruby_9000?; end
+  def jruby_version; end
+  def mri?; end
+  def non_mri?; end
+  def rbx?; end
+  def self.jruby?; end
+  def self.jruby_9000?; end
+  def self.jruby_version; end
+  def self.mri?; end
+  def self.non_mri?; end
+  def self.rbx?; end
+end
+module RSpec::Support::RubyFeatures
+  def caller_locations_supported?; end
+  def fork_supported?; end
+  def kw_args_supported?; end
+  def module_prepends_supported?; end
+  def module_refinement_supported?; end
+  def optional_and_splat_args_supported?; end
+  def required_kw_args_supported?; end
+  def ripper_supported?; end
+  def self.caller_locations_supported?; end
+  def self.fork_supported?; end
+  def self.kw_args_supported?; end
+  def self.module_prepends_supported?; end
+  def self.module_refinement_supported?; end
+  def self.optional_and_splat_args_supported?; end
+  def self.required_kw_args_supported?; end
+  def self.ripper_supported?; end
+  def self.supports_exception_cause?; end
+  def self.supports_rebinding_module_methods?; end
+  def supports_exception_cause?; end
+  def supports_rebinding_module_methods?; end
+end
+module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+  def self.===(exception); end
+end
+class RSpec::CallerFilter
+  def self.first_non_rspec_line(skip_frames = nil, increment = nil); end
+end
+module RSpec::Support::Warnings
+  def deprecate(deprecated, options = nil); end
+  def warn_deprecation(message, options = nil); end
+  def warn_with(message, options = nil); end
+  def warning(text, options = nil); end
+end
+class RSpec::Support::EncodedString
+  def <<(string); end
+  def ==(*args, &block); end
+  def detect_source_encoding(string); end
+  def empty?(*args, &block); end
+  def encoding(*args, &block); end
+  def eql?(*args, &block); end
+  def initialize(string, encoding = nil); end
+  def lines(*args, &block); end
+  def matching_encoding(string); end
+  def remove_invalid_bytes(string); end
+  def self.pick_encoding(source_a, source_b); end
+  def source_encoding; end
+  def split(regex_or_string); end
+  def to_s; end
+  def to_str; end
+end
+class RSpec::Support::ReentrantMutex
+  def enter; end
+  def exit; end
+  def initialize; end
+  def synchronize; end
+end
+class RSpec::Support::DirectoryMaker
+  def self.directory_exists?(dirname); end
+  def self.generate_path(stack, part); end
+  def self.generate_stack(path); end
+  def self.mkdir_p(path); end
+end
+module RSpec::Support::RecursiveConstMethods
+  def const_defined_on?(mod, const_name); end
+  def constants_defined_on(mod); end
+  def get_const_defined_on(mod, const_name); end
+  def normalize_const_name(const_name); end
+  def recursive_const_defined?(const_name); end
+  def recursive_const_get(const_name); end
+end
+class RSpec::Support::ObjectFormatter
+  def format(object); end
+  def initialize(max_formatted_output_length = nil); end
+  def max_formatted_output_length; end
+  def max_formatted_output_length=(arg0); end
+  def prepare_array(array); end
+  def prepare_element(element); end
+  def prepare_for_inspection(object); end
+  def prepare_hash(input_hash); end
+  def recursive_structure?(object); end
+  def self.default_instance; end
+  def self.format(object); end
+  def self.prepare_for_inspection(object); end
+  def sort_hash_keys(input_hash); end
+  def truncate_string(str, start_index, end_index); end
+  def with_entering_structure(structure); end
+end
+class RSpec::Support::ObjectFormatter::InspectableItem < Struct
+  def inspect; end
+  def pretty_print(pp); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def text; end
+  def text=(_); end
+end
+class RSpec::Support::ObjectFormatter::BaseInspector < Struct
+  def formatter; end
+  def formatter=(_); end
+  def inspect; end
+  def object; end
+  def object=(_); end
+  def pretty_print(pp); end
+  def self.[](*arg0); end
+  def self.can_inspect?(_object); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def klass; end
+  def native_object_id; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def self.can_inspect?(object); end
+end
+module RSpec::Support::FuzzyMatcher
+  def self.arrays_match?(expected_list, actual_list); end
+  def self.hashes_match?(expected_hash, actual_hash); end
+  def self.values_match?(expected, actual); end
+end
+class RSpec::Support::MethodSignature
+  def arbitrary_kw_args?; end
+  def classify_arity(arity = nil); end
+  def classify_parameters; end
+  def could_contain_kw_args?(args); end
+  def description; end
+  def has_kw_args_in?(args); end
+  def initialize(method); end
+  def invalid_kw_args_from(given_kw_args); end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def missing_kw_args_from(given_kw_args); end
+  def non_kw_args_arity_description; end
+  def optional_kw_args; end
+  def required_kw_args; end
+  def unlimited_args?; end
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end
+end
+class RSpec::Support::MethodSignatureExpectation
+  def empty?; end
+  def expect_arbitrary_keywords; end
+  def expect_arbitrary_keywords=(arg0); end
+  def expect_unlimited_arguments; end
+  def expect_unlimited_arguments=(arg0); end
+  def initialize; end
+  def keywords; end
+  def keywords=(values); end
+  def max_count; end
+  def max_count=(number); end
+  def min_count; end
+  def min_count=(number); end
+end
+class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature
+  def classify_parameters; end
+end
+class RSpec::Support::MethodSignatureVerifier
+  def arbitrary_kw_args?; end
+  def error_message; end
+  def initialize(signature, args = nil); end
+  def invalid_kw_args; end
+  def kw_args; end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def missing_kw_args; end
+  def non_kw_args; end
+  def split_args(*args); end
+  def unlimited_args?; end
+  def valid?; end
+  def valid_non_kw_args?; end
+  def with_expectation(expectation); end
+end
+class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier
+  def split_args(*args); end
+end
+class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
+  def has_kw_args_in?(args); end
+  def initialize(signature); end
+  def invalid_kw_args_from(_kw_args); end
+  def missing_kw_args_from(_kw_args); end
+  def non_kw_args_arity_description; end
+  def valid_non_kw_args?(*args); end
+end
diff --git a/sorbet/rbi/gems/rspec.rbi b/sorbet/rbi/gems/rspec.rbi
new file mode 100644
index 0000000..01b7968
--- /dev/null
+++ b/sorbet/rbi/gems/rspec.rbi
@@ -0,0 +1,15 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi
+#
+# rspec-3.8.0
+
+module RSpec
+end
+module RSpec::Version
+end
diff --git a/sorbet/rbi/gems/simplecov-html.rbi b/sorbet/rbi/gems/simplecov-html.rbi
new file mode 100644
index 0000000..a4ccda1
--- /dev/null
+++ b/sorbet/rbi/gems/simplecov-html.rbi
@@ -0,0 +1,31 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov-html/all/simplecov-html.rbi
+#
+# simplecov-html-0.10.2
+
+module SimpleCov
+end
+module SimpleCov::Formatter
+end
+class SimpleCov::Formatter::HTMLFormatter
+  def asset_output_path; end
+  def assets_path(name); end
+  def coverage_css_class(covered_percent); end
+  def format(result); end
+  def formatted_file_list(title, source_files); end
+  def formatted_source_file(source_file); end
+  def id(source_file); end
+  def link_to_source_file(source_file); end
+  def output_message(result); end
+  def output_path; end
+  def shortened_filename(source_file); end
+  def strength_css_class(covered_strength); end
+  def template(name); end
+  def timeago(time); end
+end
diff --git a/sorbet/rbi/gems/simplecov.rbi b/sorbet/rbi/gems/simplecov.rbi
new file mode 100644
index 0000000..d6deba5
--- /dev/null
+++ b/sorbet/rbi/gems/simplecov.rbi
@@ -0,0 +1,226 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov/all/simplecov.rbi
+#
+# simplecov-0.17.1
+
+module SimpleCov
+  def self.add_not_loaded_files(result); end
+  def self.clear_result; end
+  def self.exit_exception; end
+  def self.exit_status_from_exception; end
+  def self.filtered(files); end
+  def self.final_result_process?; end
+  def self.grouped(files); end
+  def self.load_adapter(name); end
+  def self.load_profile(name); end
+  def self.pid; end
+  def self.pid=(arg0); end
+  def self.process_result(result, exit_status); end
+  def self.result; end
+  def self.result?; end
+  def self.result_exit_status(result, covered_percent); end
+  def self.run_exit_tasks!; end
+  def self.running; end
+  def self.running=(arg0); end
+  def self.set_exit_exception; end
+  def self.start(profile = nil, &block); end
+  def self.usable?; end
+  def self.wait_for_other_processes; end
+  def self.write_last_run(covered_percent); end
+  extend SimpleCov::Configuration
+end
+module SimpleCov::Formatter
+end
+class SimpleCov::Formatter::MultiFormatter
+  def self.[](*args); end
+  def self.new(formatters = nil); end
+end
+module SimpleCov::Formatter::MultiFormatter::InstanceMethods
+  def format(result); end
+end
+module SimpleCov::Configuration
+  def adapters; end
+  def add_filter(filter_argument = nil, &filter_proc); end
+  def add_group(group_name, filter_argument = nil, &filter_proc); end
+  def at_exit(&block); end
+  def command_name(name = nil); end
+  def configure(&block); end
+  def coverage_dir(dir = nil); end
+  def coverage_path; end
+  def filters; end
+  def filters=(arg0); end
+  def formatter(formatter = nil); end
+  def formatter=(arg0); end
+  def formatters; end
+  def formatters=(formatters); end
+  def groups; end
+  def groups=(arg0); end
+  def maximum_coverage_drop(coverage_drop = nil); end
+  def merge_timeout(seconds = nil); end
+  def minimum_coverage(coverage = nil); end
+  def minimum_coverage_by_file(coverage = nil); end
+  def nocov_token(nocov_token = nil); end
+  def parse_filter(filter_argument = nil, &filter_proc); end
+  def profiles; end
+  def project_name(new_name = nil); end
+  def refuse_coverage_drop; end
+  def root(root = nil); end
+  def skip_token(nocov_token = nil); end
+  def track_files(glob); end
+  def tracked_files; end
+  def use_merging(use = nil); end
+end
+module SimpleCov::ExitCodes
+end
+class SimpleCov::Profiles < Hash
+  def define(name, &blk); end
+  def load(name); end
+end
+class SimpleCov::SourceFile
+  def build_lines; end
+  def coverage; end
+  def coverage_exceeding_source_warn; end
+  def covered_lines; end
+  def covered_percent; end
+  def covered_strength; end
+  def filename; end
+  def initialize(filename, coverage); end
+  def line(number); end
+  def lines; end
+  def lines_of_code; end
+  def lines_strength; end
+  def missed_lines; end
+  def never_lines; end
+  def no_lines?; end
+  def process_skipped_lines(lines); end
+  def project_filename; end
+  def relevant_lines; end
+  def round_float(float, places); end
+  def skipped_lines; end
+  def source; end
+  def source_lines; end
+  def src; end
+end
+class SimpleCov::SourceFile::Line
+  def coverage; end
+  def covered?; end
+  def initialize(src, line_number, coverage); end
+  def line; end
+  def line_number; end
+  def missed?; end
+  def never?; end
+  def number; end
+  def skipped!; end
+  def skipped; end
+  def skipped?; end
+  def source; end
+  def src; end
+  def status; end
+end
+class SimpleCov::FileList < Array
+  def covered_lines; end
+  def covered_percent; end
+  def covered_percentages; end
+  def covered_strength; end
+  def least_covered_file; end
+  def lines_of_code; end
+  def missed_lines; end
+  def never_lines; end
+  def skipped_lines; end
+end
+class SimpleCov::Result
+  def command_name; end
+  def command_name=(arg0); end
+  def coverage; end
+  def covered_lines(*args, &block); end
+  def covered_percent(*args, &block); end
+  def covered_percentages(*args, &block); end
+  def covered_strength(*args, &block); end
+  def created_at; end
+  def created_at=(arg0); end
+  def filenames; end
+  def files; end
+  def filter!; end
+  def format!; end
+  def groups; end
+  def initialize(original_result); end
+  def least_covered_file(*args, &block); end
+  def missed_lines(*args, &block); end
+  def original_result; end
+  def self.from_hash(hash); end
+  def source_files; end
+  def to_hash; end
+  def total_lines(*args, &block); end
+  extend Forwardable
+end
+class SimpleCov::Filter
+  def filter_argument; end
+  def initialize(filter_argument); end
+  def matches?(_); end
+  def passes?(source_file); end
+  def self.build_filter(filter_argument); end
+  def self.class_for_argument(filter_argument); end
+end
+class SimpleCov::StringFilter < SimpleCov::Filter
+  def matches?(source_file); end
+end
+class SimpleCov::RegexFilter < SimpleCov::Filter
+  def matches?(source_file); end
+end
+class SimpleCov::BlockFilter < SimpleCov::Filter
+  def matches?(source_file); end
+end
+class SimpleCov::ArrayFilter < SimpleCov::Filter
+  def initialize(filter_argument); end
+  def matches?(source_files_list); end
+end
+class SimpleCov::Formatter::SimpleFormatter
+  def format(result); end
+end
+module SimpleCov::LastRun
+  def self.last_run_path; end
+  def self.read; end
+  def self.write(json); end
+end
+class SimpleCov::LinesClassifier
+  def classify(lines); end
+  def self.no_cov_line; end
+  def self.no_cov_line?(line); end
+  def self.whitespace_line?(line); end
+end
+module SimpleCov::RawCoverage
+  def merge_file_coverage(file1, file2); end
+  def merge_line_coverage(count1, count2); end
+  def merge_results(*results); end
+  def merge_resultsets(result1, result2); end
+  def self.merge_file_coverage(file1, file2); end
+  def self.merge_line_coverage(count1, count2); end
+  def self.merge_results(*results); end
+  def self.merge_resultsets(result1, result2); end
+end
+module SimpleCov::ResultMerger
+  def self.clear_resultset; end
+  def self.merge_results(*results); end
+  def self.merged_result; end
+  def self.results; end
+  def self.resultset; end
+  def self.resultset_path; end
+  def self.resultset_writelock; end
+  def self.store_result(result); end
+  def self.stored_data; end
+  def self.synchronize_resultset; end
+end
+module SimpleCov::CommandGuesser
+  def self.from_command_line_options; end
+  def self.from_defined_constants; end
+  def self.from_env; end
+  def self.guess; end
+  def self.original_run_command; end
+  def self.original_run_command=(arg0); end
+end
diff --git a/sorbet/rbi/gems/sqlite3.rbi b/sorbet/rbi/gems/sqlite3.rbi
new file mode 100644
index 0000000..0795504
--- /dev/null
+++ b/sorbet/rbi/gems/sqlite3.rbi
@@ -0,0 +1,354 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/sqlite3/all/sqlite3.rbi
+#
+# sqlite3-1.4.1
+
+class SQLite3::Database
+  def authorizer(&block); end
+  def authorizer=(arg0); end
+  def busy_handler(*arg0); end
+  def busy_timeout(arg0); end
+  def busy_timeout=(arg0); end
+  def changes; end
+  def close; end
+  def closed?; end
+  def collation(arg0, arg1); end
+  def collations; end
+  def commit; end
+  def complete?(arg0); end
+  def create_aggregate(name, arity, step = nil, finalize = nil, text_rep = nil, &block); end
+  def create_aggregate_handler(handler); end
+  def create_function(name, arity, text_rep = nil, &block); end
+  def db_filename(arg0); end
+  def define_aggregator(name, aggregator); end
+  def define_aggregator2(arg0, arg1); end
+  def define_function(arg0); end
+  def define_function_with_flags(arg0, arg1); end
+  def enable_load_extension(arg0); end
+  def encoding; end
+  def errcode; end
+  def errmsg; end
+  def exec_batch(arg0, arg1); end
+  def execute(sql, bind_vars = nil, *args, &block); end
+  def execute2(sql, *bind_vars); end
+  def execute_batch(sql, bind_vars = nil, *args); end
+  def execute_batch2(sql, &block); end
+  def extended_result_codes=(arg0); end
+  def filename(db_name = nil); end
+  def get_first_row(sql, *bind_vars); end
+  def get_first_value(sql, *bind_vars); end
+  def initialize(file, options = nil, zvfs = nil); end
+  def interrupt; end
+  def last_insert_row_id; end
+  def load_extension(arg0); end
+  def make_type_translator(should_translate); end
+  def open16(arg0); end
+  def open_v2(arg0, arg1, arg2); end
+  def prepare(sql); end
+  def query(sql, bind_vars = nil, *args); end
+  def readonly?; end
+  def results_as_hash; end
+  def results_as_hash=(arg0); end
+  def rollback; end
+  def self.open(*arg0); end
+  def self.quote(string); end
+  def total_changes; end
+  def trace(*arg0); end
+  def transaction(mode = nil); end
+  def transaction_active?; end
+  def translate_from_db(types, row); end
+  def translator; end
+  def type_translation; end
+  def type_translation=(value); end
+  include SQLite3::Pragmas
+end
+class SQLite3::Statement
+  def active?; end
+  def bind_param(arg0, arg1); end
+  def bind_parameter_count; end
+  def bind_params(*bind_vars); end
+  def clear_bindings!; end
+  def close; end
+  def closed?; end
+  def column_count; end
+  def column_decltype(arg0); end
+  def column_name(arg0); end
+  def columns; end
+  def database_name(arg0); end
+  def done?; end
+  def each; end
+  def execute!(*bind_vars, &block); end
+  def execute(*bind_vars); end
+  def get_metadata; end
+  def initialize(arg0, arg1); end
+  def must_be_open!; end
+  def remainder; end
+  def reset!; end
+  def step; end
+  def types; end
+  include Enumerable
+end
+class SQLite3::Backup
+  def finish; end
+  def initialize(arg0, arg1, arg2, arg3); end
+  def pagecount; end
+  def remaining; end
+  def step(arg0); end
+end
+module SQLite3
+  def self.const_missing(name); end
+  def self.libversion; end
+  def self.sqlcipher?; end
+  def self.threadsafe; end
+  def self.threadsafe?; end
+end
+module SQLite3::Constants
+end
+module SQLite3::Constants::TextRep
+end
+module SQLite3::Constants::ColumnType
+end
+module SQLite3::Constants::ErrorCode
+end
+class SQLite3::Exception < StandardError
+  def code; end
+end
+class SQLite3::SQLException < SQLite3::Exception
+end
+class SQLite3::InternalException < SQLite3::Exception
+end
+class SQLite3::PermissionException < SQLite3::Exception
+end
+class SQLite3::AbortException < SQLite3::Exception
+end
+class SQLite3::BusyException < SQLite3::Exception
+end
+class SQLite3::LockedException < SQLite3::Exception
+end
+class SQLite3::MemoryException < SQLite3::Exception
+end
+class SQLite3::ReadOnlyException < SQLite3::Exception
+end
+class SQLite3::InterruptException < SQLite3::Exception
+end
+class SQLite3::IOException < SQLite3::Exception
+end
+class SQLite3::CorruptException < SQLite3::Exception
+end
+class SQLite3::NotFoundException < SQLite3::Exception
+end
+class SQLite3::FullException < SQLite3::Exception
+end
+class SQLite3::CantOpenException < SQLite3::Exception
+end
+class SQLite3::ProtocolException < SQLite3::Exception
+end
+class SQLite3::EmptyException < SQLite3::Exception
+end
+class SQLite3::SchemaChangedException < SQLite3::Exception
+end
+class SQLite3::TooBigException < SQLite3::Exception
+end
+class SQLite3::ConstraintException < SQLite3::Exception
+end
+class SQLite3::MismatchException < SQLite3::Exception
+end
+class SQLite3::MisuseException < SQLite3::Exception
+end
+class SQLite3::UnsupportedException < SQLite3::Exception
+end
+class SQLite3::AuthorizationException < SQLite3::Exception
+end
+class SQLite3::FormatException < SQLite3::Exception
+end
+class SQLite3::RangeException < SQLite3::Exception
+end
+class SQLite3::NotADatabaseException < SQLite3::Exception
+end
+module SQLite3::Pragmas
+  def application_id; end
+  def application_id=(integer); end
+  def auto_vacuum; end
+  def auto_vacuum=(mode); end
+  def automatic_index; end
+  def automatic_index=(mode); end
+  def busy_timeout; end
+  def busy_timeout=(milliseconds); end
+  def cache_size; end
+  def cache_size=(size); end
+  def cache_spill; end
+  def cache_spill=(mode); end
+  def case_sensitive_like=(mode); end
+  def cell_size_check; end
+  def cell_size_check=(mode); end
+  def checkpoint_fullfsync; end
+  def checkpoint_fullfsync=(mode); end
+  def collation_list(&block); end
+  def compile_options(&block); end
+  def count_changes; end
+  def count_changes=(mode); end
+  def data_version; end
+  def database_list(&block); end
+  def default_cache_size; end
+  def default_cache_size=(size); end
+  def default_synchronous; end
+  def default_synchronous=(mode); end
+  def default_temp_store; end
+  def default_temp_store=(mode); end
+  def defer_foreign_keys; end
+  def defer_foreign_keys=(mode); end
+  def encoding; end
+  def encoding=(mode); end
+  def foreign_key_check(*table, &block); end
+  def foreign_key_list(table, &block); end
+  def foreign_keys; end
+  def foreign_keys=(mode); end
+  def freelist_count; end
+  def full_column_names; end
+  def full_column_names=(mode); end
+  def fullfsync; end
+  def fullfsync=(mode); end
+  def get_boolean_pragma(name); end
+  def get_enum_pragma(name); end
+  def get_int_pragma(name); end
+  def get_query_pragma(name, *parms, &block); end
+  def ignore_check_constraints=(mode); end
+  def incremental_vacuum(pages, &block); end
+  def index_info(index, &block); end
+  def index_list(table, &block); end
+  def index_xinfo(index, &block); end
+  def integrity_check(*num_errors, &block); end
+  def journal_mode; end
+  def journal_mode=(mode); end
+  def journal_size_limit; end
+  def journal_size_limit=(size); end
+  def legacy_file_format; end
+  def legacy_file_format=(mode); end
+  def locking_mode; end
+  def locking_mode=(mode); end
+  def max_page_count; end
+  def max_page_count=(size); end
+  def mmap_size; end
+  def mmap_size=(size); end
+  def page_count; end
+  def page_size; end
+  def page_size=(size); end
+  def parser_trace=(mode); end
+  def query_only; end
+  def query_only=(mode); end
+  def quick_check(*num_errors, &block); end
+  def read_uncommitted; end
+  def read_uncommitted=(mode); end
+  def recursive_triggers; end
+  def recursive_triggers=(mode); end
+  def reverse_unordered_selects; end
+  def reverse_unordered_selects=(mode); end
+  def schema_cookie; end
+  def schema_cookie=(cookie); end
+  def schema_version; end
+  def schema_version=(version); end
+  def secure_delete; end
+  def secure_delete=(mode); end
+  def set_boolean_pragma(name, mode); end
+  def set_enum_pragma(name, mode, enums); end
+  def set_int_pragma(name, value); end
+  def short_column_names; end
+  def short_column_names=(mode); end
+  def shrink_memory; end
+  def soft_heap_limit; end
+  def soft_heap_limit=(mode); end
+  def stats(&block); end
+  def synchronous; end
+  def synchronous=(mode); end
+  def table_info(table); end
+  def temp_store; end
+  def temp_store=(mode); end
+  def threads; end
+  def threads=(count); end
+  def tweak_default(hash); end
+  def user_cookie; end
+  def user_cookie=(cookie); end
+  def user_version; end
+  def user_version=(version); end
+  def vdbe_addoptrace=(mode); end
+  def vdbe_debug=(mode); end
+  def vdbe_listing=(mode); end
+  def vdbe_trace; end
+  def vdbe_trace=(mode); end
+  def version_compare(v1, v2); end
+  def wal_autocheckpoint; end
+  def wal_autocheckpoint=(mode); end
+  def wal_checkpoint; end
+  def wal_checkpoint=(mode); end
+  def writable_schema=(mode); end
+end
+class SQLite3::ResultSet
+  def close; end
+  def closed?; end
+  def columns; end
+  def each; end
+  def each_hash; end
+  def eof?; end
+  def initialize(db, stmt); end
+  def next; end
+  def next_hash; end
+  def reset(*bind_params); end
+  def types; end
+  include Enumerable
+end
+class SQLite3::ResultSet::ArrayWithTypes < Array
+  def types; end
+  def types=(arg0); end
+end
+class SQLite3::ResultSet::ArrayWithTypesAndFields < Array
+  def fields; end
+  def fields=(arg0); end
+  def types; end
+  def types=(arg0); end
+end
+class SQLite3::ResultSet::HashWithTypesAndFields < Hash
+  def [](key); end
+  def fields; end
+  def fields=(arg0); end
+  def types; end
+  def types=(arg0); end
+end
+class String
+  def to_blob; end
+end
+class SQLite3::Translator
+  def add_translator(type, &block); end
+  def initialize; end
+  def register_default_translators; end
+  def translate(type, value); end
+  def type_name(type); end
+end
+class SQLite3::Value
+  def handle; end
+  def initialize(db, handle); end
+  def length(utf16 = nil); end
+  def null?; end
+  def to_blob; end
+  def to_f; end
+  def to_i; end
+  def to_int64; end
+  def to_s(utf16 = nil); end
+  def type; end
+end
+class SQLite3::Database::FunctionProxy
+  def [](key); end
+  def []=(key, value); end
+  def count; end
+  def initialize; end
+  def result; end
+  def result=(arg0); end
+  def set_error(error); end
+end
+module SQLite3::VersionProxy
+end
diff --git a/sorbet/rbi/gems/thread_safe.rbi b/sorbet/rbi/gems/thread_safe.rbi
new file mode 100644
index 0000000..ff4422a
--- /dev/null
+++ b/sorbet/rbi/gems/thread_safe.rbi
@@ -0,0 +1,82 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/thread_safe/all/thread_safe.rbi
+#
+# thread_safe-0.3.6
+
+module ThreadSafe
+end
+module Threadsafe
+  def self.const_missing(name); end
+end
+class SynchronizedDelegator < SimpleDelegator
+  def initialize(obj); end
+  def method_missing(method, *args, &block); end
+  def setup; end
+  def teardown; end
+end
+class ThreadSafe::NonConcurrentCacheBackend
+  def [](key); end
+  def []=(key, value); end
+  def _get(key); end
+  def _set(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def dupped_backend; end
+  def each_pair; end
+  def get_and_set(key, value); end
+  def get_or_default(key, default_value); end
+  def initialize(options = nil); end
+  def initialize_copy(other); end
+  def key?(key); end
+  def merge_pair(key, value); end
+  def pair?(key, expected_value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+  def size; end
+  def store_computed_value(key, new_value); end
+  def value?(value); end
+end
+class ThreadSafe::MriCacheBackend < ThreadSafe::NonConcurrentCacheBackend
+  def []=(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def get_and_set(key, value); end
+  def merge_pair(key, value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+end
+class ThreadSafe::Cache < ThreadSafe::MriCacheBackend
+  def [](key); end
+  def each_key; end
+  def each_value; end
+  def empty?; end
+  def fetch(key, default_value = nil); end
+  def fetch_or_store(key, default_value = nil); end
+  def get(key); end
+  def initialize(options = nil, &block); end
+  def initialize_copy(other); end
+  def key(value); end
+  def keys; end
+  def marshal_dump; end
+  def marshal_load(hash); end
+  def populate_from(hash); end
+  def put(key, value); end
+  def put_if_absent(key, value); end
+  def raise_fetch_no_key; end
+  def validate_options_hash!(options); end
+  def values; end
+end
diff --git a/sorbet/rbi/gems/tty-color.rbi b/sorbet/rbi/gems/tty-color.rbi
new file mode 100644
index 0000000..5148c9b
--- /dev/null
+++ b/sorbet/rbi/gems/tty-color.rbi
@@ -0,0 +1,44 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/tty-color/all/tty-color.rbi
+#
+# tty-color-0.5.2
+
+module TTY
+end
+module TTY::Color
+  def color?; end
+  def command?(cmd); end
+  def mode; end
+  def output; end
+  def output=(arg0); end
+  def support?; end
+  def supports?; end
+  def supports_color?; end
+  def tty?; end
+  def verbose; end
+  def verbose=(arg0); end
+  def windows?; end
+  extend TTY::Color
+end
+class TTY::Color::Support
+  def from_curses(curses_class = nil); end
+  def from_env; end
+  def from_term; end
+  def from_tput; end
+  def initialize(env, verbose: nil); end
+  def support?; end
+end
+class TTY::Color::Mode
+  def from_term; end
+  def from_tput; end
+  def initialize(env); end
+  def mode; end
+end
+module TTY::Color::NoValue
+end
diff --git a/sorbet/rbi/gems/tzinfo.rbi b/sorbet/rbi/gems/tzinfo.rbi
new file mode 100644
index 0000000..2fa410f
--- /dev/null
+++ b/sorbet/rbi/gems/tzinfo.rbi
@@ -0,0 +1,406 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/tzinfo/all/tzinfo.rbi
+#
+# tzinfo-1.2.7
+
+module TZInfo
+end
+module TZInfo::RubyCoreSupport
+  def self.datetime_new!(ajd = nil, of = nil, sg = nil); end
+  def self.datetime_new(y = nil, m = nil, d = nil, h = nil, min = nil, s = nil, of = nil, sg = nil); end
+  def self.force_encoding(str, encoding); end
+  def self.open_file(file_name, mode, opts, &block); end
+  def self.rational_new!(numerator, denominator = nil); end
+  def self.time_nsec(time); end
+  def self.time_supports_64bit; end
+  def self.time_supports_negative; end
+end
+module TZInfo::OffsetRationals
+  def rational_for_offset(offset); end
+  def self.rational_for_offset(offset); end
+end
+class TZInfo::TimeOrDateTime
+  def +(seconds); end
+  def -(seconds); end
+  def <=>(timeOrDateTime); end
+  def add_with_convert(seconds); end
+  def day; end
+  def eql?(todt); end
+  def hash; end
+  def hour; end
+  def initialize(timeOrDateTime); end
+  def inspect; end
+  def mday; end
+  def min; end
+  def mon; end
+  def month; end
+  def sec; end
+  def self.wrap(timeOrDateTime); end
+  def to_datetime; end
+  def to_i; end
+  def to_orig; end
+  def to_s; end
+  def to_time; end
+  def usec; end
+  def year; end
+  include Comparable
+end
+module TZInfo::TimezoneDefinition
+  def self.append_features(base); end
+end
+module TZInfo::TimezoneDefinition::ClassMethods
+  def get; end
+  def linked_timezone(identifier, link_to_identifier); end
+  def timezone(identifier); end
+end
+class TZInfo::TimezoneOffset
+  def ==(toi); end
+  def abbreviation; end
+  def dst?; end
+  def eql?(toi); end
+  def hash; end
+  def initialize(utc_offset, std_offset, abbreviation); end
+  def inspect; end
+  def std_offset; end
+  def to_local(utc); end
+  def to_utc(local); end
+  def utc_offset; end
+  def utc_total_offset; end
+end
+class TZInfo::TimezoneTransition
+  def ==(tti); end
+  def at; end
+  def datetime; end
+  def eql?(tti); end
+  def hash; end
+  def initialize(offset, previous_offset); end
+  def inspect; end
+  def local_end; end
+  def local_end_at; end
+  def local_end_time; end
+  def local_start; end
+  def local_start_at; end
+  def local_start_time; end
+  def offset; end
+  def previous_offset; end
+  def raise_not_implemented(method_name); end
+  def time; end
+end
+class TZInfo::TimezoneTransitionDefinition < TZInfo::TimezoneTransition
+  def at; end
+  def denominator; end
+  def eql?(tti); end
+  def hash; end
+  def initialize(offset, previous_offset, numerator_or_timestamp, denominator_or_numerator = nil, denominator = nil); end
+  def numerator_or_time; end
+end
+module TZInfo::TimezoneIndexDefinition
+  def self.append_features(base); end
+end
+module TZInfo::TimezoneIndexDefinition::ClassMethods
+  def data_timezones; end
+  def linked_timezone(identifier); end
+  def linked_timezones; end
+  def timezone(identifier); end
+  def timezones; end
+end
+class TZInfo::TimezoneInfo
+  def create_timezone; end
+  def identifier; end
+  def initialize(identifier); end
+  def inspect; end
+  def raise_not_implemented(method_name); end
+end
+class TZInfo::DataTimezoneInfo < TZInfo::TimezoneInfo
+  def create_timezone; end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def raise_not_implemented(method_name); end
+  def transitions_up_to(utc_to, utc_from = nil); end
+end
+class TZInfo::LinkedTimezoneInfo < TZInfo::TimezoneInfo
+  def create_timezone; end
+  def initialize(identifier, link_to_identifier); end
+  def inspect; end
+  def link_to_identifier; end
+end
+class TZInfo::NoOffsetsDefined < StandardError
+end
+class TZInfo::TransitionDataTimezoneInfo < TZInfo::DataTimezoneInfo
+  def initialize(identifier); end
+  def offset(id, utc_offset, std_offset, abbreviation); end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def transition(year, month, offset_id, numerator_or_timestamp, denominator_or_numerator = nil, denominator = nil); end
+  def transition_after_start(index); end
+  def transition_before_end(index); end
+  def transition_index(year, month); end
+  def transitions_up_to(utc_to, utc_from = nil); end
+end
+class TZInfo::InvalidZoneinfoFile < StandardError
+end
+class TZInfo::ZoneinfoTimezoneInfo < TZInfo::TransitionDataTimezoneInfo
+  def check_read(file, bytes); end
+  def define_offset(index, offset); end
+  def derive_offsets(transitions, offsets); end
+  def initialize(identifier, file_path); end
+  def make_signed_int32(long); end
+  def make_signed_int64(high, low); end
+  def parse(file); end
+end
+class TZInfo::InvalidDataSource < StandardError
+end
+class TZInfo::DataSourceNotFound < StandardError
+end
+class TZInfo::DataSource
+  def country_codes; end
+  def data_timezone_identifiers; end
+  def inspect; end
+  def linked_timezone_identifiers; end
+  def load_country_info(code); end
+  def load_timezone_info(identifier); end
+  def raise_invalid_data_source(method_name); end
+  def self.create_default_data_source; end
+  def self.get; end
+  def self.set(data_source_or_type, *args); end
+  def timezone_identifiers; end
+  def to_s; end
+end
+class TZInfo::RubyDataSource < TZInfo::DataSource
+  def country_codes; end
+  def data_timezone_identifiers; end
+  def initialize; end
+  def linked_timezone_identifiers; end
+  def load_country_index; end
+  def load_country_info(code); end
+  def load_timezone_index; end
+  def load_timezone_info(identifier); end
+  def require_data(*file); end
+  def require_definition(identifier); end
+  def require_index(name); end
+  def timezone_identifiers; end
+  def to_s; end
+end
+class TZInfo::InvalidZoneinfoDirectory < StandardError
+end
+class TZInfo::ZoneinfoDirectoryNotFound < StandardError
+end
+class TZInfo::ZoneinfoDataSource < TZInfo::DataSource
+  def country_codes; end
+  def data_timezone_identifiers; end
+  def dms_to_rational(sign, degrees, minutes, seconds = nil); end
+  def enum_timezones(dir, exclude = nil, &block); end
+  def find_zoneinfo_dir; end
+  def initialize(zoneinfo_dir = nil, alternate_iso3166_tab_path = nil); end
+  def inspect; end
+  def linked_timezone_identifiers; end
+  def load_country_index(iso3166_tab_path, zone_tab_path); end
+  def load_country_info(code); end
+  def load_timezone_index; end
+  def load_timezone_info(identifier); end
+  def resolve_tab_path(zoneinfo_path, standard_names, tab_name); end
+  def self.alternate_iso3166_tab_search_path; end
+  def self.alternate_iso3166_tab_search_path=(alternate_iso3166_tab_search_path); end
+  def self.process_search_path(path, default); end
+  def self.search_path; end
+  def self.search_path=(search_path); end
+  def timezone_identifiers; end
+  def to_s; end
+  def validate_zoneinfo_dir(path, iso3166_tab_path = nil); end
+  def zoneinfo_dir; end
+end
+class TZInfo::TimezonePeriod
+  def ==(p); end
+  def abbreviation; end
+  def dst?; end
+  def end_transition; end
+  def eql?(p); end
+  def hash; end
+  def initialize(start_transition, end_transition, offset = nil); end
+  def inspect; end
+  def local_after_start?(local); end
+  def local_before_end?(local); end
+  def local_end; end
+  def local_end_time; end
+  def local_start; end
+  def local_start_time; end
+  def offset; end
+  def start_transition; end
+  def std_offset; end
+  def to_local(utc); end
+  def to_utc(local); end
+  def utc_after_start?(utc); end
+  def utc_before_end?(utc); end
+  def utc_end; end
+  def utc_end_time; end
+  def utc_offset; end
+  def utc_start; end
+  def utc_start_time; end
+  def utc_total_offset; end
+  def utc_total_offset_rational; end
+  def valid_for_local?(local); end
+  def valid_for_utc?(utc); end
+  def zone_identifier; end
+end
+class TZInfo::AmbiguousTime < StandardError
+end
+class TZInfo::PeriodNotFound < StandardError
+end
+class TZInfo::InvalidTimezoneIdentifier < StandardError
+end
+class TZInfo::UnknownTimezone < StandardError
+end
+class TZInfo::Timezone
+  def <=>(tz); end
+  def _dump(limit); end
+  def canonical_identifier; end
+  def canonical_zone; end
+  def current_period; end
+  def current_period_and_time; end
+  def current_time_and_period; end
+  def eql?(tz); end
+  def friendly_identifier(skip_first_part = nil); end
+  def hash; end
+  def identifier; end
+  def inspect; end
+  def local_to_utc(local, dst = nil); end
+  def name; end
+  def now; end
+  def offsets_up_to(utc_to, utc_from = nil); end
+  def period_for_local(local, dst = nil); end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def raise_unknown_timezone; end
+  def self._load(data); end
+  def self.all; end
+  def self.all_country_zone_identifiers; end
+  def self.all_country_zones; end
+  def self.all_data_zone_identifiers; end
+  def self.all_data_zones; end
+  def self.all_identifiers; end
+  def self.all_linked_zone_identifiers; end
+  def self.all_linked_zones; end
+  def self.data_source; end
+  def self.default_dst; end
+  def self.default_dst=(value); end
+  def self.get(identifier); end
+  def self.get_proxies(identifiers); end
+  def self.get_proxy(identifier); end
+  def self.init_loaded_zones; end
+  def self.new(identifier = nil); end
+  def self.us_zone_identifiers; end
+  def self.us_zones; end
+  def strftime(format, utc = nil); end
+  def to_s; end
+  def transitions_up_to(utc_to, utc_from = nil); end
+  def utc_to_local(utc); end
+  include Comparable
+end
+class TZInfo::InfoTimezone < TZInfo::Timezone
+  def identifier; end
+  def info; end
+  def self.new(info); end
+  def setup(info); end
+end
+class TZInfo::DataTimezone < TZInfo::InfoTimezone
+  def canonical_zone; end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def transitions_up_to(utc_to, utc_from = nil); end
+end
+class TZInfo::LinkedTimezone < TZInfo::InfoTimezone
+  def canonical_zone; end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def setup(info); end
+  def transitions_up_to(utc_to, utc_from = nil); end
+end
+class TZInfo::TimezoneProxy < TZInfo::Timezone
+  def _dump(limit); end
+  def canonical_zone; end
+  def identifier; end
+  def period_for_utc(utc); end
+  def periods_for_local(local); end
+  def real_timezone; end
+  def self._load(data); end
+  def self.new(identifier); end
+  def setup(identifier); end
+  def transitions_up_to(to, from = nil); end
+end
+module TZInfo::CountryIndexDefinition
+  def self.append_features(base); end
+end
+module TZInfo::CountryIndexDefinition::ClassMethods
+  def countries; end
+  def country(code, name, &block); end
+end
+class TZInfo::CountryInfo
+  def code; end
+  def initialize(code, name); end
+  def inspect; end
+  def name; end
+  def raise_not_implemented(method_name); end
+  def zone_identifiers; end
+  def zones; end
+end
+class TZInfo::RubyCountryInfo < TZInfo::CountryInfo
+  def initialize(code, name, &block); end
+  def zone_identifiers; end
+  def zones; end
+end
+class TZInfo::RubyCountryInfo::Zones
+  def initialize; end
+  def list; end
+  def timezone(identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description = nil); end
+end
+class TZInfo::ZoneinfoCountryInfo < TZInfo::CountryInfo
+  def initialize(code, name, zones); end
+  def zone_identifiers; end
+  def zones; end
+end
+class TZInfo::InvalidCountryCode < StandardError
+end
+class TZInfo::Country
+  def <=>(c); end
+  def _dump(limit); end
+  def code; end
+  def eql?(c); end
+  def hash; end
+  def inspect; end
+  def name; end
+  def self._load(data); end
+  def self.all; end
+  def self.all_codes; end
+  def self.data_source; end
+  def self.get(identifier); end
+  def self.init_countries; end
+  def self.new(identifier); end
+  def setup(info); end
+  def to_s; end
+  def zone_identifiers; end
+  def zone_info; end
+  def zone_names; end
+  def zones; end
+  include Comparable
+end
+class TZInfo::CountryTimezone
+  def ==(ct); end
+  def description; end
+  def description_or_friendly_identifier; end
+  def eql?(ct); end
+  def hash; end
+  def identifier; end
+  def initialize(identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description = nil); end
+  def inspect; end
+  def latitude; end
+  def longitude; end
+  def self.new!(*arg0); end
+  def self.new(identifier, latitude, longitude, description = nil); end
+  def timezone; end
+end
diff --git a/sorbet/rbi/hidden-definitions/errors.txt b/sorbet/rbi/hidden-definitions/errors.txt
new file mode 100644
index 0000000..0ac7096
--- /dev/null
+++ b/sorbet/rbi/hidden-definitions/errors.txt
@@ -0,0 +1,3952 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi hidden-definitions
+
+# typed: autogenerated
+
+# wrong constant name <DeclBuilderForProcs>
+# wrong constant name <DeclBuilderForProcs>
+# wrong constant name <Class:<DeclBuilderForProcs>>
+# wrong constant name <Magic>
+# wrong constant name <Magic>
+# wrong constant name <Class:<Magic>>
+# wrong constant name <PackageRegistry>
+# wrong constant name <PackageRegistry>
+# wrong constant name <RESERVED_0>
+# wrong constant name <RESERVED_1>
+# wrong constant name <RESERVED_2>
+# wrong constant name <RESERVED_3>
+# wrong constant name <RESERVED_4>
+# wrong constant name <RESERVED_5>
+# wrong constant name <RESERVED_6>
+# wrong constant name <TypeAlias>
+# wrong constant name <TypeAlias>
+# wrong constant name <any>
+# wrong constant name <any>
+# wrong constant name <root>
+# wrong constant name <Class:<root>>
+# wrong constant name <todo sym>
+# wrong constant name <todo sym>
+# uninitialized constant Abbrev
+# uninitialized constant Abbrev
+# wrong constant name <Class:ClassMethods>
+# wrong constant name attribute_names
+# wrong constant name attributes
+# wrong constant name initialize
+# wrong constant name attribute
+# wrong constant name attribute_names
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:Tests>
+# wrong constant name test_errors_aref
+# wrong constant name test_model_naming
+# wrong constant name test_persisted?
+# wrong constant name test_to_key
+# wrong constant name test_to_param
+# wrong constant name test_to_partial_path
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name persisted?
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::AdvisoryLockBase::ACTIONS
+# uninitialized constant ActiveRecord::AdvisoryLockBase::CALLBACKS
+# uninitialized constant ActiveRecord::AdvisoryLockBase::CALLBACK_FILTER_TYPES
+# uninitialized constant ActiveRecord::AdvisoryLockBase::CALL_COMPILABLE_REGEXP
+# wrong constant name <Class:GeneratedAssociationMethods>
+# wrong constant name <Class:GeneratedAttributeMethods>
+# uninitialized constant ActiveRecord::AdvisoryLockBase::MAX_PASSWORD_LENGTH_ALLOWED
+# uninitialized constant ActiveRecord::AdvisoryLockBase::NAME_COMPILABLE_REGEXP
+# uninitialized constant ActiveRecord::AdvisoryLockBase::RESTRICTED_CLASS_METHODS
+# uninitialized constant ActiveRecord::AdvisoryLockBase::UNASSIGNABLE_KEYS
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name aliased_table_for
+# wrong constant name aliases
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name create
+# wrong constant name initial_count_for
+# wrong constant name create
+# wrong constant name create!
+# wrong constant name extensions
+# wrong constant name initialize
+# wrong constant name initialize_attributes
+# wrong constant name inversed_from
+# wrong constant name inversed_from_queries
+# wrong constant name klass
+# wrong constant name load_target
+# wrong constant name loaded!
+# wrong constant name loaded?
+# wrong constant name marshal_dump
+# wrong constant name marshal_load
+# wrong constant name options
+# wrong constant name owner
+# wrong constant name reflection
+# wrong constant name reload
+# wrong constant name remove_inverse_instance
+# wrong constant name reset
+# wrong constant name reset_scope
+# wrong constant name scope
+# wrong constant name set_inverse_instance
+# wrong constant name set_inverse_instance_from_queries
+# wrong constant name stale_target?
+# wrong constant name target
+# wrong constant name target=
+# wrong constant name <static-init>
+# wrong constant name <Class:ReflectionProxy>
+# wrong constant name initialize
+# wrong constant name scope
+# wrong constant name aliased_table
+# wrong constant name all_includes
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name create
+# wrong constant name get_bind_values
+# wrong constant name scope
+# wrong constant name decrement_counters
+# wrong constant name decrement_counters_before_last_save
+# wrong constant name default
+# wrong constant name handle_dependency
+# wrong constant name increment_counters
+# wrong constant name target_changed?
+# wrong constant name updated?
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Associations::Builder::CollectionAssociation::VALID_OPTIONS
+# wrong constant name association_name
+# wrong constant name initialize
+# wrong constant name lhs_model
+# wrong constant name middle_reflection
+# wrong constant name options
+# wrong constant name through_model
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Associations::Builder::HasOne::VALID_OPTIONS
+# wrong constant name <static-init>
+# wrong constant name touch_record
+# wrong constant name add_to_target
+# wrong constant name build
+# wrong constant name concat
+# wrong constant name delete
+# wrong constant name delete_all
+# wrong constant name destroy
+# wrong constant name destroy_all
+# wrong constant name empty?
+# wrong constant name find
+# wrong constant name find_from_target?
+# wrong constant name ids_reader
+# wrong constant name ids_writer
+# wrong constant name include?
+# wrong constant name null_scope?
+# wrong constant name reader
+# wrong constant name replace
+# wrong constant name size
+# wrong constant name transaction
+# wrong constant name writer
+# wrong constant name <static-init>
+# wrong constant name foreign_key_present?
+# wrong constant name nullified_owner_attributes
+# wrong constant name <static-init>
+# wrong constant name handle_dependency
+# wrong constant name insert_record
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name delete
+# wrong constant name handle_dependency
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:Aliases>
+# wrong constant name <Class:JoinAssociation>
+# wrong constant name <Class:JoinBase>
+# wrong constant name <Class:JoinPart>
+# wrong constant name apply_column_aliases
+# wrong constant name base_klass
+# wrong constant name initialize
+# wrong constant name instantiate
+# wrong constant name join_constraints
+# wrong constant name join_root
+# wrong constant name join_type
+# wrong constant name reflections
+# wrong constant name <Class:Column>
+# wrong constant name <Class:Table>
+# wrong constant name column_alias
+# wrong constant name column_aliases
+# wrong constant name columns
+# wrong constant name initialize
+# uninitialized constant ActiveRecord::Associations::JoinDependency::Aliases::Column::Elem
+# wrong constant name alias
+# wrong constant name alias=
+# wrong constant name name
+# wrong constant name name=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# uninitialized constant ActiveRecord::Associations::JoinDependency::Aliases::Table::Elem
+# wrong constant name column_aliases
+# wrong constant name columns
+# wrong constant name columns=
+# wrong constant name node
+# wrong constant name node=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Associations::JoinDependency::JoinAssociation::Elem
+# wrong constant name initialize
+# wrong constant name join_constraints
+# wrong constant name readonly?
+# wrong constant name reflection
+# wrong constant name table=
+# wrong constant name tables
+# wrong constant name tables=
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Associations::JoinDependency::JoinBase::Elem
+# wrong constant name initialize
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Associations::JoinDependency::JoinPart::Elem
+# wrong constant name base_klass
+# wrong constant name children
+# wrong constant name column_names
+# wrong constant name each
+# wrong constant name each_children
+# wrong constant name extract_record
+# wrong constant name initialize
+# wrong constant name instantiate
+# wrong constant name match?
+# wrong constant name primary_key
+# wrong constant name table
+# wrong constant name table_name
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name make_tree
+# wrong constant name walk_tree
+# wrong constant name <Class:AlreadyLoaded>
+# wrong constant name <Class:Association>
+# wrong constant name <Class:ThroughAssociation>
+# wrong constant name preload
+# wrong constant name initialize
+# wrong constant name preloaded_records
+# wrong constant name records_by_owner
+# wrong constant name run
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name preloaded_records
+# wrong constant name records_by_owner
+# wrong constant name run
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name build
+# wrong constant name force_reload_reader
+# wrong constant name reader
+# wrong constant name writer
+# wrong constant name <static-init>
+# wrong constant name source_reflection
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name dump
+# wrong constant name load
+# wrong constant name assert_valid_value
+# wrong constant name dump
+# wrong constant name initialize
+# wrong constant name load
+# wrong constant name object_class
+# wrong constant name object_class=
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::ConnectionAdapters::AbstractAdapter::CALLBACK_FILTER_TYPES
+# uninitialized constant ActiveRecord::ConnectionAdapters::SQLite3Adapter::CALLBACK_FILTER_TYPES
+# uninitialized constant ActiveRecord::ConnectionAdapters::SQLite3Adapter::COMMENT_REGEX
+# uninitialized constant ActiveRecord::ConnectionAdapters::SQLite3Adapter::SIMPLE_INT
+# wrong constant name collect?
+# wrong constant name created_at
+# wrong constant name created_at=
+# wrong constant name created_at?
+# wrong constant name created_at_before_last_save
+# wrong constant name created_at_before_type_cast
+# wrong constant name created_at_came_from_user?
+# wrong constant name created_at_change
+# wrong constant name created_at_change_to_be_saved
+# wrong constant name created_at_changed?
+# wrong constant name created_at_in_database
+# wrong constant name created_at_previous_change
+# wrong constant name created_at_previously_changed?
+# wrong constant name created_at_was
+# wrong constant name created_at_will_change!
+# wrong constant name key
+# wrong constant name key=
+# wrong constant name key?
+# wrong constant name key_before_last_save
+# wrong constant name key_before_type_cast
+# wrong constant name key_came_from_user?
+# wrong constant name key_change
+# wrong constant name key_change_to_be_saved
+# wrong constant name key_changed?
+# wrong constant name key_in_database
+# wrong constant name key_previous_change
+# wrong constant name key_previously_changed?
+# wrong constant name key_was
+# wrong constant name key_will_change!
+# wrong constant name restore_created_at!
+# wrong constant name restore_key!
+# wrong constant name restore_updated_at!
+# wrong constant name restore_value!
+# wrong constant name saved_change_to_created_at
+# wrong constant name saved_change_to_created_at?
+# wrong constant name saved_change_to_key
+# wrong constant name saved_change_to_key?
+# wrong constant name saved_change_to_updated_at
+# wrong constant name saved_change_to_updated_at?
+# wrong constant name saved_change_to_value
+# wrong constant name saved_change_to_value?
+# wrong constant name updated_at
+# wrong constant name updated_at=
+# wrong constant name updated_at?
+# wrong constant name updated_at_before_last_save
+# wrong constant name updated_at_before_type_cast
+# wrong constant name updated_at_came_from_user?
+# wrong constant name updated_at_change
+# wrong constant name updated_at_change_to_be_saved
+# wrong constant name updated_at_changed?
+# wrong constant name updated_at_in_database
+# wrong constant name updated_at_previous_change
+# wrong constant name updated_at_previously_changed?
+# wrong constant name updated_at_was
+# wrong constant name updated_at_will_change!
+# wrong constant name value
+# wrong constant name value=
+# wrong constant name value?
+# wrong constant name value_before_last_save
+# wrong constant name value_before_type_cast
+# wrong constant name value_came_from_user?
+# wrong constant name value_change
+# wrong constant name value_change_to_be_saved
+# wrong constant name value_changed?
+# wrong constant name value_in_database
+# wrong constant name value_previous_change
+# wrong constant name value_previously_changed?
+# wrong constant name value_was
+# wrong constant name value_will_change!
+# wrong constant name will_save_change_to_created_at?
+# wrong constant name will_save_change_to_key?
+# wrong constant name will_save_change_to_updated_at?
+# wrong constant name will_save_change_to_value?
+# wrong constant name <Class:Rails41>
+# wrong constant name <Class:Rails420>
+# wrong constant name <static-init>
+# wrong constant name convert
+# wrong constant name <static-init>
+# wrong constant name convert
+# wrong constant name <static-init>
+# wrong constant name convert
+# uninitialized constant ActiveRecord::LogSubscriber::BLACK
+# uninitialized constant ActiveRecord::LogSubscriber::BLUE
+# uninitialized constant ActiveRecord::LogSubscriber::BOLD
+# uninitialized constant ActiveRecord::LogSubscriber::CLEAR
+# uninitialized constant ActiveRecord::LogSubscriber::CYAN
+# uninitialized constant ActiveRecord::LogSubscriber::GREEN
+# uninitialized constant ActiveRecord::LogSubscriber::MAGENTA
+# uninitialized constant ActiveRecord::LogSubscriber::RED
+# uninitialized constant ActiveRecord::LogSubscriber::WHITE
+# uninitialized constant ActiveRecord::LogSubscriber::YELLOW
+# wrong constant name backtrace_cleaner
+# wrong constant name backtrace_cleaner=
+# wrong constant name backtrace_cleaner?
+# wrong constant name sql
+# wrong constant name <Class:Resolver>
+# wrong constant name call
+# wrong constant name context_klass
+# wrong constant name initialize
+# wrong constant name options
+# wrong constant name resolver_klass
+# wrong constant name <Class:Session>
+# wrong constant name context
+# wrong constant name delay
+# wrong constant name initialize
+# wrong constant name instrumenter
+# wrong constant name read
+# wrong constant name write
+# wrong constant name initialize
+# wrong constant name last_write_timestamp
+# wrong constant name session
+# wrong constant name update_last_write_timestamp
+# wrong constant name <static-init>
+# wrong constant name call
+# wrong constant name convert_time_to_timestamp
+# wrong constant name convert_timestamp_to_time
+# wrong constant name <static-init>
+# wrong constant name call
+# wrong constant name <static-init>
+# wrong constant name <Class:CommandRecorder>
+# wrong constant name <Class:StraightReversions>
+# wrong constant name add_belongs_to
+# wrong constant name add_column
+# wrong constant name add_foreign_key
+# wrong constant name add_index
+# wrong constant name add_reference
+# wrong constant name add_timestamps
+# wrong constant name change_column
+# wrong constant name change_column_comment
+# wrong constant name change_column_default
+# wrong constant name change_column_null
+# wrong constant name change_table
+# wrong constant name change_table_comment
+# wrong constant name commands
+# wrong constant name commands=
+# wrong constant name create_join_table
+# wrong constant name create_table
+# wrong constant name delegate
+# wrong constant name delegate=
+# wrong constant name disable_extension
+# wrong constant name drop_join_table
+# wrong constant name drop_table
+# wrong constant name enable_extension
+# wrong constant name execute
+# wrong constant name execute_block
+# wrong constant name initialize
+# wrong constant name inverse_of
+# wrong constant name invert_add_belongs_to
+# wrong constant name invert_remove_belongs_to
+# wrong constant name record
+# wrong constant name remove_belongs_to
+# wrong constant name remove_column
+# wrong constant name remove_columns
+# wrong constant name remove_foreign_key
+# wrong constant name remove_index
+# wrong constant name remove_reference
+# wrong constant name remove_timestamps
+# wrong constant name rename_column
+# wrong constant name rename_index
+# wrong constant name rename_table
+# wrong constant name replay
+# wrong constant name revert
+# wrong constant name reverting
+# wrong constant name reverting=
+# wrong constant name transaction
+# wrong constant name invert_add_column
+# wrong constant name invert_add_foreign_key
+# wrong constant name invert_add_reference
+# wrong constant name invert_add_timestamps
+# wrong constant name invert_create_join_table
+# wrong constant name invert_create_table
+# wrong constant name invert_disable_extension
+# wrong constant name invert_drop_join_table
+# wrong constant name invert_drop_table
+# wrong constant name invert_enable_extension
+# wrong constant name invert_execute_block
+# wrong constant name invert_remove_column
+# wrong constant name invert_remove_foreign_key
+# wrong constant name invert_remove_reference
+# wrong constant name invert_remove_timestamps
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Migration::Compatibility::V4_2::MigrationFilenameRegexp
+# wrong constant name <Class:TableDefinition>
+# wrong constant name index_exists?
+# wrong constant name remove_index
+# wrong constant name belongs_to
+# wrong constant name references
+# wrong constant name timestamps
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Migration::Compatibility::V5_0::MigrationFilenameRegexp
+# wrong constant name <Class:TableDefinition>
+# wrong constant name add_belongs_to
+# wrong constant name add_column
+# wrong constant name add_reference
+# wrong constant name create_join_table
+# wrong constant name belongs_to
+# wrong constant name primary_key
+# wrong constant name references
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Migration::Compatibility::V5_1::MigrationFilenameRegexp
+# wrong constant name change_column
+# wrong constant name <Class:CommandRecorder>
+# uninitialized constant ActiveRecord::Migration::Compatibility::V5_2::MigrationFilenameRegexp
+# wrong constant name <Class:TableDefinition>
+# wrong constant name add_timestamps
+# wrong constant name change_table
+# wrong constant name create_join_table
+# wrong constant name invert_change_column_comment
+# wrong constant name invert_change_table_comment
+# wrong constant name invert_transaction
+# wrong constant name <static-init>
+# wrong constant name timestamps
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name find
+# wrong constant name any?
+# wrong constant name calculate
+# wrong constant name delete
+# wrong constant name delete_all
+# wrong constant name empty?
+# wrong constant name exists?
+# wrong constant name many?
+# wrong constant name none?
+# wrong constant name one?
+# wrong constant name or
+# wrong constant name pluck
+# wrong constant name to_sql
+# wrong constant name update_all
+# wrong constant name <static-init>
+# uninitialized constant ActiveRecord::Relation::DEFAULT_VALUES
+# uninitialized constant ActiveRecord::Relation::FROZEN_EMPTY_ARRAY
+# uninitialized constant ActiveRecord::Relation::FROZEN_EMPTY_HASH
+# uninitialized constant ActiveRecord::Relation::ONE_AS_ONE
+# uninitialized constant ActiveRecord::Relation::ORDER_IGNORE_MESSAGE
+# uninitialized constant ActiveRecord::Relation::STRUCTURAL_OR_METHODS
+# uninitialized constant ActiveRecord::Relation::VALID_DIRECTIONS
+# uninitialized constant ActiveRecord::Relation::VALID_UNSCOPING_VALUES
+# wrong constant name connection_handler
+# wrong constant name connection_handler=
+# wrong constant name sql_runtime
+# wrong constant name sql_runtime=
+# wrong constant name <static-init>
+# wrong constant name connection_handler
+# wrong constant name connection_handler=
+# wrong constant name sql_runtime
+# wrong constant name sql_runtime=
+# wrong constant name set_value_for
+# wrong constant name value_for
+# wrong constant name suppressed
+# wrong constant name cache_dump_filename
+# wrong constant name charset
+# wrong constant name charset_current
+# wrong constant name check_protected_environments!
+# wrong constant name check_schema_file
+# wrong constant name check_target_version
+# wrong constant name collation
+# wrong constant name collation_current
+# wrong constant name create
+# wrong constant name create_all
+# wrong constant name create_current
+# wrong constant name current_config
+# wrong constant name current_config=
+# wrong constant name database_configuration
+# wrong constant name database_configuration=
+# wrong constant name db_dir
+# wrong constant name db_dir=
+# wrong constant name drop
+# wrong constant name drop_all
+# wrong constant name drop_current
+# wrong constant name dump_filename
+# wrong constant name dump_schema
+# wrong constant name dump_schema_cache
+# wrong constant name env
+# wrong constant name env=
+# wrong constant name fixtures_path
+# wrong constant name fixtures_path=
+# wrong constant name for_each
+# wrong constant name load_schema
+# wrong constant name load_schema_current
+# wrong constant name load_seed
+# wrong constant name migrate
+# wrong constant name migrate_status
+# wrong constant name migrations_paths
+# wrong constant name migrations_paths=
+# wrong constant name purge
+# wrong constant name purge_all
+# wrong constant name purge_current
+# wrong constant name raise_for_multi_db
+# wrong constant name reconstruct_from_schema
+# wrong constant name register_task
+# wrong constant name root
+# wrong constant name root=
+# wrong constant name schema_file
+# wrong constant name schema_file_type
+# wrong constant name schema_up_to_date?
+# wrong constant name seed_loader
+# wrong constant name seed_loader=
+# wrong constant name setup_initial_database_yaml
+# wrong constant name spec
+# wrong constant name structure_dump
+# wrong constant name structure_load
+# wrong constant name target_version
+# wrong constant name truncate_all
+# wrong constant name <static-init>
+# wrong constant name structure_dump_flags
+# wrong constant name structure_dump_flags=
+# wrong constant name structure_load_flags
+# wrong constant name structure_load_flags=
+# wrong constant name charset
+# wrong constant name collation
+# wrong constant name connection
+# wrong constant name create
+# wrong constant name drop
+# wrong constant name establish_connection
+# wrong constant name initialize
+# wrong constant name purge
+# wrong constant name structure_dump
+# wrong constant name structure_load
+# wrong constant name <static-init>
+# wrong constant name charset
+# wrong constant name clear_active_connections!
+# wrong constant name collation
+# wrong constant name connection
+# wrong constant name create
+# wrong constant name drop
+# wrong constant name establish_connection
+# wrong constant name initialize
+# wrong constant name purge
+# wrong constant name structure_dump
+# wrong constant name structure_load
+# wrong constant name <static-init>
+# wrong constant name charset
+# wrong constant name connection
+# wrong constant name create
+# wrong constant name drop
+# wrong constant name establish_connection
+# wrong constant name initialize
+# wrong constant name purge
+# wrong constant name structure_dump
+# wrong constant name structure_load
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name create_and_load_schema
+# wrong constant name <Class:ClassMethods>
+# wrong constant name after_teardown
+# wrong constant name before_setup
+# wrong constant name enlist_fixture_connections
+# wrong constant name run_in_transaction?
+# wrong constant name setup_fixtures
+# wrong constant name teardown_fixtures
+# wrong constant name fixtures
+# wrong constant name set_fixture_class
+# wrong constant name setup_fixture_accessors
+# wrong constant name uses_transaction
+# wrong constant name uses_transaction?
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::Deprecation::RAILS_GEM_ROOT
+# wrong constant name deprecation_horizon
+# wrong constant name deprecation_horizon=
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name hash_digest_class
+# wrong constant name hash_digest_class=
+# wrong constant name hexdigest
+# wrong constant name <Class:ISO8601Parser>
+# wrong constant name <Class:ISO8601Serializer>
+# wrong constant name <Class:ParsingError>
+# wrong constant name initialize
+# wrong constant name mode
+# wrong constant name mode=
+# wrong constant name parse!
+# wrong constant name parts
+# wrong constant name scanner
+# wrong constant name sign
+# wrong constant name sign=
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name serialize
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::ExecutionWrapper::CALLBACK_FILTER_TYPES
+# wrong constant name <Class:Stream>
+# uninitialized constant ActiveSupport::Gzip::Stream::Elem
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name compress
+# wrong constant name decompress
+# wrong constant name generate_key
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name colorize_logging
+# wrong constant name colorize_logging=
+# wrong constant name debug
+# wrong constant name error
+# wrong constant name fatal
+# wrong constant name info
+# wrong constant name logger
+# wrong constant name unknown
+# wrong constant name warn
+# wrong constant name <Class:InvalidMessage>
+# wrong constant name <Class:NullSerializer>
+# wrong constant name <Class:NullVerifier>
+# wrong constant name <Class:OpenSSLCipherError>
+# wrong constant name encrypt_and_sign
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name dump
+# wrong constant name load
+# wrong constant name <static-init>
+# wrong constant name generate
+# wrong constant name verify
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name default_cipher
+# wrong constant name key_len
+# wrong constant name use_authenticated_message_encryption
+# wrong constant name use_authenticated_message_encryption=
+# wrong constant name <Class:InvalidSignature>
+# wrong constant name generate
+# wrong constant name valid_message?
+# wrong constant name verify
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:Encryptor>
+# wrong constant name <Class:Verifier>
+# wrong constant name initialize
+# wrong constant name rotate
+# wrong constant name decrypt_and_verify
+# wrong constant name <static-init>
+# wrong constant name verified
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name compose
+# wrong constant name decompose
+# wrong constant name default_normalization_form
+# wrong constant name default_normalization_form=
+# wrong constant name downcase
+# wrong constant name normalize
+# wrong constant name pack_graphemes
+# wrong constant name swapcase
+# wrong constant name tidy_bytes
+# wrong constant name unpack_graphemes
+# wrong constant name upcase
+# wrong constant name <static-init>
+# wrong constant name execute
+# wrong constant name initialize
+# wrong constant name namespace
+# wrong constant name namespace=
+# wrong constant name namespace?
+# wrong constant name number
+# wrong constant name opts
+# wrong constant name validate_float
+# wrong constant name validate_float=
+# wrong constant name validate_float?
+# wrong constant name <static-init>
+# wrong constant name convert
+# wrong constant name namespace
+# wrong constant name namespace=
+# wrong constant name namespace?
+# wrong constant name validate_float
+# wrong constant name validate_float=
+# wrong constant name validate_float?
+# uninitialized constant ActiveSupport::NumberHelper::NumberToCurrencyConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToDelimitedConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToHumanConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToHumanSizeConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToPercentageConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToPhoneConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::NumberHelper::NumberToRoundedConverter::DEFAULTS
+# wrong constant name convert
+# wrong constant name <static-init>
+# wrong constant name digit_count
+# wrong constant name initialize
+# wrong constant name options
+# wrong constant name round
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::OrderedHash::Elem
+# uninitialized constant ActiveSupport::OrderedHash::K
+# uninitialized constant ActiveSupport::OrderedHash::V
+# wrong constant name encode_with
+# wrong constant name reject
+# wrong constant name select
+# wrong constant name to_yaml_type
+# wrong constant name <static-init>
+# wrong constant name <Class:ClassMethods>
+# wrong constant name handler_for_rescue
+# wrong constant name rescue_with_handler
+# wrong constant name handler_for_rescue
+# wrong constant name rescue_from
+# wrong constant name rescue_with_handler
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name %
+# wrong constant name *
+# wrong constant name +
+# wrong constant name <<
+# uninitialized constant ActiveSupport::SafeBuffer::BLANK_RE
+# uninitialized constant ActiveSupport::SafeBuffer::ENCODED_BLANKS
+# wrong constant name <Class:SafeConcatError>
+# wrong constant name []
+# wrong constant name []=
+# wrong constant name capitalize
+# wrong constant name capitalize!
+# wrong constant name chomp
+# wrong constant name chomp!
+# wrong constant name chop
+# wrong constant name chop!
+# wrong constant name clone_empty
+# wrong constant name concat
+# wrong constant name delete
+# wrong constant name delete!
+# wrong constant name delete_prefix
+# wrong constant name delete_prefix!
+# wrong constant name delete_suffix
+# wrong constant name delete_suffix!
+# wrong constant name downcase
+# wrong constant name downcase!
+# wrong constant name encode_with
+# wrong constant name gsub
+# wrong constant name gsub!
+# wrong constant name initialize
+# wrong constant name insert
+# wrong constant name lstrip
+# wrong constant name lstrip!
+# wrong constant name next
+# wrong constant name next!
+# wrong constant name prepend
+# wrong constant name replace
+# wrong constant name reverse
+# wrong constant name reverse!
+# wrong constant name rstrip
+# wrong constant name rstrip!
+# wrong constant name safe_concat
+# wrong constant name slice
+# wrong constant name slice!
+# wrong constant name squeeze
+# wrong constant name squeeze!
+# wrong constant name strip
+# wrong constant name strip!
+# wrong constant name sub
+# wrong constant name sub!
+# wrong constant name succ
+# wrong constant name succ!
+# wrong constant name swapcase
+# wrong constant name swapcase!
+# wrong constant name tr
+# wrong constant name tr!
+# wrong constant name tr_s
+# wrong constant name tr_s!
+# wrong constant name unicode_normalize
+# wrong constant name unicode_normalize!
+# wrong constant name upcase
+# wrong constant name upcase!
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ActiveSupport::StringInquirer::BLANK_RE
+# uninitialized constant ActiveSupport::StringInquirer::ENCODED_BLANKS
+# wrong constant name <static-init>
+# wrong constant name finish
+# wrong constant name patterns
+# wrong constant name start
+# wrong constant name <Class:Formatter>
+# wrong constant name clear_tags!
+# wrong constant name flush
+# wrong constant name pop_tags
+# wrong constant name push_tags
+# wrong constant name tagged
+# wrong constant name call
+# wrong constant name clear_tags!
+# wrong constant name current_tags
+# wrong constant name pop_tags
+# wrong constant name push_tags
+# wrong constant name tagged
+# wrong constant name tags_text
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name new
+# wrong constant name <Class:Assertion>
+# uninitialized constant ActiveSupport::TestCase::CALLBACK_FILTER_TYPES
+# uninitialized constant ActiveSupport::TestCase::E
+# uninitialized constant ActiveSupport::TestCase::PASSTHROUGH_EXCEPTIONS
+# uninitialized constant ActiveSupport::TestCase::SIGNALS
+# uninitialized constant ActiveSupport::TestCase::TEARDOWN_METHODS
+# uninitialized constant ActiveSupport::TestCase::UNDEFINED
+# uninitialized constant ActiveSupport::TestCase::UNTRACKED
+# wrong constant name __callbacks
+# wrong constant name __callbacks?
+# wrong constant name _run_setup_callbacks
+# wrong constant name _run_teardown_callbacks
+# wrong constant name _setup_callbacks
+# wrong constant name _teardown_callbacks
+# wrong constant name assert_no_match
+# wrong constant name assert_not_empty
+# wrong constant name assert_not_equal
+# wrong constant name assert_not_in_delta
+# wrong constant name assert_not_in_epsilon
+# wrong constant name assert_not_includes
+# wrong constant name assert_not_instance_of
+# wrong constant name assert_not_kind_of
+# wrong constant name assert_not_nil
+# wrong constant name assert_not_operator
+# wrong constant name assert_not_predicate
+# wrong constant name assert_not_respond_to
+# wrong constant name assert_not_same
+# wrong constant name assert_raise
+# wrong constant name file_fixture_path
+# wrong constant name file_fixture_path?
+# wrong constant name method_name
+# wrong constant name error
+# wrong constant name location
+# wrong constant name result_code
+# wrong constant name result_label
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name __callbacks
+# wrong constant name __callbacks=
+# wrong constant name __callbacks?
+# wrong constant name _setup_callbacks
+# wrong constant name _setup_callbacks=
+# wrong constant name _teardown_callbacks
+# wrong constant name _teardown_callbacks=
+# wrong constant name file_fixture_path
+# wrong constant name file_fixture_path=
+# wrong constant name file_fixture_path?
+# wrong constant name parallelize
+# wrong constant name parallelize_setup
+# wrong constant name parallelize_teardown
+# wrong constant name test_order=
+# wrong constant name <Class:Assertions>
+# wrong constant name <Class:ConstantLookup>
+# wrong constant name <Class:Declarative>
+# wrong constant name <Class:Deprecation>
+# wrong constant name <Class:FileFixtures>
+# wrong constant name <Class:Isolation>
+# wrong constant name <Class:Parallelization>
+# wrong constant name <Class:SetupAndTeardown>
+# wrong constant name <Class:SimpleStubs>
+# wrong constant name <Class:TaggedLogging>
+# wrong constant name <Class:TimeHelpers>
+# wrong constant name assert_changes
+# wrong constant name assert_difference
+# wrong constant name assert_no_changes
+# wrong constant name assert_no_difference
+# wrong constant name assert_not
+# wrong constant name assert_nothing_raised
+# wrong constant name <static-init>
+# wrong constant name <Class:ClassMethods>
+# wrong constant name determine_constant_from_test_name
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name test
+# wrong constant name <static-init>
+# wrong constant name assert_deprecated
+# wrong constant name assert_not_deprecated
+# wrong constant name collect_deprecations
+# wrong constant name <static-init>
+# wrong constant name file_fixture
+# wrong constant name <static-init>
+# wrong constant name <Class:Forking>
+# wrong constant name <Class:Subprocess>
+# wrong constant name run
+# wrong constant name run_in_isolation
+# wrong constant name <static-init>
+# wrong constant name run_in_isolation
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name forking_env?
+# wrong constant name included
+# wrong constant name <<
+# wrong constant name <Class:Server>
+# wrong constant name after_fork
+# wrong constant name after_fork_hooks
+# wrong constant name initialize
+# wrong constant name run_cleanup
+# wrong constant name run_cleanup_hooks
+# wrong constant name shutdown
+# wrong constant name start
+# wrong constant name <<
+# wrong constant name length
+# wrong constant name pop
+# wrong constant name record
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name after_fork_hook
+# wrong constant name after_fork_hooks
+# wrong constant name run_cleanup_hook
+# wrong constant name run_cleanup_hooks
+# wrong constant name after_teardown
+# wrong constant name before_setup
+# wrong constant name <static-init>
+# wrong constant name prepended
+# wrong constant name <Class:Stub>
+# wrong constant name stub_object
+# wrong constant name stubbing
+# wrong constant name unstub_all!
+# uninitialized constant ActiveSupport::Testing::SimpleStubs::Stub::Elem
+# wrong constant name method_name
+# wrong constant name method_name=
+# wrong constant name object
+# wrong constant name object=
+# wrong constant name original_method
+# wrong constant name original_method=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <static-init>
+# wrong constant name before_setup
+# wrong constant name tagged_logger=
+# wrong constant name <static-init>
+# wrong constant name after_teardown
+# wrong constant name freeze_time
+# wrong constant name travel
+# wrong constant name travel_back
+# wrong constant name travel_to
+# wrong constant name unfreeze_time
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name shelljoin
+# wrong constant name to_h
+# wrong constant name wrap
+# wrong constant name <Class:BasicObject>
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name to_a
+# uninitialized constant BigDecimal::EXABYTE
+# uninitialized constant BigDecimal::GIGABYTE
+# uninitialized constant BigDecimal::KILOBYTE
+# uninitialized constant BigDecimal::MEGABYTE
+# uninitialized constant BigDecimal::PETABYTE
+# uninitialized constant BigDecimal::TERABYTE
+# wrong constant name clone
+# wrong constant name to_digits
+# wrong constant name new
+# wrong constant name clone
+# wrong constant name irb
+# uninitialized constant Bundler::Dependency::TYPES
+# wrong constant name branch
+# wrong constant name expanded_platforms
+# wrong constant name git
+# wrong constant name <static-init>
+# wrong constant name environment
+# wrong constant name report
+# wrong constant name write
+# wrong constant name <Class:Base>
+# wrong constant name <Class:CompactIndex>
+# wrong constant name <Class:Dependency>
+# wrong constant name <Class:Downloader>
+# wrong constant name <Class:Index>
+# wrong constant name <Class:TooManyRequestsError>
+# wrong constant name fetch_spec
+# wrong constant name fetchers
+# wrong constant name http_proxy
+# wrong constant name initialize
+# wrong constant name specs
+# wrong constant name specs_with_retry
+# wrong constant name uri
+# wrong constant name use_api
+# wrong constant name user_agent
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name api_fetcher?
+# wrong constant name available?
+# wrong constant name display_uri
+# wrong constant name downloader
+# wrong constant name fetch_uri
+# wrong constant name initialize
+# wrong constant name remote
+# wrong constant name remote_uri
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <Class:ClientFetcher>
+# wrong constant name available?
+# wrong constant name fetch_spec
+# wrong constant name specs
+# wrong constant name specs_for_names
+# uninitialized constant Bundler::Fetcher::CompactIndex::ClientFetcher::Elem
+# wrong constant name call
+# wrong constant name fetcher
+# wrong constant name fetcher=
+# wrong constant name ui
+# wrong constant name ui=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <static-init>
+# wrong constant name compact_index_request
+# wrong constant name dependency_api_uri
+# wrong constant name dependency_specs
+# wrong constant name get_formatted_specs_and_deps
+# wrong constant name specs
+# wrong constant name unmarshalled_dep_gems
+# wrong constant name <static-init>
+# wrong constant name connection
+# wrong constant name fetch
+# wrong constant name initialize
+# wrong constant name redirect_limit
+# wrong constant name request
+# wrong constant name <static-init>
+# wrong constant name fetch_spec
+# wrong constant name specs
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name api_timeout
+# wrong constant name api_timeout=
+# wrong constant name disable_endpoint
+# wrong constant name disable_endpoint=
+# wrong constant name max_retries
+# wrong constant name max_retries=
+# wrong constant name redirect_limit
+# wrong constant name redirect_limit=
+# wrong constant name link
+# wrong constant name cp_lr
+# wrong constant name link_entry
+# uninitialized constant Bundler::GemHelper::DEFAULT
+# uninitialized constant Bundler::GemHelper::LN_SUPPORTED
+# uninitialized constant Bundler::GemHelper::LOW_METHODS
+# uninitialized constant Bundler::GemHelper::METHODS
+# uninitialized constant Bundler::GemHelper::OPT_TABLE
+# uninitialized constant Bundler::GemHelper::RUBY
+# uninitialized constant Bundler::GemHelper::VERSION
+# wrong constant name allowed_push_host
+# wrong constant name already_tagged?
+# wrong constant name base
+# wrong constant name build_gem
+# wrong constant name built_gem_path
+# wrong constant name clean?
+# wrong constant name committed?
+# wrong constant name gem_command
+# wrong constant name gem_key
+# wrong constant name gem_push?
+# wrong constant name gem_push_host
+# wrong constant name gemspec
+# wrong constant name git_push
+# wrong constant name guard_clean
+# wrong constant name initialize
+# wrong constant name install
+# wrong constant name install_gem
+# wrong constant name name
+# wrong constant name perform_git_push
+# wrong constant name rubygem_push
+# wrong constant name sh
+# wrong constant name sh_with_input
+# wrong constant name sh_with_status
+# wrong constant name spec_path
+# wrong constant name tag_version
+# wrong constant name version
+# wrong constant name version_tag
+# wrong constant name <static-init>
+# wrong constant name gemspec
+# wrong constant name install_tasks
+# wrong constant name instance
+# wrong constant name instance=
+# wrong constant name initialize
+# wrong constant name level
+# wrong constant name level=
+# wrong constant name locked_specs
+# wrong constant name major?
+# wrong constant name minor?
+# wrong constant name prerelease_specified
+# wrong constant name prerelease_specified=
+# wrong constant name sort_versions
+# wrong constant name strict
+# wrong constant name strict=
+# wrong constant name unlock_gems
+# wrong constant name <static-init>
+# wrong constant name <Class:GraphVizClient>
+# wrong constant name edge_options
+# wrong constant name groups
+# wrong constant name initialize
+# wrong constant name node_options
+# wrong constant name output_file
+# wrong constant name output_format
+# wrong constant name relations
+# wrong constant name viz
+# wrong constant name g
+# wrong constant name initialize
+# wrong constant name run
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name inject
+# wrong constant name remove
+# wrong constant name <static-init>
+# wrong constant name inject
+# wrong constant name remove
+# wrong constant name generate_bundler_executable_stubs
+# wrong constant name generate_standalone_bundler_executable_stubs
+# wrong constant name initialize
+# wrong constant name post_install_messages
+# wrong constant name run
+# wrong constant name <static-init>
+# wrong constant name ambiguous_gems
+# wrong constant name ambiguous_gems=
+# wrong constant name install
+# wrong constant name _recursive_predecessors
+# wrong constant name _recursive_successors
+# wrong constant name ==
+# wrong constant name app_cache_dirname
+# wrong constant name app_cache_path
+# wrong constant name bundler_plugin_api_source?
+# wrong constant name cache
+# wrong constant name cached!
+# wrong constant name can_lock?
+# wrong constant name dependency_names
+# wrong constant name dependency_names=
+# wrong constant name double_check_for
+# wrong constant name eql?
+# wrong constant name fetch_gemspec_files
+# wrong constant name gem_install_dir
+# wrong constant name hash
+# wrong constant name include?
+# wrong constant name initialize
+# wrong constant name install
+# wrong constant name install_path
+# wrong constant name installed?
+# wrong constant name name
+# wrong constant name options
+# wrong constant name options_to_lock
+# wrong constant name post_install
+# wrong constant name remote!
+# wrong constant name root
+# wrong constant name specs
+# wrong constant name to_lock
+# wrong constant name to_s
+# wrong constant name unlock!
+# wrong constant name unmet_deps
+# wrong constant name uri
+# wrong constant name uri_hash
+# wrong constant name <static-init>
+# wrong constant name <Class:CommandConflict>
+# wrong constant name <Class:SourceConflict>
+# wrong constant name installed_plugins
+# wrong constant name plugin_commands
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <Class:Git>
+# wrong constant name <Class:Rubygems>
+# wrong constant name install
+# wrong constant name install_definition
+# uninitialized constant Bundler::Plugin::Installer::Git::DEFAULT_GLOB
+# wrong constant name generate_bin
+# wrong constant name <static-init>
+# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT
+# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name list
+# wrong constant name <static-init>
+# wrong constant name lock
+# wrong constant name attempt
+# wrong constant name attempts
+# wrong constant name current_run
+# wrong constant name current_run=
+# wrong constant name initialize
+# wrong constant name name
+# wrong constant name name=
+# wrong constant name total_runs
+# wrong constant name total_runs=
+# wrong constant name <static-init>
+# wrong constant name attempts
+# wrong constant name default_attempts
+# wrong constant name default_retries
+# uninitialized constant Bundler::RubyGemsGemInstaller::ENV_PATHS
+# wrong constant name <static-init>
+# wrong constant name add_to_load_path
+# wrong constant name all_specs
+# wrong constant name backport_ext_builder_monitor
+# wrong constant name correct_for_windows_path
+# wrong constant name default_stubs
+# wrong constant name find_name
+# wrong constant name gem_remote_fetcher
+# wrong constant name plain_specs
+# wrong constant name plain_specs=
+# wrong constant name stub_rubygems
+# wrong constant name use_gemdeps
+# uninitialized constant Bundler::RubygemsIntegration::AlmostModern
+# uninitialized constant Bundler::RubygemsIntegration::AlmostModern
+# uninitialized constant Bundler::RubygemsIntegration::Ancient
+# uninitialized constant Bundler::RubygemsIntegration::Ancient
+# uninitialized constant Bundler::RubygemsIntegration::Future
+# uninitialized constant Bundler::RubygemsIntegration::Future
+# uninitialized constant Bundler::RubygemsIntegration::Legacy
+# uninitialized constant Bundler::RubygemsIntegration::Legacy
+# uninitialized constant Bundler::RubygemsIntegration::Modern
+# uninitialized constant Bundler::RubygemsIntegration::Modern
+# uninitialized constant Bundler::RubygemsIntegration::MoreFuture
+# uninitialized constant Bundler::RubygemsIntegration::MoreFuture
+# uninitialized constant Bundler::RubygemsIntegration::MoreModern
+# uninitialized constant Bundler::RubygemsIntegration::MoreModern
+# uninitialized constant Bundler::RubygemsIntegration::Transitional
+# uninitialized constant Bundler::RubygemsIntegration::Transitional
+# wrong constant name ==
+# wrong constant name fallback_timeout
+# wrong constant name fallback_timeout=
+# wrong constant name initialize
+# wrong constant name uri
+# wrong constant name uri=
+# wrong constant name valid?
+# wrong constant name validate!
+# wrong constant name <static-init>
+# wrong constant name each
+# wrong constant name for
+# wrong constant name initialize
+# wrong constant name parse
+# wrong constant name <static-init>
+# wrong constant name <Class:Rule>
+# wrong constant name description
+# wrong constant name fail!
+# wrong constant name initialize
+# wrong constant name k
+# wrong constant name set
+# wrong constant name validate!
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name validate!
+# uninitialized constant Bundler::Source::Git::DEFAULT_GLOB
+# wrong constant name glob
+# wrong constant name <Class:Actions>
+# wrong constant name <Class:AmbiguousCommandError>
+# wrong constant name <Class:Argument>
+# wrong constant name <Class:Arguments>
+# wrong constant name <Class:Base>
+# wrong constant name <Class:Command>
+# wrong constant name <Class:CoreExt>
+# wrong constant name <Class:DynamicCommand>
+# wrong constant name <Class:Error>
+# wrong constant name <Class:Group>
+# wrong constant name <Class:HiddenCommand>
+# wrong constant name <Class:Invocation>
+# wrong constant name <Class:InvocationError>
+# wrong constant name <Class:LineEditor>
+# wrong constant name <Class:MalformattedArgumentError>
+# wrong constant name <Class:NestedContext>
+# wrong constant name <Class:NoKwargSpellChecker>
+# wrong constant name <Class:Option>
+# wrong constant name <Class:Options>
+# wrong constant name <Class:RakeCompat>
+# wrong constant name <Class:RequiredArgumentMissingError>
+# uninitialized constant Bundler::Thor::SHELL_DELEGATED_METHODS
+# wrong constant name <Class:Sandbox>
+# wrong constant name <Class:Shell>
+# wrong constant name <Class:UndefinedCommandError>
+# wrong constant name <Class:UnknownArgumentError>
+# wrong constant name <Class:Util>
+# wrong constant name help
+# wrong constant name <Class:CapturableERB>
+# wrong constant name <Class:ClassMethods>
+# wrong constant name <Class:CreateFile>
+# wrong constant name <Class:CreateLink>
+# wrong constant name <Class:Directory>
+# wrong constant name <Class:EmptyDirectory>
+# wrong constant name <Class:InjectIntoFile>
+# wrong constant name _cleanup_options_and_set
+# wrong constant name _shared_configuration
+# wrong constant name action
+# wrong constant name add_file
+# wrong constant name add_link
+# wrong constant name append_file
+# wrong constant name append_to_file
+# wrong constant name apply
+# wrong constant name behavior
+# wrong constant name behavior=
+# wrong constant name chmod
+# wrong constant name comment_lines
+# wrong constant name copy_file
+# wrong constant name create_file
+# wrong constant name create_link
+# wrong constant name destination_root
+# wrong constant name destination_root=
+# wrong constant name directory
+# wrong constant name empty_directory
+# wrong constant name find_in_source_paths
+# wrong constant name get
+# wrong constant name gsub_file
+# wrong constant name in_root
+# wrong constant name initialize
+# wrong constant name inject_into_class
+# wrong constant name inject_into_file
+# wrong constant name inject_into_module
+# wrong constant name insert_into_file
+# wrong constant name inside
+# wrong constant name link_file
+# wrong constant name prepend_file
+# wrong constant name prepend_to_file
+# wrong constant name relative_to_original_destination_root
+# wrong constant name remove_dir
+# wrong constant name remove_file
+# wrong constant name run
+# wrong constant name run_ruby_script
+# wrong constant name source_paths
+# wrong constant name template
+# wrong constant name thor
+# wrong constant name uncomment_lines
+# uninitialized constant Bundler::Thor::Actions::CapturableERB::Revision
+# wrong constant name <static-init>
+# wrong constant name add_runtime_options!
+# wrong constant name source_paths
+# wrong constant name source_paths_for_search
+# wrong constant name source_root
+# wrong constant name <static-init>
+# wrong constant name data
+# wrong constant name force_on_collision?
+# wrong constant name force_or_skip_or_conflict
+# wrong constant name identical?
+# wrong constant name initialize
+# wrong constant name on_conflict_behavior
+# wrong constant name render
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name execute!
+# wrong constant name file_level_lookup
+# wrong constant name files
+# wrong constant name initialize
+# wrong constant name source
+# wrong constant name <static-init>
+# wrong constant name base
+# wrong constant name config
+# wrong constant name convert_encoded_instructions
+# wrong constant name destination
+# wrong constant name destination=
+# wrong constant name exists?
+# wrong constant name given_destination
+# wrong constant name initialize
+# wrong constant name invoke!
+# wrong constant name invoke_with_conflict_check
+# wrong constant name on_conflict_behavior
+# wrong constant name on_file_clash_behavior
+# wrong constant name pretend?
+# wrong constant name relative_destination
+# wrong constant name revoke!
+# wrong constant name say_status
+# wrong constant name <static-init>
+# wrong constant name behavior
+# wrong constant name flag
+# wrong constant name initialize
+# wrong constant name replace!
+# wrong constant name replacement
+# wrong constant name say_status
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name <static-init>
+# wrong constant name banner
+# wrong constant name default
+# wrong constant name default_banner
+# wrong constant name description
+# wrong constant name enum
+# wrong constant name human_name
+# wrong constant name initialize
+# wrong constant name name
+# wrong constant name required
+# wrong constant name required?
+# wrong constant name show_default?
+# wrong constant name type
+# wrong constant name usage
+# wrong constant name valid_type?
+# wrong constant name validate!
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name parse
+# wrong constant name remaining
+# wrong constant name <static-init>
+# wrong constant name parse
+# wrong constant name split
+# wrong constant name <Class:ClassMethods>
+# wrong constant name args
+# wrong constant name args=
+# wrong constant name initialize
+# wrong constant name options
+# wrong constant name options=
+# wrong constant name parent_options
+# wrong constant name parent_options=
+# wrong constant name all_commands
+# wrong constant name all_tasks
+# wrong constant name allow_incompatible_default_type!
+# wrong constant name argument
+# wrong constant name arguments
+# wrong constant name attr_accessor
+# wrong constant name attr_reader
+# wrong constant name attr_writer
+# wrong constant name baseclass
+# wrong constant name basename
+# wrong constant name build_option
+# wrong constant name build_options
+# wrong constant name check_default_type
+# wrong constant name check_default_type!
+# wrong constant name check_unknown_options
+# wrong constant name check_unknown_options!
+# wrong constant name check_unknown_options?
+# wrong constant name class_option
+# wrong constant name class_options
+# wrong constant name class_options_help
+# wrong constant name commands
+# wrong constant name create_command
+# wrong constant name create_task
+# wrong constant name disable_required_check?
+# wrong constant name dispatch
+# wrong constant name exit_on_failure?
+# wrong constant name find_and_refresh_command
+# wrong constant name find_and_refresh_task
+# wrong constant name from_superclass
+# wrong constant name group
+# wrong constant name handle_argument_error
+# wrong constant name handle_no_command_error
+# wrong constant name handle_no_task_error
+# wrong constant name inherited
+# wrong constant name initialize_added
+# wrong constant name is_thor_reserved_word?
+# wrong constant name method_added
+# wrong constant name namespace
+# wrong constant name no_commands
+# wrong constant name no_commands?
+# wrong constant name no_commands_context
+# wrong constant name no_tasks
+# wrong constant name print_options
+# wrong constant name public_command
+# wrong constant name public_task
+# wrong constant name remove_argument
+# wrong constant name remove_class_option
+# wrong constant name remove_command
+# wrong constant name remove_task
+# wrong constant name start
+# wrong constant name stop_on_unknown_option?
+# wrong constant name strict_args_position
+# wrong constant name strict_args_position!
+# wrong constant name strict_args_position?
+# wrong constant name tasks
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name register_klass_file
+# wrong constant name shell
+# wrong constant name shell=
+# wrong constant name subclass_files
+# wrong constant name subclasses
+# wrong constant name formatted_usage
+# wrong constant name handle_argument_error?
+# wrong constant name handle_no_method_error?
+# wrong constant name hidden?
+# wrong constant name initialize
+# wrong constant name local_method?
+# wrong constant name not_debugging?
+# wrong constant name private_method?
+# wrong constant name public_method?
+# wrong constant name required_arguments_for
+# wrong constant name required_options
+# wrong constant name run
+# wrong constant name sans_backtrace
+# wrong constant name <static-init>
+# wrong constant name <Class:HashWithIndifferentAccess>
+# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::Elem
+# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::K
+# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::V
+# wrong constant name []
+# wrong constant name []=
+# wrong constant name convert_key
+# wrong constant name delete
+# wrong constant name fetch
+# wrong constant name initialize
+# wrong constant name key?
+# wrong constant name merge
+# wrong constant name merge!
+# wrong constant name method_missing
+# wrong constant name replace
+# wrong constant name reverse_merge
+# wrong constant name values_at
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant Bundler::Thor::DynamicCommand::FILE_REGEXP
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant Bundler::Thor::Group::SHELL_DELEGATED_METHODS
+# wrong constant name _invoke_for_class_method
+# wrong constant name <static-init>
+# wrong constant name banner
+# wrong constant name desc
+# wrong constant name get_options_from_invocations
+# wrong constant name handle_argument_error
+# wrong constant name help
+# wrong constant name invocation_blocks
+# wrong constant name invocations
+# wrong constant name invoke
+# wrong constant name invoke_from_option
+# wrong constant name printable_commands
+# wrong constant name printable_tasks
+# wrong constant name remove_invocation
+# wrong constant name self_command
+# wrong constant name self_task
+# uninitialized constant Bundler::Thor::HiddenCommand::FILE_REGEXP
+# wrong constant name <static-init>
+# wrong constant name <Class:ClassMethods>
+# wrong constant name _parse_initialization_options
+# wrong constant name _retrieve_class_and_command
+# wrong constant name _retrieve_class_and_task
+# wrong constant name _shared_configuration
+# wrong constant name current_command_chain
+# wrong constant name initialize
+# wrong constant name invoke
+# wrong constant name invoke_all
+# wrong constant name invoke_command
+# wrong constant name invoke_task
+# wrong constant name invoke_with_padding
+# wrong constant name prepare_for_invocation
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name <static-init>
+# wrong constant name <Class:Basic>
+# wrong constant name <Class:Readline>
+# wrong constant name initialize
+# wrong constant name options
+# wrong constant name prompt
+# wrong constant name readline
+# wrong constant name <static-init>
+# wrong constant name available?
+# wrong constant name <Class:PathCompletion>
+# wrong constant name initialize
+# wrong constant name matches
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name best_available
+# wrong constant name readline
+# wrong constant name <static-init>
+# wrong constant name enter
+# wrong constant name entered?
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name aliases
+# wrong constant name array?
+# wrong constant name boolean?
+# wrong constant name dasherize
+# wrong constant name dasherized?
+# wrong constant name group
+# wrong constant name hash?
+# wrong constant name hide
+# wrong constant name lazy_default
+# wrong constant name numeric?
+# wrong constant name repeatable
+# wrong constant name string?
+# wrong constant name switch_name
+# wrong constant name undasherize
+# wrong constant name usage
+# wrong constant name validate_default_type!
+# wrong constant name <static-init>
+# wrong constant name parse
+# uninitialized constant Bundler::Thor::Options::NUMERIC
+# wrong constant name assign_result!
+# wrong constant name check_unknown!
+# wrong constant name current_is_switch?
+# wrong constant name current_is_switch_formatted?
+# wrong constant name initialize
+# wrong constant name normalize_switch
+# wrong constant name parse_boolean
+# wrong constant name parse_peek
+# wrong constant name parsing_options?
+# wrong constant name switch?
+# wrong constant name switch_option
+# wrong constant name <static-init>
+# wrong constant name to_switches
+# uninitialized constant Bundler::Thor::RakeCompat::DEFAULT
+# uninitialized constant Bundler::Thor::RakeCompat::LN_SUPPORTED
+# uninitialized constant Bundler::Thor::RakeCompat::LOW_METHODS
+# uninitialized constant Bundler::Thor::RakeCompat::METHODS
+# uninitialized constant Bundler::Thor::RakeCompat::OPT_TABLE
+# uninitialized constant Bundler::Thor::RakeCompat::RUBY
+# uninitialized constant Bundler::Thor::RakeCompat::VERSION
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name rake_classes
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:Basic>
+# wrong constant name <Class:Color>
+# wrong constant name <Class:HTML>
+# wrong constant name _shared_configuration
+# wrong constant name ask
+# wrong constant name error
+# wrong constant name file_collision
+# wrong constant name initialize
+# wrong constant name no?
+# wrong constant name print_in_columns
+# wrong constant name print_table
+# wrong constant name print_wrapped
+# wrong constant name say
+# wrong constant name say_status
+# wrong constant name set_color
+# wrong constant name shell
+# wrong constant name shell=
+# wrong constant name terminal_width
+# wrong constant name with_padding
+# wrong constant name yes?
+# wrong constant name answer_match
+# wrong constant name as_unicode
+# wrong constant name ask
+# wrong constant name ask_filtered
+# wrong constant name ask_simply
+# wrong constant name base
+# wrong constant name base=
+# wrong constant name can_display_colors?
+# wrong constant name dynamic_width
+# wrong constant name dynamic_width_stty
+# wrong constant name dynamic_width_tput
+# wrong constant name error
+# wrong constant name file_collision
+# wrong constant name file_collision_help
+# wrong constant name git_merge_tool
+# wrong constant name indent
+# wrong constant name is?
+# wrong constant name lookup_color
+# wrong constant name merge
+# wrong constant name merge_tool
+# wrong constant name mute
+# wrong constant name mute?
+# wrong constant name no?
+# wrong constant name padding
+# wrong constant name padding=
+# wrong constant name prepare_message
+# wrong constant name print_in_columns
+# wrong constant name print_table
+# wrong constant name print_wrapped
+# wrong constant name quiet?
+# wrong constant name say
+# wrong constant name say_status
+# wrong constant name set_color
+# wrong constant name show_diff
+# wrong constant name stderr
+# wrong constant name stdout
+# wrong constant name terminal_width
+# wrong constant name truncate
+# wrong constant name unix?
+# wrong constant name yes?
+# wrong constant name <static-init>
+# uninitialized constant Bundler::Thor::Shell::Color::DEFAULT_TERMINAL_WIDTH
+# wrong constant name are_colors_disabled?
+# wrong constant name diff_lcs_loaded?
+# wrong constant name output_diff_line
+# wrong constant name set_color
+# wrong constant name <static-init>
+# uninitialized constant Bundler::Thor::Shell::HTML::DEFAULT_TERMINAL_WIDTH
+# wrong constant name ask
+# wrong constant name diff_lcs_loaded?
+# wrong constant name output_diff_line
+# wrong constant name set_color
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:SpellChecker>
+# wrong constant name all_commands
+# wrong constant name command
+# wrong constant name initialize
+# wrong constant name corrections
+# wrong constant name error
+# wrong constant name initialize
+# wrong constant name spell_checker
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:SpellChecker>
+# wrong constant name initialize
+# wrong constant name switches
+# wrong constant name unknown
+# wrong constant name corrections
+# wrong constant name error
+# wrong constant name initialize
+# wrong constant name spell_checker
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name camel_case
+# wrong constant name escape_globs
+# wrong constant name escape_html
+# wrong constant name find_by_namespace
+# wrong constant name find_class_and_command_by_namespace
+# wrong constant name find_class_and_task_by_namespace
+# wrong constant name globs_for
+# wrong constant name load_thorfile
+# wrong constant name namespace_from_thor_class
+# wrong constant name namespaces_in_content
+# wrong constant name ruby_command
+# wrong constant name snake_case
+# wrong constant name thor_classes_in
+# wrong constant name thor_root
+# wrong constant name thor_root_glob
+# wrong constant name user_home
+# wrong constant name <static-init>
+# wrong constant name banner
+# wrong constant name check_unknown_options!
+# wrong constant name command_help
+# wrong constant name default_command
+# wrong constant name default_task
+# wrong constant name deprecation_warning
+# wrong constant name desc
+# wrong constant name disable_required_check
+# wrong constant name disable_required_check!
+# wrong constant name disable_required_check?
+# wrong constant name dispatch
+# wrong constant name dynamic_command_class
+# wrong constant name find_command_possibilities
+# wrong constant name find_task_possibilities
+# wrong constant name help
+# wrong constant name long_desc
+# wrong constant name map
+# wrong constant name method_option
+# wrong constant name method_options
+# wrong constant name normalize_command_name
+# wrong constant name normalize_task_name
+# wrong constant name option
+# wrong constant name options
+# wrong constant name package_name
+# wrong constant name printable_commands
+# wrong constant name printable_tasks
+# wrong constant name register
+# wrong constant name retrieve_command_name
+# wrong constant name retrieve_task_name
+# wrong constant name stop_on_unknown_option
+# wrong constant name stop_on_unknown_option!
+# wrong constant name stop_on_unknown_option?
+# wrong constant name subcommand
+# wrong constant name subcommand_classes
+# wrong constant name subcommand_help
+# wrong constant name subcommands
+# wrong constant name subtask
+# wrong constant name subtask_help
+# wrong constant name subtasks
+# wrong constant name task_help
+# wrong constant name add_color
+# wrong constant name ask
+# wrong constant name confirm
+# wrong constant name debug
+# wrong constant name debug?
+# wrong constant name error
+# wrong constant name info
+# wrong constant name initialize
+# wrong constant name level
+# wrong constant name level=
+# wrong constant name no?
+# wrong constant name quiet?
+# wrong constant name shell=
+# wrong constant name silence
+# wrong constant name trace
+# wrong constant name unprinted_warnings
+# wrong constant name warn
+# wrong constant name yes?
+# wrong constant name <static-init>
+# wrong constant name <Class:BadURIError>
+# wrong constant name <Class:Error>
+# wrong constant name <Class:Escape>
+# wrong constant name <Class:FTP>
+# wrong constant name <Class:File>
+# wrong constant name <Class:Generic>
+# wrong constant name <Class:HTTP>
+# wrong constant name <Class:HTTPS>
+# wrong constant name <Class:InvalidComponentError>
+# wrong constant name <Class:InvalidURIError>
+# wrong constant name <Class:LDAP>
+# wrong constant name <Class:LDAPS>
+# wrong constant name <Class:MailTo>
+# wrong constant name <Class:RFC2396_Parser>
+# wrong constant name <Class:RFC2396_REGEXP>
+# wrong constant name <Class:RFC3986_Parser>
+# wrong constant name <Class:Util>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name decode
+# wrong constant name encode
+# wrong constant name escape
+# wrong constant name unescape
+# wrong constant name <static-init>
+# uninitialized constant Bundler::URI::FTP::ABS_PATH
+# uninitialized constant Bundler::URI::FTP::ABS_URI
+# uninitialized constant Bundler::URI::FTP::ABS_URI_REF
+# uninitialized constant Bundler::URI::FTP::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::FTP::ESCAPED
+# uninitialized constant Bundler::URI::FTP::FRAGMENT
+# uninitialized constant Bundler::URI::FTP::HOST
+# uninitialized constant Bundler::URI::FTP::OPAQUE
+# uninitialized constant Bundler::URI::FTP::PORT
+# uninitialized constant Bundler::URI::FTP::QUERY
+# uninitialized constant Bundler::URI::FTP::REGISTRY
+# uninitialized constant Bundler::URI::FTP::REL_PATH
+# uninitialized constant Bundler::URI::FTP::REL_URI
+# uninitialized constant Bundler::URI::FTP::REL_URI_REF
+# uninitialized constant Bundler::URI::FTP::RFC3986_PARSER
+# uninitialized constant Bundler::URI::FTP::SCHEME
+# uninitialized constant Bundler::URI::FTP::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::FTP::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::FTP::UNSAFE
+# uninitialized constant Bundler::URI::FTP::URI_REF
+# uninitialized constant Bundler::URI::FTP::USERINFO
+# uninitialized constant Bundler::URI::FTP::USE_REGISTRY
+# uninitialized constant Bundler::URI::FTP::VERSION
+# uninitialized constant Bundler::URI::FTP::VERSION_CODE
+# uninitialized constant Bundler::URI::FTP::WEB_ENCODINGS_
+# wrong constant name set_typecode
+# wrong constant name typecode
+# wrong constant name typecode=
+# wrong constant name <static-init>
+# wrong constant name new2
+# uninitialized constant Bundler::URI::File::ABS_PATH
+# uninitialized constant Bundler::URI::File::ABS_URI
+# uninitialized constant Bundler::URI::File::ABS_URI_REF
+# uninitialized constant Bundler::URI::File::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::File::ESCAPED
+# uninitialized constant Bundler::URI::File::FRAGMENT
+# uninitialized constant Bundler::URI::File::HOST
+# uninitialized constant Bundler::URI::File::OPAQUE
+# uninitialized constant Bundler::URI::File::PORT
+# uninitialized constant Bundler::URI::File::QUERY
+# uninitialized constant Bundler::URI::File::REGISTRY
+# uninitialized constant Bundler::URI::File::REL_PATH
+# uninitialized constant Bundler::URI::File::REL_URI
+# uninitialized constant Bundler::URI::File::REL_URI_REF
+# uninitialized constant Bundler::URI::File::RFC3986_PARSER
+# uninitialized constant Bundler::URI::File::SCHEME
+# uninitialized constant Bundler::URI::File::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::File::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::File::UNSAFE
+# uninitialized constant Bundler::URI::File::URI_REF
+# uninitialized constant Bundler::URI::File::USERINFO
+# uninitialized constant Bundler::URI::File::USE_REGISTRY
+# uninitialized constant Bundler::URI::File::VERSION
+# uninitialized constant Bundler::URI::File::VERSION_CODE
+# uninitialized constant Bundler::URI::File::WEB_ENCODINGS_
+# wrong constant name check_password
+# wrong constant name check_user
+# wrong constant name check_userinfo
+# wrong constant name set_userinfo
+# wrong constant name <static-init>
+# wrong constant name +
+# wrong constant name -
+# wrong constant name ==
+# uninitialized constant Bundler::URI::Generic::ABS_PATH
+# uninitialized constant Bundler::URI::Generic::ABS_URI
+# uninitialized constant Bundler::URI::Generic::ABS_URI_REF
+# uninitialized constant Bundler::URI::Generic::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::Generic::ESCAPED
+# uninitialized constant Bundler::URI::Generic::FRAGMENT
+# uninitialized constant Bundler::URI::Generic::HOST
+# uninitialized constant Bundler::URI::Generic::OPAQUE
+# uninitialized constant Bundler::URI::Generic::PORT
+# uninitialized constant Bundler::URI::Generic::QUERY
+# uninitialized constant Bundler::URI::Generic::REGISTRY
+# uninitialized constant Bundler::URI::Generic::REL_PATH
+# uninitialized constant Bundler::URI::Generic::REL_URI
+# uninitialized constant Bundler::URI::Generic::REL_URI_REF
+# uninitialized constant Bundler::URI::Generic::RFC3986_PARSER
+# uninitialized constant Bundler::URI::Generic::SCHEME
+# uninitialized constant Bundler::URI::Generic::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::Generic::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::Generic::UNSAFE
+# uninitialized constant Bundler::URI::Generic::URI_REF
+# uninitialized constant Bundler::URI::Generic::USERINFO
+# uninitialized constant Bundler::URI::Generic::VERSION
+# uninitialized constant Bundler::URI::Generic::VERSION_CODE
+# uninitialized constant Bundler::URI::Generic::WEB_ENCODINGS_
+# wrong constant name absolute
+# wrong constant name absolute?
+# wrong constant name coerce
+# wrong constant name component
+# wrong constant name component_ary
+# wrong constant name default_port
+# wrong constant name eql?
+# wrong constant name find_proxy
+# wrong constant name fragment
+# wrong constant name fragment=
+# wrong constant name hierarchical?
+# wrong constant name host
+# wrong constant name host=
+# wrong constant name hostname
+# wrong constant name hostname=
+# wrong constant name initialize
+# wrong constant name merge
+# wrong constant name merge!
+# wrong constant name normalize
+# wrong constant name normalize!
+# wrong constant name opaque
+# wrong constant name opaque=
+# wrong constant name parser
+# wrong constant name password
+# wrong constant name password=
+# wrong constant name path
+# wrong constant name path=
+# wrong constant name port
+# wrong constant name port=
+# wrong constant name query
+# wrong constant name query=
+# wrong constant name registry
+# wrong constant name registry=
+# wrong constant name relative?
+# wrong constant name route_from
+# wrong constant name route_to
+# wrong constant name scheme
+# wrong constant name scheme=
+# wrong constant name select
+# wrong constant name set_host
+# wrong constant name set_opaque
+# wrong constant name set_password
+# wrong constant name set_path
+# wrong constant name set_port
+# wrong constant name set_registry
+# wrong constant name set_scheme
+# wrong constant name set_user
+# wrong constant name set_userinfo
+# wrong constant name user
+# wrong constant name user=
+# wrong constant name userinfo
+# wrong constant name userinfo=
+# wrong constant name <static-init>
+# wrong constant name build
+# wrong constant name build2
+# wrong constant name component
+# wrong constant name default_port
+# wrong constant name use_proxy?
+# wrong constant name use_registry
+# uninitialized constant Bundler::URI::HTTP::ABS_PATH
+# uninitialized constant Bundler::URI::HTTP::ABS_URI
+# uninitialized constant Bundler::URI::HTTP::ABS_URI_REF
+# uninitialized constant Bundler::URI::HTTP::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::HTTP::ESCAPED
+# uninitialized constant Bundler::URI::HTTP::FRAGMENT
+# uninitialized constant Bundler::URI::HTTP::HOST
+# uninitialized constant Bundler::URI::HTTP::OPAQUE
+# uninitialized constant Bundler::URI::HTTP::PORT
+# uninitialized constant Bundler::URI::HTTP::QUERY
+# uninitialized constant Bundler::URI::HTTP::REGISTRY
+# uninitialized constant Bundler::URI::HTTP::REL_PATH
+# uninitialized constant Bundler::URI::HTTP::REL_URI
+# uninitialized constant Bundler::URI::HTTP::REL_URI_REF
+# uninitialized constant Bundler::URI::HTTP::RFC3986_PARSER
+# uninitialized constant Bundler::URI::HTTP::SCHEME
+# uninitialized constant Bundler::URI::HTTP::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::HTTP::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::HTTP::UNSAFE
+# uninitialized constant Bundler::URI::HTTP::URI_REF
+# uninitialized constant Bundler::URI::HTTP::USERINFO
+# uninitialized constant Bundler::URI::HTTP::USE_REGISTRY
+# uninitialized constant Bundler::URI::HTTP::VERSION
+# uninitialized constant Bundler::URI::HTTP::VERSION_CODE
+# uninitialized constant Bundler::URI::HTTP::WEB_ENCODINGS_
+# wrong constant name request_uri
+# wrong constant name <static-init>
+# uninitialized constant Bundler::URI::HTTPS::ABS_PATH
+# uninitialized constant Bundler::URI::HTTPS::ABS_URI
+# uninitialized constant Bundler::URI::HTTPS::ABS_URI_REF
+# uninitialized constant Bundler::URI::HTTPS::COMPONENT
+# uninitialized constant Bundler::URI::HTTPS::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::HTTPS::ESCAPED
+# uninitialized constant Bundler::URI::HTTPS::FRAGMENT
+# uninitialized constant Bundler::URI::HTTPS::HOST
+# uninitialized constant Bundler::URI::HTTPS::OPAQUE
+# uninitialized constant Bundler::URI::HTTPS::PORT
+# uninitialized constant Bundler::URI::HTTPS::QUERY
+# uninitialized constant Bundler::URI::HTTPS::REGISTRY
+# uninitialized constant Bundler::URI::HTTPS::REL_PATH
+# uninitialized constant Bundler::URI::HTTPS::REL_URI
+# uninitialized constant Bundler::URI::HTTPS::REL_URI_REF
+# uninitialized constant Bundler::URI::HTTPS::RFC3986_PARSER
+# uninitialized constant Bundler::URI::HTTPS::SCHEME
+# uninitialized constant Bundler::URI::HTTPS::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::HTTPS::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::HTTPS::UNSAFE
+# uninitialized constant Bundler::URI::HTTPS::URI_REF
+# uninitialized constant Bundler::URI::HTTPS::USERINFO
+# uninitialized constant Bundler::URI::HTTPS::USE_REGISTRY
+# uninitialized constant Bundler::URI::HTTPS::VERSION
+# uninitialized constant Bundler::URI::HTTPS::VERSION_CODE
+# uninitialized constant Bundler::URI::HTTPS::WEB_ENCODINGS_
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant Bundler::URI::LDAP::ABS_PATH
+# uninitialized constant Bundler::URI::LDAP::ABS_URI
+# uninitialized constant Bundler::URI::LDAP::ABS_URI_REF
+# uninitialized constant Bundler::URI::LDAP::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::LDAP::ESCAPED
+# uninitialized constant Bundler::URI::LDAP::FRAGMENT
+# uninitialized constant Bundler::URI::LDAP::HOST
+# uninitialized constant Bundler::URI::LDAP::OPAQUE
+# uninitialized constant Bundler::URI::LDAP::PORT
+# uninitialized constant Bundler::URI::LDAP::QUERY
+# uninitialized constant Bundler::URI::LDAP::REGISTRY
+# uninitialized constant Bundler::URI::LDAP::REL_PATH
+# uninitialized constant Bundler::URI::LDAP::REL_URI
+# uninitialized constant Bundler::URI::LDAP::REL_URI_REF
+# uninitialized constant Bundler::URI::LDAP::RFC3986_PARSER
+# uninitialized constant Bundler::URI::LDAP::SCHEME
+# uninitialized constant Bundler::URI::LDAP::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::LDAP::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::LDAP::UNSAFE
+# uninitialized constant Bundler::URI::LDAP::URI_REF
+# uninitialized constant Bundler::URI::LDAP::USERINFO
+# uninitialized constant Bundler::URI::LDAP::USE_REGISTRY
+# uninitialized constant Bundler::URI::LDAP::VERSION
+# uninitialized constant Bundler::URI::LDAP::VERSION_CODE
+# uninitialized constant Bundler::URI::LDAP::WEB_ENCODINGS_
+# wrong constant name attributes
+# wrong constant name attributes=
+# wrong constant name dn
+# wrong constant name dn=
+# wrong constant name extensions
+# wrong constant name extensions=
+# wrong constant name filter
+# wrong constant name filter=
+# wrong constant name initialize
+# wrong constant name scope
+# wrong constant name scope=
+# wrong constant name set_attributes
+# wrong constant name set_dn
+# wrong constant name set_extensions
+# wrong constant name set_filter
+# wrong constant name set_scope
+# wrong constant name <static-init>
+# uninitialized constant Bundler::URI::LDAPS::ABS_PATH
+# uninitialized constant Bundler::URI::LDAPS::ABS_URI
+# uninitialized constant Bundler::URI::LDAPS::ABS_URI_REF
+# uninitialized constant Bundler::URI::LDAPS::COMPONENT
+# uninitialized constant Bundler::URI::LDAPS::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::LDAPS::ESCAPED
+# uninitialized constant Bundler::URI::LDAPS::FRAGMENT
+# uninitialized constant Bundler::URI::LDAPS::HOST
+# uninitialized constant Bundler::URI::LDAPS::OPAQUE
+# uninitialized constant Bundler::URI::LDAPS::PORT
+# uninitialized constant Bundler::URI::LDAPS::QUERY
+# uninitialized constant Bundler::URI::LDAPS::REGISTRY
+# uninitialized constant Bundler::URI::LDAPS::REL_PATH
+# uninitialized constant Bundler::URI::LDAPS::REL_URI
+# uninitialized constant Bundler::URI::LDAPS::REL_URI_REF
+# uninitialized constant Bundler::URI::LDAPS::RFC3986_PARSER
+# uninitialized constant Bundler::URI::LDAPS::SCHEME
+# uninitialized constant Bundler::URI::LDAPS::SCOPE
+# uninitialized constant Bundler::URI::LDAPS::SCOPE_BASE
+# uninitialized constant Bundler::URI::LDAPS::SCOPE_ONE
+# uninitialized constant Bundler::URI::LDAPS::SCOPE_SUB
+# uninitialized constant Bundler::URI::LDAPS::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::LDAPS::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::LDAPS::UNSAFE
+# uninitialized constant Bundler::URI::LDAPS::URI_REF
+# uninitialized constant Bundler::URI::LDAPS::USERINFO
+# uninitialized constant Bundler::URI::LDAPS::USE_REGISTRY
+# uninitialized constant Bundler::URI::LDAPS::VERSION
+# uninitialized constant Bundler::URI::LDAPS::VERSION_CODE
+# uninitialized constant Bundler::URI::LDAPS::WEB_ENCODINGS_
+# wrong constant name <static-init>
+# uninitialized constant Bundler::URI::MailTo::ABS_PATH
+# uninitialized constant Bundler::URI::MailTo::ABS_URI
+# uninitialized constant Bundler::URI::MailTo::ABS_URI_REF
+# uninitialized constant Bundler::URI::MailTo::DEFAULT_PARSER
+# uninitialized constant Bundler::URI::MailTo::ESCAPED
+# uninitialized constant Bundler::URI::MailTo::FRAGMENT
+# uninitialized constant Bundler::URI::MailTo::HOST
+# uninitialized constant Bundler::URI::MailTo::OPAQUE
+# uninitialized constant Bundler::URI::MailTo::PORT
+# uninitialized constant Bundler::URI::MailTo::QUERY
+# uninitialized constant Bundler::URI::MailTo::REGISTRY
+# uninitialized constant Bundler::URI::MailTo::REL_PATH
+# uninitialized constant Bundler::URI::MailTo::REL_URI
+# uninitialized constant Bundler::URI::MailTo::REL_URI_REF
+# uninitialized constant Bundler::URI::MailTo::RFC3986_PARSER
+# uninitialized constant Bundler::URI::MailTo::SCHEME
+# uninitialized constant Bundler::URI::MailTo::TBLDECWWWCOMP_
+# uninitialized constant Bundler::URI::MailTo::TBLENCWWWCOMP_
+# uninitialized constant Bundler::URI::MailTo::UNSAFE
+# uninitialized constant Bundler::URI::MailTo::URI_REF
+# uninitialized constant Bundler::URI::MailTo::USERINFO
+# uninitialized constant Bundler::URI::MailTo::USE_REGISTRY
+# uninitialized constant Bundler::URI::MailTo::VERSION
+# uninitialized constant Bundler::URI::MailTo::VERSION_CODE
+# uninitialized constant Bundler::URI::MailTo::WEB_ENCODINGS_
+# wrong constant name headers
+# wrong constant name headers=
+# wrong constant name initialize
+# wrong constant name set_headers
+# wrong constant name set_to
+# wrong constant name to
+# wrong constant name to=
+# wrong constant name to_mailtext
+# wrong constant name to_rfc822text
+# wrong constant name <static-init>
+# wrong constant name escape
+# wrong constant name extract
+# wrong constant name initialize
+# wrong constant name join
+# wrong constant name make_regexp
+# wrong constant name parse
+# wrong constant name pattern
+# wrong constant name regexp
+# wrong constant name split
+# wrong constant name unescape
+# wrong constant name <static-init>
+# wrong constant name <Class:PATTERN>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name join
+# wrong constant name parse
+# wrong constant name regexp
+# wrong constant name split
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name make_components_hash
+# wrong constant name <static-init>
+# wrong constant name decode_www_form
+# wrong constant name decode_www_form_component
+# wrong constant name encode_www_form
+# wrong constant name encode_www_form_component
+# wrong constant name extract
+# wrong constant name get_encoding
+# wrong constant name join
+# wrong constant name parse
+# wrong constant name regexp
+# wrong constant name scheme_list
+# wrong constant name split
+# wrong constant name <Class:NEq>
+# wrong constant name <Class:ReqR>
+# uninitialized constant Bundler::VersionRanges::NEq::Elem
+# wrong constant name version
+# wrong constant name version=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <=>
+# uninitialized constant Bundler::VersionRanges::ReqR::Elem
+# wrong constant name <Class:Endpoint>
+# wrong constant name cover?
+# wrong constant name empty?
+# wrong constant name left
+# wrong constant name left=
+# wrong constant name right
+# wrong constant name right=
+# wrong constant name single?
+# wrong constant name <=>
+# uninitialized constant Bundler::VersionRanges::ReqR::Endpoint::Elem
+# wrong constant name inclusive
+# wrong constant name inclusive=
+# wrong constant name version
+# wrong constant name version=
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name members
+# wrong constant name <static-init>
+# wrong constant name empty?
+# wrong constant name for
+# wrong constant name for_many
+# wrong constant name original_exec
+# wrong constant name original_system
+# wrong constant name unbundled_env
+# wrong constant name unbundled_exec
+# wrong constant name unbundled_system
+# wrong constant name with_unbundled_env
+# wrong constant name a
+# wrong constant name base
+# wrong constant name blockquote
+# wrong constant name caption
+# wrong constant name checkbox
+# wrong constant name checkbox_group
+# wrong constant name file_field
+# wrong constant name form
+# wrong constant name hidden
+# wrong constant name html
+# wrong constant name image_button
+# wrong constant name img
+# wrong constant name multipart_form
+# wrong constant name password_field
+# wrong constant name popup_menu
+# wrong constant name radio_button
+# wrong constant name radio_group
+# wrong constant name reset
+# wrong constant name scrolling_list
+# wrong constant name submit
+# wrong constant name text_field
+# wrong constant name textarea
+# wrong constant name <static-init>
+# uninitialized constant CMath
+# uninitialized constant CMath
+# uninitialized constant CSV
+# uninitialized constant CSV
+# uninitialized constant Chalk
+# uninitialized constant Chalk
+# uninitialized constant Class::DELEGATION_RESERVED_KEYWORDS
+# uninitialized constant Class::DELEGATION_RESERVED_METHOD_NAMES
+# uninitialized constant Class::RUBY_RESERVED_KEYWORDS
+# wrong constant name json_creatable?
+# wrong constant name <Class:Duo>
+# wrong constant name <Class:FileType>
+# wrong constant name <Class:Scanners>
+# wrong constant name <Class:Styles>
+# wrong constant name <Class:Tokens>
+# wrong constant name <Class:TokensProxy>
+# wrong constant name call
+# wrong constant name encode
+# wrong constant name encoder
+# wrong constant name format
+# wrong constant name format=
+# wrong constant name highlight
+# wrong constant name initialize
+# wrong constant name lang
+# wrong constant name lang=
+# wrong constant name options
+# wrong constant name options=
+# wrong constant name scanner
+# wrong constant name <static-init>
+# wrong constant name []
+# CodeRay::Encoders could not load plugin "default_options": cannot load such file -- /Users/st0012/.rbenv/versions/2.6.5/lib/ruby/gems/2.6.0/gems/coderay-1.1.3/lib/coderay/encoders/default_options.rb
+# wrong constant name <Class:UnknownFileType>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name fetch
+# wrong constant name type_from_shebang
+# wrong constant name <Class:Scanner>
+# wrong constant name <Class:ScanError>
+# wrong constant name binary_string
+# wrong constant name column
+# wrong constant name each
+# wrong constant name file_extension
+# wrong constant name initialize
+# wrong constant name lang
+# wrong constant name line
+# wrong constant name raise_inspect
+# wrong constant name raise_inspect_arguments
+# wrong constant name reset_instance
+# wrong constant name scan_rest
+# wrong constant name scan_tokens
+# wrong constant name scanner_state_info
+# wrong constant name set_string_from_source
+# wrong constant name set_tokens_from_options
+# wrong constant name setup
+# wrong constant name state
+# wrong constant name state=
+# wrong constant name string=
+# wrong constant name tokenize
+# wrong constant name tokens
+# wrong constant name tokens_last
+# wrong constant name tokens_size
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name encode_with_encoding
+# wrong constant name encoding
+# wrong constant name file_extension
+# wrong constant name guess_encoding
+# wrong constant name lang
+# wrong constant name normalize
+# wrong constant name to_unix
+# wrong constant name <static-init>
+# wrong constant name <Class:Style>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant CodeRay::Tokens::Elem
+# wrong constant name begin_group
+# wrong constant name begin_line
+# wrong constant name count
+# wrong constant name encode
+# wrong constant name end_group
+# wrong constant name end_line
+# wrong constant name method_missing
+# wrong constant name scanner
+# wrong constant name scanner=
+# wrong constant name split_into_parts
+# wrong constant name text_token
+# wrong constant name to_s
+# wrong constant name tokens
+# wrong constant name <static-init>
+# wrong constant name block
+# wrong constant name block=
+# wrong constant name each
+# wrong constant name encode
+# wrong constant name initialize
+# wrong constant name input
+# wrong constant name input=
+# wrong constant name lang
+# wrong constant name lang=
+# wrong constant name method_missing
+# wrong constant name options
+# wrong constant name options=
+# wrong constant name scanner
+# wrong constant name tokens
+# wrong constant name <static-init>
+# uninitialized constant Comment::ACTIONS
+# uninitialized constant Comment::CALLBACKS
+# uninitialized constant Comment::CALLBACK_FILTER_TYPES
+# uninitialized constant Comment::CALL_COMPILABLE_REGEXP
+# wrong constant name <Class:GeneratedAssociationMethods>
+# wrong constant name <Class:GeneratedAttributeMethods>
+# uninitialized constant Comment::MAX_PASSWORD_LENGTH_ALLOWED
+# uninitialized constant Comment::NAME_COMPILABLE_REGEXP
+# uninitialized constant Comment::RESTRICTED_CLASS_METHODS
+# uninitialized constant Comment::UNASSIGNABLE_KEYS
+# wrong constant name autosave_associated_records_for_post
+# wrong constant name autosave_associated_records_for_user
+# wrong constant name build_post
+# wrong constant name build_user
+# wrong constant name create_post
+# wrong constant name create_post!
+# wrong constant name create_user
+# wrong constant name create_user!
+# wrong constant name post
+# wrong constant name post=
+# wrong constant name reload_post
+# wrong constant name reload_user
+# wrong constant name user
+# wrong constant name user=
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant Concurrent::AbstractExecutorService::DEBUG
+# uninitialized constant Concurrent::AbstractExecutorService::ERROR
+# uninitialized constant Concurrent::AbstractExecutorService::FATAL
+# uninitialized constant Concurrent::AbstractExecutorService::INFO
+# uninitialized constant Concurrent::AbstractExecutorService::UNKNOWN
+# uninitialized constant Concurrent::AbstractExecutorService::WARN
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::DEBUG
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::ERROR
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::FALLBACK_POLICIES
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::FATAL
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::INFO
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::UNKNOWN
+# uninitialized constant Concurrent::RubyThreadPoolExecutor::WARN
+# uninitialized constant Concurrent::TimerTask::DEBUG
+# uninitialized constant Concurrent::TimerTask::ERROR
+# uninitialized constant Concurrent::TimerTask::FALLBACK_POLICIES
+# uninitialized constant Concurrent::TimerTask::FATAL
+# uninitialized constant Concurrent::TimerTask::INFO
+# uninitialized constant Concurrent::TimerTask::UNKNOWN
+# uninitialized constant Concurrent::TimerTask::WARN
+# uninitialized constant Configatron
+# uninitialized constant Configatron
+# uninitialized constant Continuation
+# uninitialized constant Continuation
+# uninitialized constant DBM
+# uninitialized constant DBM
+# uninitialized constant DBMError
+# uninitialized constant DBMError
+# wrong constant name _dump
+# uninitialized constant Date::DAYS_INTO_WEEK
+# uninitialized constant Date::WEEKEND_DAYS
+# uninitialized constant Date::Error
+# uninitialized constant Date::Error
+# uninitialized constant Date::Infinity::EXABYTE
+# uninitialized constant Date::Infinity::GIGABYTE
+# uninitialized constant Date::Infinity::KILOBYTE
+# uninitialized constant Date::Infinity::MEGABYTE
+# uninitialized constant Date::Infinity::PETABYTE
+# uninitialized constant Date::Infinity::TERABYTE
+# wrong constant name initialize
+# wrong constant name class_name
+# wrong constant name class_names
+# wrong constant name corrections
+# wrong constant name initialize
+# wrong constant name scopes
+# wrong constant name corrections
+# wrong constant name original_message
+# wrong constant name spell_checker
+# wrong constant name to_s
+# uninitialized constant DidYouMean::Formatter
+# uninitialized constant DidYouMean::Formatter
+# wrong constant name distance
+# wrong constant name distance
+# wrong constant name corrections
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name distance
+# wrong constant name min3
+# wrong constant name corrections
+# wrong constant name initialize
+# wrong constant name method_name
+# wrong constant name method_names
+# wrong constant name receiver
+# wrong constant name corrections
+# wrong constant name initialize
+# wrong constant name message_for
+# wrong constant name <static-init>
+# wrong constant name corrections
+# wrong constant name cvar_names
+# wrong constant name initialize
+# wrong constant name ivar_names
+# wrong constant name lvar_names
+# wrong constant name method_names
+# wrong constant name name
+# wrong constant name formatter
+# wrong constant name formatter=
+# wrong constant name <static-init>
+# wrong constant name uuid_from_hash
+# wrong constant name uuid_v3
+# wrong constant name uuid_v4
+# wrong constant name uuid_v5
+# wrong constant name children
+# wrong constant name each_child
+# wrong constant name exists?
+# wrong constant name def_method
+# wrong constant name def_module
+# wrong constant name html_escape_once
+# wrong constant name json_escape
+# wrong constant name unwrapped_html_escape
+# wrong constant name _dump
+# wrong constant name initialize
+# wrong constant name _load
+# wrong constant name chain
+# wrong constant name sum
+# wrong constant name +
+# wrong constant name <Class:ArithmeticSequence>
+# wrong constant name <Class:Chain>
+# wrong constant name each_with_index
+# uninitialized constant Enumerator::ArithmeticSequence::Elem
+# wrong constant name begin
+# wrong constant name each
+# wrong constant name end
+# wrong constant name exclude_end?
+# wrong constant name last
+# wrong constant name step
+# wrong constant name <static-init>
+# uninitialized constant Enumerator::Chain::Elem
+# wrong constant name <static-init>
+# wrong constant name each
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name gid
+# wrong constant name gid=
+# wrong constant name mem
+# wrong constant name mem=
+# wrong constant name name
+# wrong constant name name=
+# wrong constant name passwd
+# wrong constant name passwd=
+# wrong constant name []
+# wrong constant name each
+# wrong constant name members
+# wrong constant name <Class:Group>
+# wrong constant name change
+# wrong constant name change=
+# wrong constant name dir=
+# wrong constant name expire
+# wrong constant name expire=
+# wrong constant name gecos
+# wrong constant name gecos=
+# wrong constant name gid=
+# wrong constant name name=
+# wrong constant name passwd=
+# wrong constant name shell=
+# wrong constant name uclass
+# wrong constant name uclass=
+# wrong constant name uid=
+# wrong constant name []
+# wrong constant name each
+# wrong constant name members
+# wrong constant name <Class:Passwd>
+# uninitialized constant Exception2MessageMapper
+# uninitialized constant Exception2MessageMapper
+# wrong constant name <static-init>
+# uninitialized constant Fcntl
+# uninitialized constant Fcntl
+# wrong constant name transfer
+# wrong constant name current
+# uninitialized constant Fiddle
+# uninitialized constant Fiddle
+# wrong constant name exists?
+# uninitialized constant FileUtils::DryRun::LN_SUPPORTED
+# uninitialized constant FileUtils::DryRun::RUBY
+# uninitialized constant FileUtils::DryRun::VERSION
+# uninitialized constant FileUtils::NoWrite::LN_SUPPORTED
+# uninitialized constant FileUtils::NoWrite::RUBY
+# uninitialized constant FileUtils::NoWrite::VERSION
+# uninitialized constant FileUtils::Verbose::LN_SUPPORTED
+# uninitialized constant FileUtils::Verbose::RUBY
+# uninitialized constant FileUtils::Verbose::VERSION
+# uninitialized constant Find
+# uninitialized constant Find
+# uninitialized constant Float::EXABYTE
+# uninitialized constant Float::GIGABYTE
+# uninitialized constant Float::KILOBYTE
+# uninitialized constant Float::MEGABYTE
+# uninitialized constant Float::PETABYTE
+# uninitialized constant Float::TERABYTE
+# wrong constant name _compile_method
+# wrong constant name _delegator_method
+# wrong constant name _valid_method?
+# wrong constant name debug
+# wrong constant name debug=
+# wrong constant name garbage_collect
+# wrong constant name verify_transient_heap_internal_consistency
+# uninitialized constant GDBM
+# uninitialized constant GDBM
+# uninitialized constant GDBMError
+# uninitialized constant GDBMError
+# uninitialized constant GDBMFatalError
+# uninitialized constant GDBMFatalError
+# wrong constant name <Class:RuntimeRequirementNotMetError>
+# wrong constant name <Class:SpecFetcher>
+# wrong constant name <Class:SpecificationPolicy>
+# wrong constant name <Class:UninstallError>
+# wrong constant name _deprecated_add_found_dependencies
+# wrong constant name _deprecated_gather_dependencies
+# wrong constant name add_found_dependencies
+# wrong constant name gather_dependencies
+# wrong constant name <static-init>
+# wrong constant name redirector
+# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MONITOR
+# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MUTEX
+# wrong constant name <static-init>
+# wrong constant name build
+# wrong constant name get_relative_path
+# wrong constant name digests
+# wrong constant name initialize
+# wrong constant name write
+# wrong constant name <static-init>
+# wrong constant name wrap
+# wrong constant name initialize
+# wrong constant name path
+# wrong constant name start
+# wrong constant name with_read_io
+# wrong constant name with_write_io
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name io
+# wrong constant name path
+# wrong constant name start
+# wrong constant name with_read_io
+# wrong constant name with_write_io
+# wrong constant name <static-init>
+# wrong constant name extract_files
+# wrong constant name file_list
+# wrong constant name read_until_dashes
+# wrong constant name skip_ruby
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name ==
+# wrong constant name checksum
+# wrong constant name devmajor
+# wrong constant name devminor
+# wrong constant name empty?
+# wrong constant name gid
+# wrong constant name gname
+# wrong constant name initialize
+# wrong constant name linkname
+# wrong constant name magic
+# wrong constant name mode
+# wrong constant name mtime
+# wrong constant name name
+# wrong constant name prefix
+# wrong constant name size
+# wrong constant name typeflag
+# wrong constant name uid
+# wrong constant name uname
+# wrong constant name update_checksum
+# wrong constant name version
+# wrong constant name <static-init>
+# wrong constant name from
+# wrong constant name strict_oct
+# wrong constant name bytes_read
+# wrong constant name check_closed
+# wrong constant name close
+# wrong constant name closed?
+# wrong constant name directory?
+# wrong constant name eof?
+# wrong constant name file?
+# wrong constant name full_name
+# wrong constant name getc
+# wrong constant name header
+# wrong constant name initialize
+# wrong constant name length
+# wrong constant name pos
+# wrong constant name read
+# wrong constant name readpartial
+# wrong constant name rewind
+# wrong constant name size
+# wrong constant name symlink?
+# wrong constant name <static-init>
+# wrong constant name new
+# wrong constant name new
+# wrong constant name new
+# wrong constant name home
+# wrong constant name initialize
+# wrong constant name path
+# wrong constant name spec_cache_dir
+# wrong constant name <Class:FetchError>
+# wrong constant name <Class:UnknownHostError>
+# wrong constant name correct_for_windows_path
+# wrong constant name s3_expiration
+# wrong constant name sign_s3_url
+# wrong constant name initialize
+# wrong constant name uri
+# wrong constant name uri=
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name others_possible?
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name add_edge_no_circular
+# wrong constant name add_vertex
+# wrong constant name delete_edge
+# wrong constant name detach_vertex_named
+# wrong constant name each
+# wrong constant name pop!
+# wrong constant name reverse_each
+# wrong constant name rewind_to
+# wrong constant name set_payload
+# wrong constant name tag
+# wrong constant name <static-init>
+# uninitialized constant Gem::Resolver::Molinillo::DependencyGraph::Log::Elem
+# wrong constant name suggestion
+# wrong constant name suggestion=
+# wrong constant name <static-init>
+# uninitialized constant Gem::S3URISigner
+# uninitialized constant Gem::S3URISigner
+# wrong constant name <static-init>
+# wrong constant name d
+# wrong constant name dmp1
+# wrong constant name dmq1
+# wrong constant name e
+# wrong constant name export
+# wrong constant name initialize
+# wrong constant name iqmp
+# wrong constant name n
+# wrong constant name p
+# wrong constant name params
+# wrong constant name private?
+# wrong constant name private_decrypt
+# wrong constant name private_encrypt
+# wrong constant name public?
+# wrong constant name public_decrypt
+# wrong constant name public_encrypt
+# wrong constant name public_key
+# wrong constant name q
+# wrong constant name set_crt_params
+# wrong constant name set_factors
+# wrong constant name set_key
+# wrong constant name sign_pss
+# wrong constant name to_der
+# wrong constant name to_pem
+# wrong constant name to_s
+# wrong constant name to_text
+# wrong constant name verify_pss
+# wrong constant name <static-init>
+# wrong constant name generate
+# wrong constant name check_cert
+# wrong constant name check_chain
+# wrong constant name check_data
+# wrong constant name check_key
+# wrong constant name check_root
+# wrong constant name check_trust
+# wrong constant name initialize
+# wrong constant name name
+# wrong constant name only_signed
+# wrong constant name only_signed=
+# wrong constant name only_trusted
+# wrong constant name only_trusted=
+# wrong constant name subject
+# wrong constant name verify
+# wrong constant name verify_chain
+# wrong constant name verify_chain=
+# wrong constant name verify_data
+# wrong constant name verify_data=
+# wrong constant name verify_root
+# wrong constant name verify_root=
+# wrong constant name verify_signatures
+# wrong constant name verify_signer
+# wrong constant name verify_signer=
+# wrong constant name <static-init>
+# wrong constant name cert_chain
+# wrong constant name cert_chain=
+# wrong constant name digest_algorithm
+# wrong constant name digest_name
+# wrong constant name extract_name
+# wrong constant name initialize
+# wrong constant name key
+# wrong constant name key=
+# wrong constant name load_cert_chain
+# wrong constant name options
+# wrong constant name re_sign_key
+# wrong constant name sign
+# wrong constant name re_sign_cert
+# wrong constant name cert_path
+# wrong constant name dir
+# wrong constant name each_certificate
+# wrong constant name initialize
+# wrong constant name issuer_of
+# wrong constant name load_certificate
+# wrong constant name name_path
+# wrong constant name trust_cert
+# wrong constant name verify
+# wrong constant name alt_name_or_x509_entry
+# wrong constant name create_cert
+# wrong constant name create_cert_email
+# wrong constant name create_cert_self_signed
+# wrong constant name create_key
+# wrong constant name email_to_name
+# wrong constant name re_sign
+# wrong constant name reset
+# wrong constant name sign
+# wrong constant name trust_dir
+# wrong constant name trusted_certificates
+# wrong constant name write
+# wrong constant name available_specs
+# wrong constant name detect
+# wrong constant name initialize
+# wrong constant name latest_specs
+# wrong constant name prerelease_specs
+# wrong constant name search_for_dependency
+# wrong constant name sources
+# wrong constant name spec_for_dependency
+# wrong constant name specs
+# wrong constant name suggest_gems_from_name
+# wrong constant name tuples_for
+# wrong constant name <static-init>
+# wrong constant name fetcher
+# wrong constant name fetcher=
+# wrong constant name <=>
+# uninitialized constant Gem::Specification::GENERICS
+# uninitialized constant Gem::Specification::GENERIC_CACHE
+# wrong constant name to_ruby
+# wrong constant name add_spec
+# wrong constant name add_specs
+# wrong constant name remove_spec
+# wrong constant name initialize
+# wrong constant name packaging
+# wrong constant name packaging=
+# wrong constant name validate
+# wrong constant name validate_dependencies
+# wrong constant name validate_metadata
+# wrong constant name validate_permissions
+# wrong constant name <static-init>
+# uninitialized constant Gem::Stream
+# uninitialized constant Gem::Stream
+# wrong constant name _deprecated_debug
+# wrong constant name build_extensions
+# wrong constant name extensions
+# wrong constant name initialize
+# wrong constant name missing_extensions?
+# wrong constant name valid?
+# wrong constant name extensions
+# wrong constant name full_name
+# wrong constant name initialize
+# wrong constant name name
+# wrong constant name platform
+# wrong constant name require_paths
+# wrong constant name version
+# wrong constant name default_gemspec_stub
+# wrong constant name gemspec_stub
+# wrong constant name spec
+# wrong constant name spec=
+# wrong constant name <static-init>
+# uninitialized constant Gem::UriParser
+# uninitialized constant Gem::UriParser
+# uninitialized constant Gem::UriParsing
+# uninitialized constant Gem::UriParsing
+# wrong constant name default_gems_use_full_paths?
+# wrong constant name remove_unresolved_default_spec
+# uninitialized constant GetoptLong
+# uninitialized constant GetoptLong
+# wrong constant name try_convert
+# wrong constant name <Class:Backend>
+# wrong constant name <Class:Gettext>
+# wrong constant name <Class:Locale>
+# wrong constant name <Class:Middleware>
+# wrong constant name <Class:Tests>
+# wrong constant name <Class:Base>
+# wrong constant name <Class:Cache>
+# wrong constant name <Class:CacheFile>
+# wrong constant name <Class:Cascade>
+# wrong constant name <Class:Fallbacks>
+# wrong constant name <Class:Flatten>
+# wrong constant name <Class:InterpolationCompiler>
+# wrong constant name <Class:KeyValue>
+# wrong constant name <Class:Memoize>
+# wrong constant name <Class:Metadata>
+# wrong constant name <Class:Pluralization>
+# wrong constant name <Class:Simple>
+# wrong constant name <Class:Transliterator>
+# uninitialized constant I18n::Backend::Base::DEFAULT_REPLACEMENT_CHAR
+# wrong constant name available_locales
+# wrong constant name deep_interpolate
+# wrong constant name default
+# wrong constant name eager_load!
+# wrong constant name eager_loaded?
+# wrong constant name exists?
+# wrong constant name interpolate
+# wrong constant name load_file
+# wrong constant name load_json
+# wrong constant name load_rb
+# wrong constant name load_translations
+# wrong constant name load_yaml
+# wrong constant name load_yml
+# wrong constant name localize
+# wrong constant name lookup
+# wrong constant name pluralization_key
+# wrong constant name pluralize
+# wrong constant name reload!
+# wrong constant name resolve
+# wrong constant name store_translations
+# wrong constant name subtrees?
+# wrong constant name translate
+# wrong constant name translate_localization_format
+# wrong constant name <static-init>
+# wrong constant name _fetch
+# wrong constant name cache_key
+# wrong constant name fetch
+# wrong constant name translate
+# wrong constant name <static-init>
+# wrong constant name load_file
+# wrong constant name normalized_path
+# wrong constant name path_roots
+# wrong constant name path_roots=
+# wrong constant name <static-init>
+# wrong constant name lookup
+# wrong constant name <static-init>
+# wrong constant name exists?
+# wrong constant name extract_non_symbol_default!
+# wrong constant name translate
+# wrong constant name <static-init>
+# wrong constant name escape_default_separator
+# wrong constant name find_link
+# wrong constant name flatten_keys
+# wrong constant name flatten_translations
+# wrong constant name links
+# wrong constant name normalize_flat_keys
+# wrong constant name resolve_link
+# wrong constant name store_link
+# wrong constant name <static-init>
+# wrong constant name escape_default_separator
+# wrong constant name normalize_flat_keys
+# wrong constant name <Class:Compiler>
+# wrong constant name compile_all_strings_in
+# wrong constant name interpolate
+# wrong constant name store_translations
+# wrong constant name compile_if_an_interpolation
+# wrong constant name compile_interpolation_token
+# wrong constant name compiled_interpolation_body
+# wrong constant name direct_key
+# wrong constant name escape_key_sym
+# wrong constant name escape_plain_str
+# wrong constant name handle_interpolation_token
+# wrong constant name interpolate_key
+# wrong constant name interpolate_or_raise_missing
+# wrong constant name interpolated_str?
+# wrong constant name missing_key
+# wrong constant name nil_key
+# wrong constant name reserved_key
+# wrong constant name tokenize
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant I18n::Backend::KeyValue::DEFAULT_REPLACEMENT_CHAR
+# uninitialized constant I18n::Backend::KeyValue::FLATTEN_SEPARATOR
+# wrong constant name <Class:Implementation>
+# uninitialized constant I18n::Backend::KeyValue::SEPARATOR_ESCAPE_CHAR
+# wrong constant name <Class:SubtreeProxy>
+# uninitialized constant I18n::Backend::KeyValue::Implementation::DEFAULT_REPLACEMENT_CHAR
+# uninitialized constant I18n::Backend::KeyValue::Implementation::FLATTEN_SEPARATOR
+# uninitialized constant I18n::Backend::KeyValue::Implementation::SEPARATOR_ESCAPE_CHAR
+# wrong constant name available_locales
+# wrong constant name init_translations
+# wrong constant name initialize
+# wrong constant name initialized?
+# wrong constant name lookup
+# wrong constant name pluralize
+# wrong constant name store
+# wrong constant name store=
+# wrong constant name store_translations
+# wrong constant name subtrees?
+# wrong constant name translations
+# wrong constant name <static-init>
+# wrong constant name []
+# wrong constant name has_key?
+# wrong constant name initialize
+# wrong constant name instance_of?
+# wrong constant name is_a?
+# wrong constant name kind_of?
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name available_locales
+# wrong constant name eager_load!
+# wrong constant name lookup
+# wrong constant name memoized_lookup
+# wrong constant name reload!
+# wrong constant name reset_memoizations!
+# wrong constant name store_translations
+# wrong constant name <static-init>
+# wrong constant name interpolate
+# wrong constant name pluralize
+# wrong constant name translate
+# wrong constant name with_metadata
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name pluralize
+# wrong constant name pluralizer
+# wrong constant name pluralizers
+# wrong constant name <static-init>
+# uninitialized constant I18n::Backend::Simple::DEFAULT_REPLACEMENT_CHAR
+# wrong constant name <Class:Implementation>
+# uninitialized constant I18n::Backend::Simple::Implementation::DEFAULT_REPLACEMENT_CHAR
+# wrong constant name available_locales
+# wrong constant name eager_load!
+# wrong constant name init_translations
+# wrong constant name initialized?
+# wrong constant name lookup
+# wrong constant name reload!
+# wrong constant name store_translations
+# wrong constant name translations
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name <Class:HashTransliterator>
+# wrong constant name <Class:ProcTransliterator>
+# wrong constant name transliterate
+# wrong constant name initialize
+# wrong constant name transliterate
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name transliterate
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name get
+# wrong constant name <static-init>
+# wrong constant name <Class:Helpers>
+# uninitialized constant I18n::Gettext::Helpers::N_
+# wrong constant name _
+# wrong constant name gettext
+# wrong constant name n_
+# wrong constant name ngettext
+# wrong constant name np_
+# wrong constant name npgettext
+# wrong constant name ns_
+# wrong constant name nsgettext
+# wrong constant name p_
+# wrong constant name pgettext
+# wrong constant name s_
+# wrong constant name sgettext
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name extract_scope
+# wrong constant name plural_keys
+# wrong constant name <Class:Fallbacks>
+# wrong constant name <Class:Tag>
+# uninitialized constant I18n::Locale::Fallbacks::Elem
+# uninitialized constant I18n::Locale::Fallbacks::K
+# uninitialized constant I18n::Locale::Fallbacks::V
+# wrong constant name []
+# wrong constant name compute
+# wrong constant name defaults
+# wrong constant name defaults=
+# wrong constant name initialize
+# wrong constant name map
+# wrong constant name <static-init>
+# wrong constant name <Class:Parents>
+# wrong constant name <Class:Rfc4646>
+# wrong constant name <Class:Simple>
+# wrong constant name parent
+# wrong constant name parents
+# wrong constant name self_and_parents
+# wrong constant name <static-init>
+# wrong constant name <Class:Parser>
+# wrong constant name to_sym
+# wrong constant name <static-init>
+# wrong constant name match
+# wrong constant name <static-init>
+# wrong constant name parser
+# wrong constant name parser=
+# wrong constant name tag
+# wrong constant name initialize
+# wrong constant name subtags
+# wrong constant name tag
+# wrong constant name to_a
+# wrong constant name to_sym
+# wrong constant name <static-init>
+# wrong constant name tag
+# wrong constant name <static-init>
+# wrong constant name implementation
+# wrong constant name implementation=
+# wrong constant name tag
+# wrong constant name <static-init>
+# wrong constant name call
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <Class:Localization>
+# wrong constant name <static-init>
+# wrong constant name included
+# wrong constant name <static-init>
+# wrong constant name cache_key_digest
+# wrong constant name cache_key_digest=
+# wrong constant name cache_namespace
+# wrong constant name cache_namespace=
+# wrong constant name cache_store
+# wrong constant name cache_store=
+# wrong constant name fallbacks
+# wrong constant name fallbacks=
+# wrong constant name perform_caching?
+# wrong constant name nonblock
+# wrong constant name nonblock=
+# wrong constant name nonblock?
+# wrong constant name nread
+# wrong constant name pathconf
+# wrong constant name ready?
+# wrong constant name wait
+# wrong constant name wait_readable
+# wrong constant name wait_writable
+# wrong constant name ==
+# wrong constant name initialize
+# uninitialized constant IRB
+# uninitialized constant IRB
+# uninitialized constant Integer::EXABYTE
+# uninitialized constant Integer::GIGABYTE
+# uninitialized constant Integer::KILOBYTE
+# uninitialized constant Integer::MEGABYTE
+# uninitialized constant Integer::PETABYTE
+# uninitialized constant Integer::TERABYTE
+# wrong constant name to_bn
+# wrong constant name from_state
+# wrong constant name initialize
+# uninitialized constant Jacobian
+# uninitialized constant Jacobian
+# uninitialized constant Kconv
+# uninitialized constant Kconv
+# wrong constant name itself
+# wrong constant name object_id
+# wrong constant name pretty_inspect
+# wrong constant name then
+# wrong constant name yield_self
+# wrong constant name at_exit
+# wrong constant name load
+# wrong constant name require
+# uninitialized constant LUSolve
+# uninitialized constant LUSolve
+# uninitialized constant Logger::LogDevice::EXCEPTION_IMMEDIATE
+# uninitialized constant Logger::LogDevice::EXCEPTION_NEVER
+# uninitialized constant Logger::LogDevice::SiD
+# uninitialized constant Matrix
+# uninitialized constant Matrix
+# uninitialized constant MessagePack
+# uninitialized constant MessagePack
+# wrong constant name _synchronize
+# wrong constant name assert_in_delta
+# wrong constant name assert_in_epsilon
+# wrong constant name assert_instance_of
+# wrong constant name assert_kind_of
+# wrong constant name assert_match
+# wrong constant name assert_operator
+# wrong constant name assert_output
+# wrong constant name assert_path_exists
+# wrong constant name assert_predicate
+# wrong constant name assert_respond_to
+# wrong constant name assert_same
+# wrong constant name assert_send
+# wrong constant name assert_silent
+# wrong constant name assert_throws
+# wrong constant name capture_io
+# wrong constant name capture_subprocess_io
+# wrong constant name diff
+# wrong constant name exception_details
+# wrong constant name fail_after
+# wrong constant name flunk
+# wrong constant name message
+# wrong constant name mu_pp
+# wrong constant name mu_pp_for_diff
+# wrong constant name pass
+# wrong constant name refute_in_delta
+# wrong constant name refute_in_epsilon
+# wrong constant name refute_instance_of
+# wrong constant name refute_kind_of
+# wrong constant name refute_match
+# wrong constant name refute_operator
+# wrong constant name refute_path_exists
+# wrong constant name refute_predicate
+# wrong constant name refute_respond_to
+# wrong constant name refute_same
+# wrong constant name skip
+# wrong constant name skip_until
+# wrong constant name skipped?
+# wrong constant name things_to_diff
+# wrong constant name diff
+# wrong constant name diff=
+# wrong constant name jruby?
+# wrong constant name maglev?
+# wrong constant name mri?
+# wrong constant name osx?
+# wrong constant name rubinius?
+# wrong constant name windows?
+# wrong constant name <static-init>
+# wrong constant name class_name
+# wrong constant name error?
+# wrong constant name location
+# wrong constant name passed?
+# wrong constant name result_code
+# wrong constant name skipped?
+# wrong constant name <static-init>
+# wrong constant name assertions
+# wrong constant name assertions=
+# wrong constant name failure
+# wrong constant name failures
+# wrong constant name failures=
+# wrong constant name initialize
+# wrong constant name marshal_dump
+# wrong constant name marshal_load
+# wrong constant name name
+# wrong constant name name=
+# wrong constant name passed?
+# wrong constant name result_code
+# wrong constant name run
+# wrong constant name skipped?
+# wrong constant name time
+# wrong constant name time=
+# wrong constant name time_it
+# wrong constant name inherited
+# wrong constant name methods_matching
+# wrong constant name on_signal
+# wrong constant name reset
+# wrong constant name run
+# wrong constant name run_one_method
+# wrong constant name runnable_methods
+# wrong constant name runnables
+# wrong constant name with_info_handler
+# uninitialized constant Minitest::Test::E
+# wrong constant name <Class:LifecycleHooks>
+# uninitialized constant Minitest::Test::SIGNALS
+# uninitialized constant Minitest::Test::UNDEFINED
+# wrong constant name capture_exceptions
+# wrong constant name with_info_handler
+# wrong constant name after_setup
+# wrong constant name after_teardown
+# wrong constant name before_setup
+# wrong constant name before_teardown
+# wrong constant name setup
+# wrong constant name teardown
+# wrong constant name <static-init>
+# wrong constant name i_suck_and_my_tests_are_order_dependent!
+# wrong constant name io_lock
+# wrong constant name io_lock=
+# wrong constant name make_my_diffs_pretty!
+# wrong constant name parallelize_me!
+# wrong constant name test_order
+# uninitialized constant Monitor::EXCEPTION_IMMEDIATE
+# uninitialized constant Monitor::EXCEPTION_NEVER
+# wrong constant name enter
+# wrong constant name exit
+# wrong constant name try_enter
+# wrong constant name initialize
+# wrong constant name initialize
+# uninitialized constant NKF
+# uninitialized constant NKF
+# uninitialized constant Net::DNS
+# uninitialized constant Net::DNS
+# uninitialized constant Net::FTP
+# uninitialized constant Net::FTP
+# uninitialized constant Net::FTPConnectionError
+# uninitialized constant Net::FTPConnectionError
+# uninitialized constant Net::FTPError
+# uninitialized constant Net::FTPError
+# uninitialized constant Net::FTPPermError
+# uninitialized constant Net::FTPPermError
+# uninitialized constant Net::FTPProtoError
+# uninitialized constant Net::FTPProtoError
+# uninitialized constant Net::FTPReplyError
+# uninitialized constant Net::FTPReplyError
+# uninitialized constant Net::FTPTempError
+# uninitialized constant Net::FTPTempError
+# uninitialized constant Net::HTTP::DigestAuth
+# uninitialized constant Net::HTTP::DigestAuth
+# uninitialized constant Net::IMAP
+# uninitialized constant Net::IMAP
+# uninitialized constant Net::NTLM
+# uninitialized constant Net::NTLM
+# uninitialized constant Net::SFTP
+# uninitialized constant Net::SFTP
+# uninitialized constant Net::SMTP
+# uninitialized constant Net::SMTP
+# uninitialized constant Net::SMTPAuthenticationError
+# uninitialized constant Net::SMTPAuthenticationError
+# uninitialized constant Net::SMTPError
+# uninitialized constant Net::SMTPError
+# uninitialized constant Net::SMTPFatalError
+# uninitialized constant Net::SMTPFatalError
+# uninitialized constant Net::SMTPServerBusy
+# uninitialized constant Net::SMTPServerBusy
+# uninitialized constant Net::SMTPSyntaxError
+# uninitialized constant Net::SMTPSyntaxError
+# uninitialized constant Net::SMTPUnknownError
+# uninitialized constant Net::SMTPUnknownError
+# uninitialized constant Net::SMTPUnsupportedCommand
+# uninitialized constant Net::SMTPUnsupportedCommand
+# uninitialized constant Net::SSH
+# uninitialized constant Net::SSH
+# uninitialized constant Newton
+# uninitialized constant Newton
+# wrong constant name to_d
+# uninitialized constant RUBYGEMS_ACTIVATION_MONITOR
+# wrong constant name html_safe?
+# wrong constant name to_yaml
+# wrong constant name yaml_tag
+# wrong constant name <Class:Object>
+# uninitialized constant Observable
+# uninitialized constant Observable
+# uninitialized constant Open3
+# uninitialized constant Open3
+# uninitialized constant OpenSSL::Digest::DSS
+# uninitialized constant OpenSSL::Digest::DSS
+# uninitialized constant OpenSSL::Digest::DSS1
+# uninitialized constant OpenSSL::Digest::DSS1
+# uninitialized constant OpenSSL::Digest::SHA
+# uninitialized constant OpenSSL::Digest::SHA
+# uninitialized constant OpenSSL::PKCS5::PKCS5Error
+# uninitialized constant OpenSSL::PKCS5::PKCS5Error
+# uninitialized constant OpenURI
+# uninitialized constant OpenURI
+# uninitialized constant Opus
+# uninitialized constant Opus
+# uninitialized constant PStore
+# uninitialized constant PStore
+# uninitialized constant PTY
+# uninitialized constant PTY
+# uninitialized constant PackageSpec
+# uninitialized constant PackageSpec
+# wrong constant name <Class:PackageSpec>
+# uninitialized constant Pastel::Color::ATTRIBUTES
+# uninitialized constant Pastel::ColorParser::ATTRIBUTES
+# wrong constant name fnmatch?
+# wrong constant name glob
+# wrong constant name make_symlink
+# uninitialized constant Post::ACTIONS
+# uninitialized constant Post::CALLBACKS
+# uninitialized constant Post::CALLBACK_FILTER_TYPES
+# uninitialized constant Post::CALL_COMPILABLE_REGEXP
+# wrong constant name <Class:GeneratedAssociationMethods>
+# wrong constant name <Class:GeneratedAttributeMethods>
+# uninitialized constant Post::MAX_PASSWORD_LENGTH_ALLOWED
+# uninitialized constant Post::NAME_COMPILABLE_REGEXP
+# uninitialized constant Post::RESTRICTED_CLASS_METHODS
+# uninitialized constant Post::UNASSIGNABLE_KEYS
+# wrong constant name after_add_for_comments
+# wrong constant name after_add_for_comments=
+# wrong constant name after_add_for_comments?
+# wrong constant name after_remove_for_comments
+# wrong constant name after_remove_for_comments=
+# wrong constant name after_remove_for_comments?
+# wrong constant name autosave_associated_records_for_comments
+# wrong constant name autosave_associated_records_for_user
+# wrong constant name before_add_for_comments
+# wrong constant name before_add_for_comments=
+# wrong constant name before_add_for_comments?
+# wrong constant name before_remove_for_comments
+# wrong constant name before_remove_for_comments=
+# wrong constant name before_remove_for_comments?
+# wrong constant name validate_associated_records_for_comments
+# wrong constant name build_user
+# wrong constant name comment_ids
+# wrong constant name comment_ids=
+# wrong constant name comments
+# wrong constant name comments=
+# wrong constant name create_user
+# wrong constant name create_user!
+# wrong constant name reload_user
+# wrong constant name user
+# wrong constant name user=
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name after_add_for_comments
+# wrong constant name after_add_for_comments=
+# wrong constant name after_add_for_comments?
+# wrong constant name after_remove_for_comments
+# wrong constant name after_remove_for_comments=
+# wrong constant name after_remove_for_comments?
+# wrong constant name before_add_for_comments
+# wrong constant name before_add_for_comments=
+# wrong constant name before_add_for_comments?
+# wrong constant name before_remove_for_comments
+# wrong constant name before_remove_for_comments=
+# wrong constant name before_remove_for_comments?
+# uninitialized constant Prime
+# uninitialized constant Prime
+# wrong constant name <<
+# wrong constant name >>
+# wrong constant name clone
+# uninitialized constant Proc0
+# uninitialized constant Proc0
+# uninitialized constant Proc1
+# uninitialized constant Proc1
+# uninitialized constant Proc10
+# uninitialized constant Proc10
+# uninitialized constant Proc2
+# uninitialized constant Proc2
+# uninitialized constant Proc3
+# uninitialized constant Proc3
+# uninitialized constant Proc4
+# uninitialized constant Proc4
+# uninitialized constant Proc5
+# uninitialized constant Proc5
+# uninitialized constant Proc6
+# uninitialized constant Proc6
+# uninitialized constant Proc7
+# uninitialized constant Proc7
+# uninitialized constant Proc8
+# uninitialized constant Proc8
+# uninitialized constant Proc9
+# uninitialized constant Proc9
+# uninitialized constant Pry::BasicObject::RUBYGEMS_ACTIVATION_MONITOR
+# uninitialized constant Pry::Command::COLORS
+# uninitialized constant Pry::Command::Ls::COLORS
+# uninitialized constant Pry::Command::Ls::VOID_VALUE
+# uninitialized constant Pry::Command::Wtf::COLORS
+# uninitialized constant Pry::Command::Wtf::VOID_VALUE
+# uninitialized constant Psych::UnsafeYAML
+# uninitialized constant Psych::UnsafeYAML
+# wrong constant name add_builtin_type
+# wrong constant name add_domain_type
+# wrong constant name add_tag
+# wrong constant name domain_types
+# wrong constant name domain_types=
+# wrong constant name dump_tags
+# wrong constant name dump_tags=
+# wrong constant name libyaml_version
+# wrong constant name load_tags
+# wrong constant name load_tags=
+# wrong constant name remove_type
+# uninitialized constant RDoc
+# uninitialized constant RDoc
+# uninitialized constant REXML
+# uninitialized constant REXML
+# uninitialized constant RSpec::Core::ExampleGroup::NOT_YET_IMPLEMENTED
+# uninitialized constant RSpec::Core::ExampleGroup::NO_REASON_GIVEN
+# wrong constant name example_failed
+# wrong constant name example_finished
+# wrong constant name initialize
+# wrong constant name start_dump
+# wrong constant name <static-init>
+# wrong constant name inherited
+# wrong constant name close
+# wrong constant name example_group
+# wrong constant name example_group=
+# wrong constant name example_group_started
+# wrong constant name initialize
+# wrong constant name output
+# wrong constant name start
+# wrong constant name <static-init>
+# wrong constant name dump_failures
+# wrong constant name dump_pending
+# wrong constant name dump_summary
+# wrong constant name message
+# wrong constant name seed
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name notify_results
+# wrong constant name <static-init>
+# wrong constant name example_failed
+# wrong constant name example_group_finished
+# wrong constant name example_passed
+# wrong constant name example_pending
+# wrong constant name <static-init>
+# wrong constant name initialize
+# wrong constant name message
+# wrong constant name output
+# wrong constant name <static-init>
+# wrong constant name dump_summary
+# wrong constant name example_failed
+# wrong constant name example_passed
+# wrong constant name example_pending
+# wrong constant name example_started
+# wrong constant name start_dump
+# wrong constant name <static-init>
+# wrong constant name dump_profile
+# wrong constant name dump_profile_slowest_example_groups
+# wrong constant name dump_profile_slowest_examples
+# wrong constant name dump_summary
+# wrong constant name message
+# wrong constant name output_hash
+# wrong constant name seed
+# wrong constant name stop
+# wrong constant name <static-init>
+# wrong constant name dump_profile
+# wrong constant name initialize
+# wrong constant name output
+# wrong constant name <static-init>
+# wrong constant name example_failed
+# wrong constant name example_passed
+# wrong constant name example_pending
+# wrong constant name start_dump
+# wrong constant name <static-init>
+# wrong constant name write_to_file
+# uninitialized constant RSpec::Matchers::BuiltIn::Equal::UNDEFINED
+# wrong constant name <Class:Differ>
+# wrong constant name color?
+# wrong constant name diff
+# wrong constant name diff_as_object
+# wrong constant name diff_as_string
+# wrong constant name initialize
+# wrong constant name <static-init>
+# uninitialized constant Rake::DSL::DEFAULT
+# uninitialized constant Rake::DSL::LN_SUPPORTED
+# uninitialized constant Rake::DSL::LOW_METHODS
+# uninitialized constant Rake::DSL::METHODS
+# uninitialized constant Rake::DSL::OPT_TABLE
+# uninitialized constant Rake::DSL::RUBY
+# uninitialized constant Rake::DSL::VERSION
+# uninitialized constant Rake::FileUtilsExt::LN_SUPPORTED
+# uninitialized constant Rake::FileUtilsExt::LOW_METHODS
+# uninitialized constant Rake::FileUtilsExt::METHODS
+# uninitialized constant Rake::FileUtilsExt::OPT_TABLE
+# uninitialized constant Rake::FileUtilsExt::RUBY
+# uninitialized constant Rake::FileUtilsExt::VERSION
+# wrong constant name bytes
+# wrong constant name %
+# uninitialized constant Range::RANGE_FORMATS
+# wrong constant name entries
+# wrong constant name to_a
+# wrong constant name expand
+# wrong constant name fire_update!
+# wrong constant name ruby
+# uninitialized constant Readline
+# uninitialized constant Readline
+# uninitialized constant Rinda
+# uninitialized constant Rinda
+# uninitialized constant Ripper
+# uninitialized constant Ripper
+# wrong constant name <Class:Node>
+# wrong constant name children
+# wrong constant name first_column
+# wrong constant name first_lineno
+# wrong constant name last_column
+# wrong constant name last_lineno
+# wrong constant name pretty_print_children
+# wrong constant name type
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name of
+# wrong constant name parse
+# wrong constant name parse_file
+# wrong constant name <static-init>
+# wrong constant name enabled?
+# wrong constant name pause
+# wrong constant name resume
+# wrong constant name resolve_feature_path
+# uninitialized constant SDBM
+# uninitialized constant SDBM
+# uninitialized constant SDBMError
+# uninitialized constant SDBMError
+# wrong constant name <Class:Blob>
+# uninitialized constant SQLite3::Blob::BLANK_RE
+# uninitialized constant SQLite3::Blob::ENCODED_BLANKS
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant SQLite3::Database::AUTO_VACUUM_MODES
+# uninitialized constant SQLite3::Database::ENCODINGS
+# uninitialized constant SQLite3::Database::JOURNAL_MODES
+# uninitialized constant SQLite3::Database::LOCKING_MODES
+# uninitialized constant SQLite3::Database::SYNCHRONOUS_MODES
+# uninitialized constant SQLite3::Database::TEMP_STORE_MODES
+# uninitialized constant SQLite3::Database::WAL_CHECKPOINTS
+# uninitialized constant Scanf
+# uninitialized constant Scanf
+# wrong constant name ==
+# wrong constant name ===
+# wrong constant name compare_by_identity
+# wrong constant name compare_by_identity?
+# wrong constant name divide
+# wrong constant name eql?
+# wrong constant name flatten_merge
+# wrong constant name pretty_print
+# wrong constant name pretty_print_cycle
+# wrong constant name reset
+# uninitialized constant Shell
+# uninitialized constant Shell
+# wrong constant name _dump
+# wrong constant name clone
+# wrong constant name dup
+# wrong constant name _load
+# wrong constant name clone
+# wrong constant name __init__
+# uninitialized constant SortedSet::InspectKey
+# wrong constant name initialize
+# wrong constant name setup
+# wrong constant name shellescape
+# wrong constant name shellsplit
+# wrong constant name bol?
+# wrong constant name initialize
+# wrong constant name filter
+# wrong constant name <Class:Struct>
+# uninitialized constant Sync
+# uninitialized constant Sync
+# uninitialized constant Sync_m
+# uninitialized constant Sync_m
+# uninitialized constant Syslog
+# uninitialized constant Syslog
+# wrong constant name T.noreturn
+# wrong constant name T.noreturn
+# wrong constant name T.untyped
+# uninitialized constant TappingDevice::DEFAULTS
+# uninitialized constant TappingDevice::Output::Payload::ATTRS
+# uninitialized constant TappingDevice::Output::Payload::Elem
+# uninitialized constant TappingDevice::Output::Payload::K
+# uninitialized constant TappingDevice::Output::Payload::V
+# wrong constant name arguments_and_defined_class
+# wrong constant name arguments_and_defined_class_with_color
+# wrong constant name arguments_and_ivar_changes
+# wrong constant name arguments_and_ivar_changes_with_color
+# wrong constant name arguments_and_location
+# wrong constant name arguments_and_location_with_color
+# wrong constant name arguments_and_method_name
+# wrong constant name arguments_and_method_name_with_color
+# wrong constant name arguments_and_return_value
+# wrong constant name arguments_and_return_value_with_color
+# wrong constant name arguments_with_color
+# wrong constant name defined_class_and_arguments
+# wrong constant name defined_class_and_arguments_with_color
+# wrong constant name defined_class_and_ivar_changes
+# wrong constant name defined_class_and_ivar_changes_with_color
+# wrong constant name defined_class_and_location
+# wrong constant name defined_class_and_location_with_color
+# wrong constant name defined_class_and_method_name
+# wrong constant name defined_class_and_method_name_with_color
+# wrong constant name defined_class_and_return_value
+# wrong constant name defined_class_and_return_value_with_color
+# wrong constant name defined_class_with_color
+# wrong constant name ivar_changes_and_arguments
+# wrong constant name ivar_changes_and_arguments_with_color
+# wrong constant name ivar_changes_and_defined_class
+# wrong constant name ivar_changes_and_defined_class_with_color
+# wrong constant name ivar_changes_and_location
+# wrong constant name ivar_changes_and_location_with_color
+# wrong constant name ivar_changes_and_method_name
+# wrong constant name ivar_changes_and_method_name_with_color
+# wrong constant name ivar_changes_and_return_value
+# wrong constant name ivar_changes_and_return_value_with_color
+# wrong constant name ivar_changes_with_color
+# wrong constant name location_and_arguments
+# wrong constant name location_and_arguments_with_color
+# wrong constant name location_and_defined_class
+# wrong constant name location_and_defined_class_with_color
+# wrong constant name location_and_ivar_changes
+# wrong constant name location_and_ivar_changes_with_color
+# wrong constant name location_and_method_name
+# wrong constant name location_and_method_name_with_color
+# wrong constant name location_and_return_value
+# wrong constant name location_and_return_value_with_color
+# wrong constant name location_with_color
+# wrong constant name method_name_and_arguments
+# wrong constant name method_name_and_arguments_with_color
+# wrong constant name method_name_and_defined_class
+# wrong constant name method_name_and_defined_class_with_color
+# wrong constant name method_name_and_ivar_changes
+# wrong constant name method_name_and_ivar_changes_with_color
+# wrong constant name method_name_and_location
+# wrong constant name method_name_and_location_with_color
+# wrong constant name method_name_and_return_value
+# wrong constant name method_name_and_return_value_with_color
+# wrong constant name method_name_with_color
+# wrong constant name original_arguments
+# wrong constant name original_defined_class
+# wrong constant name original_ivar_changes
+# wrong constant name original_location
+# wrong constant name original_method_name
+# wrong constant name original_return_value
+# wrong constant name return_value_and_arguments
+# wrong constant name return_value_and_arguments_with_color
+# wrong constant name return_value_and_defined_class
+# wrong constant name return_value_and_defined_class_with_color
+# wrong constant name return_value_and_ivar_changes
+# wrong constant name return_value_and_ivar_changes_with_color
+# wrong constant name return_value_and_location
+# wrong constant name return_value_and_location_with_color
+# wrong constant name return_value_and_method_name
+# wrong constant name return_value_and_method_name_with_color
+# wrong constant name return_value_with_color
+# wrong constant name arguments
+# wrong constant name defined_class
+# wrong constant name filepath
+# wrong constant name is_private_call?
+# wrong constant name ivar_changes
+# wrong constant name line_number
+# wrong constant name method_name
+# wrong constant name method_object
+# wrong constant name receiver
+# wrong constant name return_value
+# wrong constant name tag
+# wrong constant name target
+# wrong constant name tp
+# wrong constant name trace
+# wrong constant name print_calls
+# wrong constant name print_instance_calls
+# wrong constant name print_instance_mutations
+# wrong constant name print_instance_traces
+# wrong constant name print_mutations
+# wrong constant name print_traces
+# wrong constant name with_print_calls
+# wrong constant name with_print_mutations
+# wrong constant name with_print_traces
+# wrong constant name with_write_calls
+# wrong constant name with_write_mutations
+# wrong constant name with_write_traces
+# wrong constant name write_calls
+# wrong constant name write_instance_calls
+# wrong constant name write_instance_mutations
+# wrong constant name write_instance_traces
+# wrong constant name write_mutations
+# wrong constant name write_traces
+# wrong constant name <Class:Remover>
+# wrong constant name _close
+# wrong constant name inspect
+# wrong constant name call
+# wrong constant name initialize
+# wrong constant name <static-init>
+# wrong constant name <Class:AtomicReferenceCacheBackend>
+# wrong constant name <Class:SynchronizedCacheBackend>
+# wrong constant name <Class:Util>
+# wrong constant name <Class:Node>
+# wrong constant name <Class:Table>
+# wrong constant name []
+# wrong constant name []=
+# wrong constant name clear
+# wrong constant name compute
+# wrong constant name compute_if_absent
+# wrong constant name compute_if_present
+# wrong constant name delete
+# wrong constant name delete_pair
+# wrong constant name each_pair
+# wrong constant name empty?
+# wrong constant name get_and_set
+# wrong constant name get_or_default
+# wrong constant name initialize
+# wrong constant name key?
+# wrong constant name merge_pair
+# wrong constant name replace_if_exists
+# wrong constant name replace_pair
+# wrong constant name size
+# wrong constant name initialize
+# wrong constant name key
+# wrong constant name key?
+# wrong constant name locked?
+# wrong constant name matches?
+# wrong constant name pure_hash
+# wrong constant name try_await_lock
+# wrong constant name try_lock_via_hash
+# wrong constant name unlock_via_hash
+# wrong constant name <static-init>
+# wrong constant name locked_hash?
+# uninitialized constant ThreadSafe::AtomicReferenceCacheBackend::Table::Elem
+# wrong constant name cas_new_node
+# wrong constant name delete_node_at
+# wrong constant name try_lock_via_hash
+# wrong constant name try_to_cas_in_computed
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ThreadSafe::SynchronizedCacheBackend::VERSION
+# wrong constant name lock
+# wrong constant name locked?
+# wrong constant name synchronize
+# wrong constant name try_lock
+# wrong constant name unlock
+# wrong constant name <static-init>
+# wrong constant name <Class:Adder>
+# wrong constant name <Class:AtomicReference>
+# wrong constant name <Class:CheapLockable>
+# wrong constant name <Class:PowerOfTwoTuple>
+# wrong constant name <Class:Striped64>
+# wrong constant name <Class:Volatile>
+# wrong constant name <Class:VolatileTuple>
+# wrong constant name <Class:XorShiftRandom>
+# uninitialized constant ThreadSafe::Util::Adder::THREAD_LOCAL_KEY
+# wrong constant name add
+# wrong constant name decrement
+# wrong constant name increment
+# wrong constant name reset
+# wrong constant name sum
+# wrong constant name <static-init>
+# wrong constant name compare_and_set
+# wrong constant name get
+# wrong constant name initialize
+# wrong constant name set
+# wrong constant name value
+# wrong constant name value=
+# wrong constant name <static-init>
+# wrong constant name cas_mutex
+# wrong constant name compare_and_set_mutex
+# wrong constant name lazy_set_mutex
+# wrong constant name mutex
+# wrong constant name mutex=
+# wrong constant name <static-init>
+# uninitialized constant ThreadSafe::Util::PowerOfTwoTuple::Elem
+# wrong constant name hash_to_index
+# wrong constant name next_in_size_table
+# wrong constant name volatile_get_by_hash
+# wrong constant name volatile_set_by_hash
+# wrong constant name <static-init>
+# wrong constant name <Class:Cell>
+# wrong constant name busy?
+# wrong constant name initialize
+# wrong constant name retry_update
+# wrong constant name cas
+# wrong constant name cas_computed
+# wrong constant name padding_
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name attr_volatile
+# wrong constant name <static-init>
+# uninitialized constant ThreadSafe::Util::VolatileTuple::Elem
+# wrong constant name cas
+# wrong constant name compare_and_set
+# wrong constant name each
+# wrong constant name initialize
+# wrong constant name size
+# wrong constant name volatile_get
+# wrong constant name volatile_set
+# wrong constant name <static-init>
+# wrong constant name get
+# wrong constant name xorshift
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# uninitialized constant ThreadsWait
+# uninitialized constant ThreadsWait
+# uninitialized constant Time::DAYS_INTO_WEEK
+# uninitialized constant Time::WEEKEND_DAYS
+# wrong constant name __enable
+# wrong constant name eval_script
+# wrong constant name instruction_sequence
+# wrong constant name parameters
+# uninitialized constant Tracer
+# uninitialized constant Tracer
+# wrong constant name <Class:File>
+# wrong constant name new2
+# uninitialized constant URI::File::ABS_PATH
+# uninitialized constant URI::File::ABS_URI
+# uninitialized constant URI::File::ABS_URI_REF
+# uninitialized constant URI::File::DEFAULT_PARSER
+# uninitialized constant URI::File::ESCAPED
+# uninitialized constant URI::File::FRAGMENT
+# uninitialized constant URI::File::HOST
+# uninitialized constant URI::File::OPAQUE
+# uninitialized constant URI::File::PORT
+# uninitialized constant URI::File::QUERY
+# uninitialized constant URI::File::REGISTRY
+# uninitialized constant URI::File::REL_PATH
+# uninitialized constant URI::File::REL_URI
+# uninitialized constant URI::File::REL_URI_REF
+# uninitialized constant URI::File::RFC3986_PARSER
+# uninitialized constant URI::File::SCHEME
+# uninitialized constant URI::File::TBLDECWWWCOMP_
+# uninitialized constant URI::File::TBLENCWWWCOMP_
+# uninitialized constant URI::File::UNSAFE
+# uninitialized constant URI::File::URI_REF
+# uninitialized constant URI::File::USERINFO
+# uninitialized constant URI::File::USE_REGISTRY
+# uninitialized constant URI::File::VERSION
+# uninitialized constant URI::File::VERSION_CODE
+# uninitialized constant URI::File::WEB_ENCODINGS_
+# wrong constant name check_password
+# wrong constant name check_user
+# wrong constant name check_userinfo
+# wrong constant name set_userinfo
+# wrong constant name <static-init>
+# wrong constant name attributes
+# wrong constant name attributes=
+# wrong constant name dn
+# wrong constant name dn=
+# wrong constant name extensions
+# wrong constant name extensions=
+# wrong constant name filter
+# wrong constant name filter=
+# wrong constant name initialize
+# wrong constant name scope
+# wrong constant name scope=
+# wrong constant name set_attributes
+# wrong constant name set_dn
+# wrong constant name set_extensions
+# wrong constant name set_filter
+# wrong constant name set_scope
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name join
+# wrong constant name parse
+# wrong constant name regexp
+# wrong constant name split
+# wrong constant name make_components_hash
+# wrong constant name get_encoding
+# wrong constant name <static-init>
+# uninitialized constant User::ACTIONS
+# uninitialized constant User::CALLBACKS
+# uninitialized constant User::CALLBACK_FILTER_TYPES
+# uninitialized constant User::CALL_COMPILABLE_REGEXP
+# wrong constant name <Class:GeneratedAssociationMethods>
+# wrong constant name <Class:GeneratedAttributeMethods>
+# uninitialized constant User::MAX_PASSWORD_LENGTH_ALLOWED
+# uninitialized constant User::NAME_COMPILABLE_REGEXP
+# uninitialized constant User::RESTRICTED_CLASS_METHODS
+# uninitialized constant User::UNASSIGNABLE_KEYS
+# wrong constant name after_add_for_comments
+# wrong constant name after_add_for_comments=
+# wrong constant name after_add_for_comments?
+# wrong constant name after_add_for_posts
+# wrong constant name after_add_for_posts=
+# wrong constant name after_add_for_posts?
+# wrong constant name after_remove_for_comments
+# wrong constant name after_remove_for_comments=
+# wrong constant name after_remove_for_comments?
+# wrong constant name after_remove_for_posts
+# wrong constant name after_remove_for_posts=
+# wrong constant name after_remove_for_posts?
+# wrong constant name autosave_associated_records_for_comments
+# wrong constant name autosave_associated_records_for_posts
+# wrong constant name before_add_for_comments
+# wrong constant name before_add_for_comments=
+# wrong constant name before_add_for_comments?
+# wrong constant name before_add_for_posts
+# wrong constant name before_add_for_posts=
+# wrong constant name before_add_for_posts?
+# wrong constant name before_remove_for_comments
+# wrong constant name before_remove_for_comments=
+# wrong constant name before_remove_for_comments?
+# wrong constant name before_remove_for_posts
+# wrong constant name before_remove_for_posts=
+# wrong constant name before_remove_for_posts?
+# wrong constant name validate_associated_records_for_comments
+# wrong constant name validate_associated_records_for_posts
+# wrong constant name comment_ids
+# wrong constant name comment_ids=
+# wrong constant name comments
+# wrong constant name comments=
+# wrong constant name post_ids
+# wrong constant name post_ids=
+# wrong constant name posts
+# wrong constant name posts=
+# wrong constant name <static-init>
+# wrong constant name <static-init>
+# wrong constant name after_add_for_comments
+# wrong constant name after_add_for_comments=
+# wrong constant name after_add_for_comments?
+# wrong constant name after_add_for_posts
+# wrong constant name after_add_for_posts=
+# wrong constant name after_add_for_posts?
+# wrong constant name after_remove_for_comments
+# wrong constant name after_remove_for_comments=
+# wrong constant name after_remove_for_comments?
+# wrong constant name after_remove_for_posts
+# wrong constant name after_remove_for_posts=
+# wrong constant name after_remove_for_posts?
+# wrong constant name before_add_for_comments
+# wrong constant name before_add_for_comments=
+# wrong constant name before_add_for_comments?
+# wrong constant name before_add_for_posts
+# wrong constant name before_add_for_posts=
+# wrong constant name before_add_for_posts?
+# wrong constant name before_remove_for_comments
+# wrong constant name before_remove_for_comments=
+# wrong constant name before_remove_for_comments?
+# wrong constant name before_remove_for_posts
+# wrong constant name before_remove_for_posts=
+# wrong constant name before_remove_for_posts?
+# uninitialized constant Vector
+# uninitialized constant Vector
+# uninitialized constant WEBrick
+# uninitialized constant WEBrick
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name initialize
+# wrong constant name initialize
diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi
new file mode 100644
index 0000000..a8902a4
--- /dev/null
+++ b/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -0,0 +1,9220 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi hidden-definitions
+
+# typed: autogenerated
+
+module ActiveModel::AttributeMethods
+  CALL_COMPILABLE_REGEXP = ::T.let(nil, ::T.untyped)
+  NAME_COMPILABLE_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::AttributeMethods::AttrNames
+  DEF_SAFE_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::AttributeMutationTracker
+  OPTION_NOT_GIVEN = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::Attributes
+  def attribute_names(); end
+
+  def attributes(); end
+
+  def initialize(*_); end
+end
+
+module ActiveModel::Attributes::ClassMethods
+  def attribute(name, type=T.unsafe(nil), **options); end
+
+  def attribute_names(); end
+end
+
+module ActiveModel::Attributes::ClassMethods
+end
+
+module ActiveModel::Attributes
+  extend ::ActiveSupport::Concern
+end
+
+class ActiveModel::Errors
+  CALLBACKS_OPTIONS = ::T.let(nil, ::T.untyped)
+  MESSAGE_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::Lint
+end
+
+module ActiveModel::Lint::Tests
+  def test_errors_aref(); end
+
+  def test_model_naming(); end
+
+  def test_persisted?(); end
+
+  def test_to_key(); end
+
+  def test_to_param(); end
+
+  def test_to_partial_path(); end
+end
+
+module ActiveModel::Lint::Tests
+end
+
+module ActiveModel::Lint
+end
+
+module ActiveModel::Model
+  include ::ActiveModel::AttributeAssignment
+  include ::ActiveModel::ForbiddenAttributesProtection
+  def initialize(attributes=T.unsafe(nil)); end
+
+  def persisted?(); end
+end
+
+module ActiveModel::Model
+  extend ::ActiveSupport::Concern
+end
+
+module ActiveModel::SecurePassword
+  MAX_PASSWORD_LENGTH_ALLOWED = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Type::Boolean
+  FALSE_VALUES = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Type::Date
+  ISO_DATE = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Type::Decimal
+  BIGDECIMAL_PRECISION = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::Type::Helpers::TimeValue
+  ISO_DATETIME = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Type::Integer
+  DEFAULT_LIMIT = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::VERSION
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  PRE = ::T.let(nil, ::T.untyped)
+  STRING = ::T.let(nil, ::T.untyped)
+  TINY = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::Validations::ClassMethods
+  VALID_OPTIONS_FOR_VALIDATE = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveModel::Validations::Clusivity
+  ERROR_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Validations::LengthValidator
+  CHECKS = ::T.let(nil, ::T.untyped)
+  MESSAGES = ::T.let(nil, ::T.untyped)
+  RESERVED_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveModel::Validations::NumericalityValidator
+  CHECKS = ::T.let(nil, ::T.untyped)
+  HEXADECIMAL_REGEX = ::T.let(nil, ::T.untyped)
+  INTEGER_REGEX = ::T.let(nil, ::T.untyped)
+  RESERVED_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::AdvisoryLockBase
+  include ::ActiveRecord::AdvisoryLockBase::GeneratedAttributeMethods
+  include ::ActiveRecord::AdvisoryLockBase::GeneratedAssociationMethods
+end
+
+module ActiveRecord::AdvisoryLockBase::GeneratedAssociationMethods
+end
+
+module ActiveRecord::AdvisoryLockBase::GeneratedAssociationMethods
+end
+
+module ActiveRecord::AdvisoryLockBase::GeneratedAttributeMethods
+end
+
+module ActiveRecord::AdvisoryLockBase::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+class ActiveRecord::AdvisoryLockBase
+end
+
+class ActiveRecord::Associations::AliasTracker
+  def aliased_table_for(table_name, aliased_name, type_caster); end
+
+  def aliases(); end
+
+  def initialize(connection, aliases); end
+end
+
+class ActiveRecord::Associations::AliasTracker
+  def self.create(connection, initial_table, joins); end
+
+  def self.initial_count_for(connection, name, table_joins); end
+end
+
+class ActiveRecord::Associations::Association
+  def create(attributes=T.unsafe(nil), &block); end
+
+  def create!(attributes=T.unsafe(nil), &block); end
+
+  def extensions(); end
+
+  def initialize(owner, reflection); end
+
+  def initialize_attributes(record, except_from_scope_attributes=T.unsafe(nil)); end
+
+  def inversed_from(record); end
+
+  def inversed_from_queries(record); end
+
+  def klass(); end
+
+  def load_target(); end
+
+  def loaded!(); end
+
+  def loaded?(); end
+
+  def marshal_dump(); end
+
+  def marshal_load(data); end
+
+  def options(*args, &block); end
+
+  def owner(); end
+
+  def reflection(); end
+
+  def reload(force=T.unsafe(nil)); end
+
+  def remove_inverse_instance(record); end
+
+  def reset(); end
+
+  def reset_scope(); end
+
+  def scope(); end
+
+  def set_inverse_instance(record); end
+
+  def set_inverse_instance_from_queries(record); end
+
+  def stale_target?(); end
+
+  def target(); end
+
+  def target=(target); end
+end
+
+class ActiveRecord::Associations::Association
+end
+
+class ActiveRecord::Associations::AssociationScope
+  def initialize(value_transformation); end
+
+  def scope(association); end
+  INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Associations::AssociationScope::ReflectionProxy
+  def aliased_table(); end
+
+  def all_includes(); end
+
+  def initialize(reflection, aliased_table); end
+end
+
+class ActiveRecord::Associations::AssociationScope::ReflectionProxy
+end
+
+class ActiveRecord::Associations::AssociationScope
+  def self.create(&block); end
+
+  def self.get_bind_values(owner, chain); end
+
+  def self.scope(association); end
+end
+
+class ActiveRecord::Associations::BelongsToAssociation
+  def decrement_counters(); end
+
+  def decrement_counters_before_last_save(); end
+
+  def default(&block); end
+
+  def handle_dependency(); end
+
+  def increment_counters(); end
+
+  def target_changed?(); end
+
+  def updated?(); end
+end
+
+class ActiveRecord::Associations::BelongsToAssociation
+end
+
+class ActiveRecord::Associations::BelongsToPolymorphicAssociation
+end
+
+class ActiveRecord::Associations::BelongsToPolymorphicAssociation
+end
+
+class ActiveRecord::Associations::Builder::Association
+  VALID_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Associations::Builder::CollectionAssociation
+  CALLBACKS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Associations::Builder::HasAndBelongsToMany
+  def association_name(); end
+
+  def initialize(association_name, lhs_model, options); end
+
+  def lhs_model(); end
+
+  def middle_reflection(join_model); end
+
+  def options(); end
+
+  def through_model(); end
+end
+
+class ActiveRecord::Associations::Builder::HasAndBelongsToMany
+end
+
+class ActiveRecord::Associations::Builder::HasOne
+end
+
+class ActiveRecord::Associations::Builder::HasOne
+  def self.touch_record(o, name, touch); end
+end
+
+class ActiveRecord::Associations::CollectionAssociation
+  def add_to_target(record, skip_callbacks=T.unsafe(nil), &block); end
+
+  def build(attributes=T.unsafe(nil), &block); end
+
+  def concat(*records); end
+
+  def delete(*records); end
+
+  def delete_all(dependent=T.unsafe(nil)); end
+
+  def destroy(*records); end
+
+  def destroy_all(); end
+
+  def empty?(); end
+
+  def find(*args); end
+
+  def find_from_target?(); end
+
+  def ids_reader(); end
+
+  def ids_writer(ids); end
+
+  def include?(record); end
+
+  def null_scope?(); end
+
+  def reader(); end
+
+  def replace(other_array); end
+
+  def size(); end
+
+  def transaction(*args); end
+
+  def writer(records); end
+end
+
+class ActiveRecord::Associations::CollectionAssociation
+end
+
+module ActiveRecord::Associations::ForeignAssociation
+  def foreign_key_present?(); end
+
+  def nullified_owner_attributes(); end
+end
+
+module ActiveRecord::Associations::ForeignAssociation
+end
+
+class ActiveRecord::Associations::HasManyAssociation
+  include ::ActiveRecord::Associations::ForeignAssociation
+  def handle_dependency(); end
+
+  def insert_record(record, validate=T.unsafe(nil), raise=T.unsafe(nil)); end
+end
+
+class ActiveRecord::Associations::HasManyAssociation
+end
+
+class ActiveRecord::Associations::HasManyThroughAssociation
+  include ::ActiveRecord::Associations::ThroughAssociation
+end
+
+class ActiveRecord::Associations::HasManyThroughAssociation
+end
+
+class ActiveRecord::Associations::HasOneAssociation
+  include ::ActiveRecord::Associations::ForeignAssociation
+  def delete(method=T.unsafe(nil)); end
+
+  def handle_dependency(); end
+end
+
+class ActiveRecord::Associations::HasOneAssociation
+end
+
+class ActiveRecord::Associations::HasOneThroughAssociation
+  include ::ActiveRecord::Associations::ThroughAssociation
+end
+
+class ActiveRecord::Associations::HasOneThroughAssociation
+end
+
+class ActiveRecord::Associations::JoinDependency
+  def apply_column_aliases(relation); end
+
+  def base_klass(); end
+
+  def initialize(base, table, associations, join_type); end
+
+  def instantiate(result_set, &block); end
+
+  def join_constraints(joins_to_add, alias_tracker); end
+
+  def join_root(); end
+
+  def join_type(); end
+
+  def reflections(); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases
+  def column_alias(node, column); end
+
+  def column_aliases(node); end
+
+  def columns(); end
+
+  def initialize(tables); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases::Column
+  def alias(); end
+
+  def alias=(_); end
+
+  def name(); end
+
+  def name=(_); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases::Column
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases::Table
+  def column_aliases(); end
+
+  def columns(); end
+
+  def columns=(_); end
+
+  def node(); end
+
+  def node=(_); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases::Table
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class ActiveRecord::Associations::JoinDependency::Aliases
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinAssociation
+  def initialize(reflection, children); end
+
+  def join_constraints(foreign_table, foreign_klass, join_type, alias_tracker); end
+
+  def readonly?(); end
+
+  def reflection(); end
+
+  def table=(table); end
+
+  def tables(); end
+
+  def tables=(tables); end
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinAssociation
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinBase
+  def initialize(base_klass, table, children); end
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinBase
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinPart
+  include ::Enumerable
+  def base_klass(); end
+
+  def children(); end
+
+  def column_names(*args, &block); end
+
+  def each(&block); end
+
+  def each_children(&block); end
+
+  def extract_record(row, column_names_with_alias); end
+
+  def initialize(base_klass, children); end
+
+  def instantiate(row, aliases, &block); end
+
+  def match?(other); end
+
+  def primary_key(*args, &block); end
+
+  def table(); end
+
+  def table_name(*args, &block); end
+end
+
+class ActiveRecord::Associations::JoinDependency::JoinPart
+end
+
+class ActiveRecord::Associations::JoinDependency
+  def self.make_tree(associations); end
+
+  def self.walk_tree(associations, hash); end
+end
+
+class ActiveRecord::Associations::Preloader
+  def preload(records, associations, preload_scope=T.unsafe(nil)); end
+end
+
+class ActiveRecord::Associations::Preloader::AlreadyLoaded
+  def initialize(klass, owners, reflection, preload_scope); end
+
+  def preloaded_records(); end
+
+  def records_by_owner(); end
+
+  def run(); end
+end
+
+class ActiveRecord::Associations::Preloader::AlreadyLoaded
+end
+
+class ActiveRecord::Associations::Preloader::Association
+  def initialize(klass, owners, reflection, preload_scope); end
+
+  def preloaded_records(); end
+
+  def records_by_owner(); end
+
+  def run(); end
+end
+
+class ActiveRecord::Associations::Preloader::Association
+end
+
+class ActiveRecord::Associations::Preloader::ThroughAssociation
+  def initialize(*_); end
+  PRELOADER = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Associations::Preloader::ThroughAssociation
+end
+
+class ActiveRecord::Associations::Preloader
+  extend ::ActiveSupport::Autoload
+end
+
+class ActiveRecord::Associations::SingularAssociation
+  def build(attributes=T.unsafe(nil), &block); end
+
+  def force_reload_reader(); end
+
+  def reader(); end
+
+  def writer(record); end
+end
+
+class ActiveRecord::Associations::SingularAssociation
+end
+
+module ActiveRecord::Associations::ThroughAssociation
+  def source_reflection(*args, &block); end
+end
+
+module ActiveRecord::Associations::ThroughAssociation
+end
+
+module ActiveRecord::AttributeMethods
+  RESTRICTED_CLASS_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::Base::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+module ActiveRecord::Batches
+  ORDER_IGNORE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::Callbacks
+  CALLBACKS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Coders::JSON
+end
+
+class ActiveRecord::Coders::JSON
+  def self.dump(obj); end
+
+  def self.load(json); end
+end
+
+class ActiveRecord::Coders::YAMLColumn
+  def assert_valid_value(obj, action:); end
+
+  def dump(obj); end
+
+  def initialize(attr_name, object_class=T.unsafe(nil)); end
+
+  def load(yaml); end
+
+  def object_class(); end
+
+  def object_class=(object_class); end
+end
+
+class ActiveRecord::Coders::YAMLColumn
+end
+
+class ActiveRecord::ConcurrentMigrationError
+  DEFAULT_MESSAGE = ::T.let(nil, ::T.untyped)
+  RELEASE_LOCK_FAILED_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  include ::ActiveRecord::ConnectionAdapters::SchemaStatements
+  include ::ActiveRecord::Migration::JoinTable
+  include ::ActiveRecord::ConnectionAdapters::DatabaseStatements
+  ADAPTER_NAME = ::T.let(nil, ::T.untyped)
+  COMMENT_REGEX = ::T.let(nil, ::T.untyped)
+  SIMPLE_INT = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::ConnectionAdapters::SQLite3Adapter
+  ADAPTER_NAME = ::T.let(nil, ::T.untyped)
+  COLLATE_REGEX = ::T.let(nil, ::T.untyped)
+  NATIVE_DATABASE_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+ActiveRecord::ConnectionAdapters::SchemaCreation = ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+class ActiveRecord::ConnectionAdapters::StatementPool
+  DEFAULT_STATEMENT_LIMIT = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::ConnectionAdapters::TransactionManager
+  NULL_TRANSACTION = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::ConnectionHandling
+  DEFAULT_ENV = ::T.let(nil, ::T.untyped)
+  RAILS_ENV = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::ExplainRegistry
+  def self.collect?(*args, &block); end
+end
+
+class ActiveRecord::ExplainSubscriber
+  EXPLAINED_SQLS = ::T.let(nil, ::T.untyped)
+  IGNORED_PAYLOADS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::FinderMethods
+  ONE_AS_ONE = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::InternalMetadata::GeneratedAttributeMethods
+  def created_at(); end
+
+  def created_at=(value); end
+
+  def created_at?(*args); end
+
+  def created_at_before_last_save(*args); end
+
+  def created_at_before_type_cast(*args); end
+
+  def created_at_came_from_user?(*args); end
+
+  def created_at_change(*args); end
+
+  def created_at_change_to_be_saved(*args); end
+
+  def created_at_changed?(*args); end
+
+  def created_at_in_database(*args); end
+
+  def created_at_previous_change(*args); end
+
+  def created_at_previously_changed?(*args); end
+
+  def created_at_was(*args); end
+
+  def created_at_will_change!(*args); end
+
+  def key(); end
+
+  def key=(value); end
+
+  def key?(*args); end
+
+  def key_before_last_save(*args); end
+
+  def key_before_type_cast(*args); end
+
+  def key_came_from_user?(*args); end
+
+  def key_change(*args); end
+
+  def key_change_to_be_saved(*args); end
+
+  def key_changed?(*args); end
+
+  def key_in_database(*args); end
+
+  def key_previous_change(*args); end
+
+  def key_previously_changed?(*args); end
+
+  def key_was(*args); end
+
+  def key_will_change!(*args); end
+
+  def restore_created_at!(*args); end
+
+  def restore_key!(*args); end
+
+  def restore_updated_at!(*args); end
+
+  def restore_value!(*args); end
+
+  def saved_change_to_created_at(*args); end
+
+  def saved_change_to_created_at?(*args); end
+
+  def saved_change_to_key(*args); end
+
+  def saved_change_to_key?(*args); end
+
+  def saved_change_to_updated_at(*args); end
+
+  def saved_change_to_updated_at?(*args); end
+
+  def saved_change_to_value(*args); end
+
+  def saved_change_to_value?(*args); end
+
+  def updated_at(); end
+
+  def updated_at=(value); end
+
+  def updated_at?(*args); end
+
+  def updated_at_before_last_save(*args); end
+
+  def updated_at_before_type_cast(*args); end
+
+  def updated_at_came_from_user?(*args); end
+
+  def updated_at_change(*args); end
+
+  def updated_at_change_to_be_saved(*args); end
+
+  def updated_at_changed?(*args); end
+
+  def updated_at_in_database(*args); end
+
+  def updated_at_previous_change(*args); end
+
+  def updated_at_previously_changed?(*args); end
+
+  def updated_at_was(*args); end
+
+  def updated_at_will_change!(*args); end
+
+  def value(); end
+
+  def value=(value); end
+
+  def value?(*args); end
+
+  def value_before_last_save(*args); end
+
+  def value_before_type_cast(*args); end
+
+  def value_came_from_user?(*args); end
+
+  def value_change(*args); end
+
+  def value_change_to_be_saved(*args); end
+
+  def value_changed?(*args); end
+
+  def value_in_database(*args); end
+
+  def value_previous_change(*args); end
+
+  def value_previously_changed?(*args); end
+
+  def value_was(*args); end
+
+  def value_will_change!(*args); end
+
+  def will_save_change_to_created_at?(*args); end
+
+  def will_save_change_to_key?(*args); end
+
+  def will_save_change_to_updated_at?(*args); end
+
+  def will_save_change_to_value?(*args); end
+end
+
+module ActiveRecord::InternalMetadata::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+module ActiveRecord::LegacyYamlAdapter
+end
+
+module ActiveRecord::LegacyYamlAdapter::Rails41
+end
+
+module ActiveRecord::LegacyYamlAdapter::Rails41
+  def self.convert(klass, coder); end
+end
+
+module ActiveRecord::LegacyYamlAdapter::Rails420
+end
+
+module ActiveRecord::LegacyYamlAdapter::Rails420
+  def self.convert(klass, coder); end
+end
+
+module ActiveRecord::LegacyYamlAdapter
+  def self.convert(klass, coder); end
+end
+
+class ActiveRecord::Locking::LockingType
+end
+
+class ActiveRecord::LogSubscriber
+  def backtrace_cleaner(); end
+
+  def backtrace_cleaner=(val); end
+
+  def backtrace_cleaner?(); end
+
+  def sql(event); end
+  IGNORE_PAYLOAD_NAMES = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Middleware::DatabaseSelector
+  def call(env); end
+
+  def context_klass(); end
+
+  def initialize(app, resolver_klass=T.unsafe(nil), context_klass=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def options(); end
+
+  def resolver_klass(); end
+end
+
+class ActiveRecord::Middleware::DatabaseSelector::Resolver
+  def context(); end
+
+  def delay(); end
+
+  def initialize(context, options=T.unsafe(nil)); end
+
+  def instrumenter(); end
+
+  def read(&blk); end
+
+  def write(&blk); end
+  SEND_TO_REPLICA_DELAY = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+  def initialize(session); end
+
+  def last_write_timestamp(); end
+
+  def session(); end
+
+  def update_last_write_timestamp(); end
+end
+
+class ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+  def self.call(request); end
+
+  def self.convert_time_to_timestamp(time); end
+
+  def self.convert_timestamp_to_time(timestamp); end
+end
+
+class ActiveRecord::Middleware::DatabaseSelector::Resolver
+  def self.call(context, options=T.unsafe(nil)); end
+end
+
+class ActiveRecord::Middleware::DatabaseSelector
+end
+
+class ActiveRecord::Migration
+  MigrationFilenameRegexp = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Migration::CommandRecorder
+  include ::ActiveRecord::Migration::JoinTable
+  include ::ActiveRecord::Migration::CommandRecorder::StraightReversions
+  def add_belongs_to(*args, &block); end
+
+  def add_column(*args, &block); end
+
+  def add_foreign_key(*args, &block); end
+
+  def add_index(*args, &block); end
+
+  def add_reference(*args, &block); end
+
+  def add_timestamps(*args, &block); end
+
+  def change_column(*args, &block); end
+
+  def change_column_comment(*args, &block); end
+
+  def change_column_default(*args, &block); end
+
+  def change_column_null(*args, &block); end
+
+  def change_table(table_name, **options); end
+
+  def change_table_comment(*args, &block); end
+
+  def commands(); end
+
+  def commands=(commands); end
+
+  def create_join_table(*args, &block); end
+
+  def create_table(*args, &block); end
+
+  def delegate(); end
+
+  def delegate=(delegate); end
+
+  def disable_extension(*args, &block); end
+
+  def drop_join_table(*args, &block); end
+
+  def drop_table(*args, &block); end
+
+  def enable_extension(*args, &block); end
+
+  def execute(*args, &block); end
+
+  def execute_block(*args, &block); end
+
+  def initialize(delegate=T.unsafe(nil)); end
+
+  def inverse_of(command, args, &block); end
+
+  def invert_add_belongs_to(args, &block); end
+
+  def invert_remove_belongs_to(args, &block); end
+
+  def record(*command, &block); end
+
+  def remove_belongs_to(*args, &block); end
+
+  def remove_column(*args, &block); end
+
+  def remove_columns(*args, &block); end
+
+  def remove_foreign_key(*args, &block); end
+
+  def remove_index(*args, &block); end
+
+  def remove_reference(*args, &block); end
+
+  def remove_timestamps(*args, &block); end
+
+  def rename_column(*args, &block); end
+
+  def rename_index(*args, &block); end
+
+  def rename_table(*args, &block); end
+
+  def replay(migration); end
+
+  def revert(); end
+
+  def reverting(); end
+
+  def reverting=(reverting); end
+
+  def transaction(*args, &block); end
+  ReversibleAndIrreversibleMethods = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::Migration::CommandRecorder::StraightReversions
+  def invert_add_column(args, &block); end
+
+  def invert_add_foreign_key(args, &block); end
+
+  def invert_add_reference(args, &block); end
+
+  def invert_add_timestamps(args, &block); end
+
+  def invert_create_join_table(args, &block); end
+
+  def invert_create_table(args, &block); end
+
+  def invert_disable_extension(args, &block); end
+
+  def invert_drop_join_table(args, &block); end
+
+  def invert_drop_table(args, &block); end
+
+  def invert_enable_extension(args, &block); end
+
+  def invert_execute_block(args, &block); end
+
+  def invert_remove_column(args, &block); end
+
+  def invert_remove_foreign_key(args, &block); end
+
+  def invert_remove_reference(args, &block); end
+
+  def invert_remove_timestamps(args, &block); end
+end
+
+module ActiveRecord::Migration::CommandRecorder::StraightReversions
+end
+
+class ActiveRecord::Migration::CommandRecorder
+end
+
+class ActiveRecord::Migration::Compatibility::V4_2
+  def index_exists?(table_name, column_name, options=T.unsafe(nil)); end
+
+  def remove_index(table_name, options=T.unsafe(nil)); end
+end
+
+module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
+  def belongs_to(*_, **options); end
+
+  def references(*_, **options); end
+
+  def timestamps(**options); end
+end
+
+module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
+end
+
+class ActiveRecord::Migration::Compatibility::V4_2
+end
+
+class ActiveRecord::Migration::Compatibility::V5_0
+  def add_belongs_to(table_name, ref_name, **options); end
+
+  def add_column(table_name, column_name, type, **options); end
+
+  def add_reference(table_name, ref_name, **options); end
+
+  def create_join_table(table_1, table_2, column_options: T.unsafe(nil), **options); end
+end
+
+module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
+  def belongs_to(*args, **options); end
+
+  def primary_key(name, type=T.unsafe(nil), **options); end
+
+  def references(*args, **options); end
+end
+
+module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
+end
+
+class ActiveRecord::Migration::Compatibility::V5_0
+end
+
+class ActiveRecord::Migration::Compatibility::V5_1
+  def change_column(table_name, column_name, type, options=T.unsafe(nil)); end
+end
+
+class ActiveRecord::Migration::Compatibility::V5_2
+  def add_timestamps(table_name, **options); end
+
+  def change_table(table_name, **options); end
+
+  def create_join_table(table_1, table_2, **options); end
+end
+
+module ActiveRecord::Migration::Compatibility::V5_2::CommandRecorder
+  def invert_change_column_comment(args); end
+
+  def invert_change_table_comment(args); end
+
+  def invert_transaction(args, &block); end
+end
+
+module ActiveRecord::Migration::Compatibility::V5_2::CommandRecorder
+end
+
+module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
+  def timestamps(**options); end
+end
+
+module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
+end
+
+module ActiveRecord::Migration::Compatibility
+  def self.find(version); end
+end
+
+class ActiveRecord::Migrator
+  MIGRATOR_SALT = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::NestedAttributes
+  UNASSIGNABLE_KEYS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::NestedAttributes::ClassMethods
+  REJECT_ALL_BLANK_PROC = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::NullRelation
+  def any?(); end
+
+  def calculate(operation, _column_name); end
+
+  def delete(_id_or_array); end
+
+  def delete_all(); end
+
+  def empty?(); end
+
+  def exists?(_conditions=T.unsafe(nil)); end
+
+  def many?(); end
+
+  def none?(); end
+
+  def one?(); end
+
+  def or(other); end
+
+  def pluck(*column_names); end
+
+  def to_sql(); end
+
+  def update_all(_updates); end
+end
+
+module ActiveRecord::NullRelation
+end
+
+module ActiveRecord::QueryMethods
+  DEFAULT_VALUES = ::T.let(nil, ::T.untyped)
+  FROZEN_EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
+  FROZEN_EMPTY_HASH = ::T.let(nil, ::T.untyped)
+  STRUCTURAL_OR_METHODS = ::T.let(nil, ::T.untyped)
+  VALID_DIRECTIONS = ::T.let(nil, ::T.untyped)
+  VALID_UNSCOPING_VALUES = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::Querying
+  QUERYING_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Reflection::AssociationReflection
+  INVALID_AUTOMATIC_INVERSE_OPTIONS = ::T.let(nil, ::T.untyped)
+  VALID_AUTOMATIC_INVERSE_MACROS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Relation
+  include ::ActiveRecord::Delegation
+  include ::ActiveRecord::Explain
+  include ::ActiveRecord::Batches
+  include ::ActiveRecord::QueryMethods
+  include ::ActiveModel::ForbiddenAttributesProtection
+  include ::ActiveRecord::SpawnMethods
+  include ::ActiveRecord::Calculations
+  CLAUSE_METHODS = ::T.let(nil, ::T.untyped)
+  INVALID_METHODS_FOR_DELETE_ALL = ::T.let(nil, ::T.untyped)
+  MULTI_VALUE_METHODS = ::T.let(nil, ::T.untyped)
+  SINGLE_VALUE_METHODS = ::T.let(nil, ::T.untyped)
+  VALUE_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Relation::Merger
+  NORMAL_VALUES = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Relation::WhereClause
+  ARRAY_WITH_EMPTY_STRING = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::RuntimeRegistry
+  def connection_handler(); end
+
+  def connection_handler=(connection_handler); end
+
+  def sql_runtime(); end
+
+  def sql_runtime=(sql_runtime); end
+end
+
+class ActiveRecord::RuntimeRegistry
+  extend ::ActiveSupport::PerThreadRegistry
+  def self.connection_handler(); end
+
+  def self.connection_handler=(x); end
+
+  def self.sql_runtime(); end
+
+  def self.sql_runtime=(x); end
+end
+
+module ActiveRecord::SchemaMigration::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+class ActiveRecord::Scoping::ScopeRegistry
+  VALID_SCOPE_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Scoping::ScopeRegistry
+  def self.set_value_for(*args, &block); end
+
+  def self.value_for(*args, &block); end
+end
+
+class ActiveRecord::SuppressorRegistry
+  def self.suppressed(*args, &block); end
+end
+
+module ActiveRecord::Tasks::DatabaseTasks
+  def cache_dump_filename(namespace); end
+
+  def charset(*arguments); end
+
+  def charset_current(environment=T.unsafe(nil), specification_name=T.unsafe(nil)); end
+
+  def check_protected_environments!(); end
+
+  def check_schema_file(filename); end
+
+  def check_target_version(); end
+
+  def collation(*arguments); end
+
+  def collation_current(environment=T.unsafe(nil), specification_name=T.unsafe(nil)); end
+
+  def create(*arguments); end
+
+  def create_all(); end
+
+  def create_current(environment=T.unsafe(nil), spec_name=T.unsafe(nil)); end
+
+  def current_config(options=T.unsafe(nil)); end
+
+  def current_config=(current_config); end
+
+  def database_configuration(); end
+
+  def database_configuration=(database_configuration); end
+
+  def db_dir(); end
+
+  def db_dir=(db_dir); end
+
+  def drop(*arguments); end
+
+  def drop_all(); end
+
+  def drop_current(environment=T.unsafe(nil)); end
+
+  def dump_filename(namespace, format=T.unsafe(nil)); end
+
+  def dump_schema(configuration, format=T.unsafe(nil), spec_name=T.unsafe(nil)); end
+
+  def dump_schema_cache(conn, filename); end
+
+  def env(); end
+
+  def env=(env); end
+
+  def fixtures_path(); end
+
+  def fixtures_path=(fixtures_path); end
+
+  def for_each(databases); end
+
+  def load_schema(configuration, format=T.unsafe(nil), file=T.unsafe(nil), environment=T.unsafe(nil), spec_name=T.unsafe(nil)); end
+
+  def load_schema_current(format=T.unsafe(nil), file=T.unsafe(nil), environment=T.unsafe(nil)); end
+
+  def load_seed(); end
+
+  def migrate(); end
+
+  def migrate_status(); end
+
+  def migrations_paths(); end
+
+  def migrations_paths=(migrations_paths); end
+
+  def purge(configuration); end
+
+  def purge_all(); end
+
+  def purge_current(environment=T.unsafe(nil)); end
+
+  def raise_for_multi_db(environment=T.unsafe(nil), command:); end
+
+  def reconstruct_from_schema(configuration, format=T.unsafe(nil), file=T.unsafe(nil), environment=T.unsafe(nil), spec_name=T.unsafe(nil)); end
+
+  def register_task(pattern, task); end
+
+  def root(); end
+
+  def root=(root); end
+
+  def schema_file(format=T.unsafe(nil)); end
+
+  def schema_file_type(format=T.unsafe(nil)); end
+
+  def schema_up_to_date?(configuration, format=T.unsafe(nil), file=T.unsafe(nil), environment=T.unsafe(nil), spec_name=T.unsafe(nil)); end
+
+  def seed_loader(); end
+
+  def seed_loader=(seed_loader); end
+
+  def setup_initial_database_yaml(); end
+
+  def spec(); end
+
+  def structure_dump(*arguments); end
+
+  def structure_load(*arguments); end
+
+  def target_version(); end
+
+  def truncate_all(environment=T.unsafe(nil)); end
+  LOCAL_HOSTS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveRecord::Tasks::DatabaseTasks
+  extend ::ActiveRecord::Tasks::DatabaseTasks
+  def self.structure_dump_flags(); end
+
+  def self.structure_dump_flags=(obj); end
+
+  def self.structure_load_flags(); end
+
+  def self.structure_load_flags=(obj); end
+end
+
+class ActiveRecord::Tasks::MySQLDatabaseTasks
+  def charset(); end
+
+  def collation(); end
+
+  def connection(*args, &block); end
+
+  def create(); end
+
+  def drop(); end
+
+  def establish_connection(*args, &block); end
+
+  def initialize(configuration); end
+
+  def purge(); end
+
+  def structure_dump(filename, extra_flags); end
+
+  def structure_load(filename, extra_flags); end
+  ER_DB_CREATE_EXISTS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Tasks::MySQLDatabaseTasks
+end
+
+class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
+  def charset(); end
+
+  def clear_active_connections!(*args, &block); end
+
+  def collation(); end
+
+  def connection(*args, &block); end
+
+  def create(master_established=T.unsafe(nil)); end
+
+  def drop(); end
+
+  def establish_connection(*args, &block); end
+
+  def initialize(configuration); end
+
+  def purge(); end
+
+  def structure_dump(filename, extra_flags); end
+
+  def structure_load(filename, extra_flags); end
+  DEFAULT_ENCODING = ::T.let(nil, ::T.untyped)
+  ON_ERROR_STOP_1 = ::T.let(nil, ::T.untyped)
+  SQL_COMMENT_BEGIN = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
+end
+
+class ActiveRecord::Tasks::SQLiteDatabaseTasks
+  def charset(); end
+
+  def connection(*args, &block); end
+
+  def create(); end
+
+  def drop(); end
+
+  def establish_connection(*args, &block); end
+
+  def initialize(configuration, root=T.unsafe(nil)); end
+
+  def purge(); end
+
+  def structure_dump(filename, extra_flags); end
+
+  def structure_load(filename, extra_flags); end
+end
+
+class ActiveRecord::Tasks::SQLiteDatabaseTasks
+end
+
+module ActiveRecord::TestDatabases
+end
+
+module ActiveRecord::TestDatabases
+  def self.create_and_load_schema(i, env_name:); end
+end
+
+module ActiveRecord::TestFixtures
+  def after_teardown(); end
+
+  def before_setup(); end
+
+  def enlist_fixture_connections(); end
+
+  def run_in_transaction?(); end
+
+  def setup_fixtures(config=T.unsafe(nil)); end
+
+  def teardown_fixtures(); end
+end
+
+module ActiveRecord::TestFixtures::ClassMethods
+  def fixtures(*fixture_set_names); end
+
+  def set_fixture_class(class_names=T.unsafe(nil)); end
+
+  def setup_fixture_accessors(fixture_set_names=T.unsafe(nil)); end
+
+  def uses_transaction(*methods); end
+
+  def uses_transaction?(method); end
+end
+
+module ActiveRecord::TestFixtures::ClassMethods
+end
+
+module ActiveRecord::TestFixtures
+  extend ::ActiveSupport::Concern
+end
+
+module ActiveRecord::Transactions
+  ACTIONS = ::T.let(nil, ::T.untyped)
+end
+
+ActiveRecord::Type::BigInteger = ActiveModel::Type::BigInteger
+
+ActiveRecord::Type::Binary = ActiveModel::Type::Binary
+
+ActiveRecord::Type::Decimal = ActiveModel::Type::Decimal
+
+ActiveRecord::Type::Float = ActiveModel::Type::Float
+
+ActiveRecord::Type::Integer = ActiveModel::Type::Integer
+
+class ActiveRecord::Type::Serialized
+end
+
+class ActiveRecord::Type::Time::Value
+end
+
+module ActiveRecord::VERSION
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  PRE = ::T.let(nil, ::T.untyped)
+  STRING = ::T.let(nil, ::T.untyped)
+  TINY = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::BacktraceCleaner
+  FORMATTED_GEMS_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Cache
+  UNIVERSAL_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Cache::Entry
+  DEFAULT_COMPRESS_LIMIT = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Cache::FileStore
+  include ::ActiveSupport::Cache::Strategy::LocalCache
+  DIR_FORMATTER = ::T.let(nil, ::T.untyped)
+  FILENAME_MAX_SIZE = ::T.let(nil, ::T.untyped)
+  FILEPATH_MAX_SIZE = ::T.let(nil, ::T.untyped)
+  GITKEEP_FILES = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Cache::MemoryStore
+  PER_ENTRY_OVERHEAD = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Cache::NullStore
+  include ::ActiveSupport::Cache::Strategy::LocalCache
+end
+
+module ActiveSupport::Callbacks
+  CALLBACK_FILTER_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Dependencies
+  Reference = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Deprecation
+  def deprecation_horizon(); end
+
+  def deprecation_horizon=(deprecation_horizon); end
+
+  def initialize(deprecation_horizon=T.unsafe(nil), gem_name=T.unsafe(nil)); end
+  DEFAULT_BEHAVIORS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Deprecation::Reporting
+  RAILS_GEM_ROOT = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Deprecation
+  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
+end
+
+class ActiveSupport::Digest
+end
+
+class ActiveSupport::Digest
+  def self.hash_digest_class(); end
+
+  def self.hash_digest_class=(klass); end
+
+  def self.hexdigest(arg); end
+end
+
+class ActiveSupport::Duration
+  PARTS = ::T.let(nil, ::T.untyped)
+  PARTS_IN_SECONDS = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_DAY = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_HOUR = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_MONTH = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_WEEK = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_YEAR = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Duration::ISO8601Parser
+  def initialize(string); end
+
+  def mode(); end
+
+  def mode=(mode); end
+
+  def parse!(); end
+
+  def parts(); end
+
+  def scanner(); end
+
+  def sign(); end
+
+  def sign=(sign); end
+  COMMA = ::T.let(nil, ::T.untyped)
+  DATE_COMPONENT = ::T.let(nil, ::T.untyped)
+  DATE_COMPONENTS = ::T.let(nil, ::T.untyped)
+  DATE_MARKER = ::T.let(nil, ::T.untyped)
+  DATE_TO_PART = ::T.let(nil, ::T.untyped)
+  PERIOD = ::T.let(nil, ::T.untyped)
+  PERIOD_OR_COMMA = ::T.let(nil, ::T.untyped)
+  SIGN_MARKER = ::T.let(nil, ::T.untyped)
+  TIME_COMPONENT = ::T.let(nil, ::T.untyped)
+  TIME_COMPONENTS = ::T.let(nil, ::T.untyped)
+  TIME_MARKER = ::T.let(nil, ::T.untyped)
+  TIME_TO_PART = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::Duration::ISO8601Parser::ParsingError
+end
+
+class ActiveSupport::Duration::ISO8601Parser::ParsingError
+end
+
+class ActiveSupport::Duration::ISO8601Parser
+end
+
+class ActiveSupport::Duration::ISO8601Serializer
+  def initialize(duration, precision: T.unsafe(nil)); end
+
+  def serialize(); end
+end
+
+class ActiveSupport::Duration::ISO8601Serializer
+end
+
+class ActiveSupport::ExecutionWrapper
+  Null = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Gzip
+end
+
+class ActiveSupport::Gzip::Stream
+end
+
+class ActiveSupport::Gzip::Stream
+end
+
+module ActiveSupport::Gzip
+  def self.compress(source, level=T.unsafe(nil), strategy=T.unsafe(nil)); end
+
+  def self.decompress(source); end
+end
+
+module ActiveSupport::JSON
+  DATETIME_REGEX = ::T.let(nil, ::T.untyped)
+  DATE_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::KeyGenerator
+  def generate_key(salt, key_size=T.unsafe(nil)); end
+
+  def initialize(secret, options=T.unsafe(nil)); end
+end
+
+class ActiveSupport::KeyGenerator
+end
+
+class ActiveSupport::LogSubscriber
+  def colorize_logging(); end
+
+  def colorize_logging=(obj); end
+
+  def debug(progname=T.unsafe(nil), &block); end
+
+  def error(progname=T.unsafe(nil), &block); end
+
+  def fatal(progname=T.unsafe(nil), &block); end
+
+  def info(progname=T.unsafe(nil), &block); end
+
+  def logger(); end
+
+  def unknown(progname=T.unsafe(nil), &block); end
+
+  def warn(progname=T.unsafe(nil), &block); end
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::MessageEncryptor
+  include ::ActiveSupport::Messages::Rotator::Encryptor
+  include ::ActiveSupport::Messages::Rotator
+  def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+end
+
+class ActiveSupport::MessageEncryptor::InvalidMessage
+end
+
+class ActiveSupport::MessageEncryptor::InvalidMessage
+end
+
+module ActiveSupport::MessageEncryptor::NullSerializer
+end
+
+module ActiveSupport::MessageEncryptor::NullSerializer
+  def self.dump(value); end
+
+  def self.load(value); end
+end
+
+module ActiveSupport::MessageEncryptor::NullVerifier
+end
+
+module ActiveSupport::MessageEncryptor::NullVerifier
+  def self.generate(value); end
+
+  def self.verify(value); end
+end
+
+class ActiveSupport::MessageEncryptor::OpenSSLCipherError
+end
+
+class ActiveSupport::MessageEncryptor::OpenSSLCipherError
+end
+
+class ActiveSupport::MessageEncryptor
+  def self.default_cipher(); end
+
+  def self.key_len(cipher=T.unsafe(nil)); end
+
+  def self.use_authenticated_message_encryption(); end
+
+  def self.use_authenticated_message_encryption=(obj); end
+end
+
+class ActiveSupport::MessageVerifier
+  include ::ActiveSupport::Messages::Rotator::Verifier
+  include ::ActiveSupport::Messages::Rotator
+  def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+
+  def valid_message?(signed_message); end
+
+  def verify(*args, **options); end
+end
+
+class ActiveSupport::MessageVerifier::InvalidSignature
+end
+
+class ActiveSupport::MessageVerifier::InvalidSignature
+end
+
+class ActiveSupport::MessageVerifier
+end
+
+module ActiveSupport::Messages::Rotator
+  def initialize(*_, **options); end
+
+  def rotate(*secrets, **options); end
+end
+
+module ActiveSupport::Messages::Rotator::Encryptor
+  include ::ActiveSupport::Messages::Rotator
+  def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
+end
+
+module ActiveSupport::Messages::Rotator::Encryptor
+end
+
+module ActiveSupport::Messages::Rotator::Verifier
+  include ::ActiveSupport::Messages::Rotator
+  def verified(*args, on_rotation: T.unsafe(nil), **options); end
+end
+
+module ActiveSupport::Messages::Rotator::Verifier
+end
+
+module ActiveSupport::Messages::Rotator
+end
+
+module ActiveSupport::Multibyte::Unicode
+  def compose(codepoints); end
+
+  def decompose(type, codepoints); end
+
+  def default_normalization_form(); end
+
+  def default_normalization_form=(default_normalization_form); end
+
+  def downcase(string); end
+
+  def normalize(string, form=T.unsafe(nil)); end
+
+  def pack_graphemes(unpacked); end
+
+  def swapcase(string); end
+
+  def tidy_bytes(string, force=T.unsafe(nil)); end
+
+  def unpack_graphemes(string); end
+
+  def upcase(string); end
+  NORMALIZATION_FORMS = ::T.let(nil, ::T.untyped)
+  NORMALIZATION_FORM_ALIASES = ::T.let(nil, ::T.untyped)
+  UNICODE_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Multibyte::Unicode
+  extend ::ActiveSupport::Multibyte::Unicode
+end
+
+class ActiveSupport::NumberHelper::NumberConverter
+  def execute(); end
+
+  def initialize(number, options); end
+
+  def namespace(); end
+
+  def namespace=(val); end
+
+  def namespace?(); end
+
+  def number(); end
+
+  def opts(); end
+
+  def validate_float(); end
+
+  def validate_float=(val); end
+
+  def validate_float?(); end
+  DEFAULTS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::NumberHelper::NumberConverter
+  def self.convert(number, options); end
+
+  def self.namespace(); end
+
+  def self.namespace=(val); end
+
+  def self.namespace?(); end
+
+  def self.validate_float(); end
+
+  def self.validate_float=(val); end
+
+  def self.validate_float?(); end
+end
+
+class ActiveSupport::NumberHelper::NumberToCurrencyConverter
+  def convert(); end
+end
+
+class ActiveSupport::NumberHelper::NumberToCurrencyConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToDelimitedConverter
+  def convert(); end
+  DEFAULT_DELIMITER_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::NumberHelper::NumberToDelimitedConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToHumanConverter
+  def convert(); end
+  DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
+  INVERTED_DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::NumberHelper::NumberToHumanConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
+  def convert(); end
+  STORAGE_UNITS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToPercentageConverter
+  def convert(); end
+end
+
+class ActiveSupport::NumberHelper::NumberToPercentageConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToPhoneConverter
+  def convert(); end
+end
+
+class ActiveSupport::NumberHelper::NumberToPhoneConverter
+end
+
+class ActiveSupport::NumberHelper::NumberToRoundedConverter
+  def convert(); end
+end
+
+class ActiveSupport::NumberHelper::NumberToRoundedConverter
+end
+
+class ActiveSupport::NumberHelper::RoundingHelper
+  def digit_count(number); end
+
+  def initialize(options); end
+
+  def options(); end
+
+  def round(number); end
+end
+
+class ActiveSupport::NumberHelper::RoundingHelper
+end
+
+module ActiveSupport::NumberHelper
+  extend ::ActiveSupport::Autoload
+  extend ::ActiveSupport::NumberHelper
+end
+
+class ActiveSupport::OptionMerger
+  def initialize(context, options); end
+end
+
+class ActiveSupport::OptionMerger
+end
+
+class ActiveSupport::OrderedHash
+  def encode_with(coder); end
+
+  def reject(*args, &block); end
+
+  def select(*args, &block); end
+
+  def to_yaml_type(); end
+end
+
+class ActiveSupport::OrderedHash
+end
+
+class ActiveSupport::ParameterFilter
+  FILTERED = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::RangeWithFormat
+  RANGE_FORMATS = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Rescuable
+  def handler_for_rescue(exception); end
+
+  def rescue_with_handler(exception); end
+end
+
+module ActiveSupport::Rescuable::ClassMethods
+  def handler_for_rescue(exception, object: T.unsafe(nil)); end
+
+  def rescue_from(*klasses, with: T.unsafe(nil), &block); end
+
+  def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
+end
+
+module ActiveSupport::Rescuable::ClassMethods
+end
+
+module ActiveSupport::Rescuable
+  extend ::ActiveSupport::Concern
+end
+
+class ActiveSupport::SafeBuffer
+  def %(args); end
+
+  def *(*_); end
+
+  def +(other); end
+
+  def <<(value); end
+
+  def [](*args); end
+
+  def []=(*args); end
+
+  def capitalize(*args, &block); end
+
+  def capitalize!(*args); end
+
+  def chomp(*args, &block); end
+
+  def chomp!(*args); end
+
+  def chop(*args, &block); end
+
+  def chop!(*args); end
+
+  def clone_empty(); end
+
+  def concat(value); end
+
+  def delete(*args, &block); end
+
+  def delete!(*args); end
+
+  def delete_prefix(*args, &block); end
+
+  def delete_prefix!(*args); end
+
+  def delete_suffix(*args, &block); end
+
+  def delete_suffix!(*args); end
+
+  def downcase(*args, &block); end
+
+  def downcase!(*args); end
+
+  def encode_with(coder); end
+
+  def gsub(*args, &block); end
+
+  def gsub!(*args, &block); end
+
+  def initialize(str=T.unsafe(nil)); end
+
+  def insert(index, value); end
+
+  def lstrip(*args, &block); end
+
+  def lstrip!(*args); end
+
+  def next(*args, &block); end
+
+  def next!(*args); end
+
+  def prepend(value); end
+
+  def replace(value); end
+
+  def reverse(*args, &block); end
+
+  def reverse!(*args); end
+
+  def rstrip(*args, &block); end
+
+  def rstrip!(*args); end
+
+  def safe_concat(value); end
+
+  def slice(*args, &block); end
+
+  def slice!(*args); end
+
+  def squeeze(*args, &block); end
+
+  def squeeze!(*args); end
+
+  def strip(*args, &block); end
+
+  def strip!(*args); end
+
+  def sub(*args, &block); end
+
+  def sub!(*args, &block); end
+
+  def succ(*args, &block); end
+
+  def succ!(*args); end
+
+  def swapcase(*args, &block); end
+
+  def swapcase!(*args); end
+
+  def tr(*args, &block); end
+
+  def tr!(*args); end
+
+  def tr_s(*args, &block); end
+
+  def tr_s!(*args); end
+
+  def unicode_normalize(*args, &block); end
+
+  def unicode_normalize!(*args); end
+
+  def upcase(*args, &block); end
+
+  def upcase!(*args); end
+  UNSAFE_STRING_METHODS = ::T.let(nil, ::T.untyped)
+  UNSAFE_STRING_METHODS_WITH_BACKREF = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::SafeBuffer::SafeConcatError
+  def initialize(); end
+end
+
+class ActiveSupport::SafeBuffer::SafeConcatError
+end
+
+class ActiveSupport::SafeBuffer
+end
+
+class ActiveSupport::StringInquirer
+end
+
+class ActiveSupport::StringInquirer
+end
+
+class ActiveSupport::Subscriber
+  def finish(name, id, payload); end
+
+  def patterns(); end
+
+  def start(name, id, payload); end
+end
+
+module ActiveSupport::TaggedLogging
+  def clear_tags!(*args, &block); end
+
+  def flush(); end
+
+  def pop_tags(*args, &block); end
+
+  def push_tags(*args, &block); end
+
+  def tagged(*tags); end
+end
+
+module ActiveSupport::TaggedLogging::Formatter
+  def call(severity, timestamp, progname, msg); end
+
+  def clear_tags!(); end
+
+  def current_tags(); end
+
+  def pop_tags(size=T.unsafe(nil)); end
+
+  def push_tags(*tags); end
+
+  def tagged(*tags); end
+
+  def tags_text(); end
+end
+
+module ActiveSupport::TaggedLogging::Formatter
+end
+
+module ActiveSupport::TaggedLogging
+  def self.new(logger); end
+end
+
+class ActiveSupport::TestCase
+  include ::ActiveSupport::Testing::TaggedLogging
+  include ::ActiveSupport::Callbacks
+  include ::ActiveSupport::Testing::Assertions
+  include ::ActiveSupport::Testing::Deprecation
+  include ::ActiveSupport::Testing::TimeHelpers
+  include ::ActiveSupport::Testing::FileFixtures
+  include ::ActiveSupport::Testing::SetupAndTeardown
+  def __callbacks(); end
+
+  def __callbacks?(); end
+
+  def _run_setup_callbacks(&block); end
+
+  def _run_teardown_callbacks(&block); end
+
+  def _setup_callbacks(); end
+
+  def _teardown_callbacks(); end
+
+  def assert_no_match(matcher, obj, msg=T.unsafe(nil)); end
+
+  def assert_not_empty(obj, msg=T.unsafe(nil)); end
+
+  def assert_not_equal(exp, act, msg=T.unsafe(nil)); end
+
+  def assert_not_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_not_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_not_includes(collection, obj, msg=T.unsafe(nil)); end
+
+  def assert_not_instance_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def assert_not_kind_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def assert_not_nil(obj, msg=T.unsafe(nil)); end
+
+  def assert_not_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_not_predicate(o1, op, msg=T.unsafe(nil)); end
+
+  def assert_not_respond_to(obj, meth, msg=T.unsafe(nil)); end
+
+  def assert_not_same(exp, act, msg=T.unsafe(nil)); end
+
+  def assert_raise(*exp); end
+
+  def file_fixture_path(); end
+
+  def file_fixture_path?(); end
+
+  def method_name(); end
+end
+
+class ActiveSupport::TestCase::Assertion
+  def error(); end
+
+  def location(); end
+
+  def result_code(); end
+
+  def result_label(); end
+end
+
+class ActiveSupport::TestCase::Assertion
+end
+
+class ActiveSupport::TestCase
+  extend ::ActiveSupport::DescendantsTracker
+  extend ::ActiveSupport::Testing::Declarative
+  def self.__callbacks(); end
+
+  def self.__callbacks=(val); end
+
+  def self.__callbacks?(); end
+
+  def self._setup_callbacks(); end
+
+  def self._setup_callbacks=(value); end
+
+  def self._teardown_callbacks(); end
+
+  def self._teardown_callbacks=(value); end
+
+  def self.file_fixture_path(); end
+
+  def self.file_fixture_path=(val); end
+
+  def self.file_fixture_path?(); end
+
+  def self.parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end
+
+  def self.parallelize_setup(&block); end
+
+  def self.parallelize_teardown(&block); end
+
+  def self.test_order=(new_order); end
+end
+
+module ActiveSupport::Testing
+end
+
+module ActiveSupport::Testing::Assertions
+  def assert_changes(expression, message=T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end
+
+  def assert_difference(expression, *args, &block); end
+
+  def assert_no_changes(expression, message=T.unsafe(nil), &block); end
+
+  def assert_no_difference(expression, message=T.unsafe(nil), &block); end
+
+  def assert_not(object, message=T.unsafe(nil)); end
+
+  def assert_nothing_raised(); end
+  UNTRACKED = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Testing::Assertions
+end
+
+module ActiveSupport::Testing::ConstantLookup
+end
+
+module ActiveSupport::Testing::ConstantLookup::ClassMethods
+  def determine_constant_from_test_name(test_name); end
+end
+
+module ActiveSupport::Testing::ConstantLookup::ClassMethods
+end
+
+module ActiveSupport::Testing::ConstantLookup
+  extend ::ActiveSupport::Concern
+end
+
+module ActiveSupport::Testing::Declarative
+  def test(name, &block); end
+end
+
+module ActiveSupport::Testing::Declarative
+end
+
+module ActiveSupport::Testing::Deprecation
+  def assert_deprecated(match=T.unsafe(nil), deprecator=T.unsafe(nil), &block); end
+
+  def assert_not_deprecated(deprecator=T.unsafe(nil), &block); end
+
+  def collect_deprecations(deprecator=T.unsafe(nil)); end
+end
+
+module ActiveSupport::Testing::Deprecation
+end
+
+module ActiveSupport::Testing::FileFixtures
+  def file_fixture(fixture_name); end
+end
+
+module ActiveSupport::Testing::FileFixtures
+  extend ::ActiveSupport::Concern
+end
+
+module ActiveSupport::Testing::Isolation
+  include ::ActiveSupport::Testing::Isolation::Forking
+  def run(); end
+end
+
+module ActiveSupport::Testing::Isolation::Forking
+  def run_in_isolation(&blk); end
+end
+
+module ActiveSupport::Testing::Isolation::Forking
+end
+
+module ActiveSupport::Testing::Isolation::Subprocess
+  def run_in_isolation(&blk); end
+  ORIG_ARGV = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Testing::Isolation::Subprocess
+end
+
+module ActiveSupport::Testing::Isolation
+  def self.forking_env?(); end
+
+  def self.included(klass); end
+end
+
+class ActiveSupport::Testing::Parallelization
+  def <<(work); end
+
+  def after_fork(worker); end
+
+  def after_fork_hooks(); end
+
+  def initialize(queue_size); end
+
+  def run_cleanup(worker); end
+
+  def run_cleanup_hooks(); end
+
+  def shutdown(); end
+
+  def start(); end
+end
+
+class ActiveSupport::Testing::Parallelization::Server
+  include ::DRb::DRbUndumped
+  def <<(o); end
+
+  def length(); end
+
+  def pop(); end
+
+  def record(reporter, result); end
+end
+
+class ActiveSupport::Testing::Parallelization::Server
+end
+
+class ActiveSupport::Testing::Parallelization
+  def self.after_fork_hook(&blk); end
+
+  def self.after_fork_hooks(); end
+
+  def self.run_cleanup_hook(&blk); end
+
+  def self.run_cleanup_hooks(); end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown
+  def after_teardown(); end
+
+  def before_setup(); end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown
+  def self.prepended(klass); end
+end
+
+class ActiveSupport::Testing::SimpleStubs
+  def stub_object(object, method_name, &block); end
+
+  def stubbing(object, method_name); end
+
+  def unstub_all!(); end
+end
+
+class ActiveSupport::Testing::SimpleStubs::Stub
+  def method_name(); end
+
+  def method_name=(_); end
+
+  def object(); end
+
+  def object=(_); end
+
+  def original_method(); end
+
+  def original_method=(_); end
+end
+
+class ActiveSupport::Testing::SimpleStubs::Stub
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class ActiveSupport::Testing::SimpleStubs
+end
+
+module ActiveSupport::Testing::TaggedLogging
+  def before_setup(); end
+
+  def tagged_logger=(tagged_logger); end
+end
+
+module ActiveSupport::Testing::TaggedLogging
+end
+
+module ActiveSupport::Testing::TimeHelpers
+  def after_teardown(); end
+
+  def freeze_time(&block); end
+
+  def travel(duration, &block); end
+
+  def travel_back(); end
+
+  def travel_to(date_or_time); end
+
+  def unfreeze_time(); end
+end
+
+module ActiveSupport::Testing::TimeHelpers
+end
+
+module ActiveSupport::Testing
+end
+
+class ActiveSupport::TimeWithZone
+  include ::DateAndTime::Compatibility
+  PRECISIONS = ::T.let(nil, ::T.untyped)
+end
+
+class ActiveSupport::TimeZone
+  MAPPING = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::VERSION
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  PRE = ::T.let(nil, ::T.untyped)
+  STRING = ::T.let(nil, ::T.untyped)
+  TINY = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::XmlMini
+  DEFAULT_ENCODINGS = ::T.let(nil, ::T.untyped)
+  FORMATTING = ::T.let(nil, ::T.untyped)
+  PARSING = ::T.let(nil, ::T.untyped)
+  TYPE_NAMES = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::XmlMini_REXML
+  CONTENT_KEY = ::T.let(nil, ::T.untyped)
+end
+
+module Arel
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+Arel::Attribute = Arel::Attributes::Attribute
+
+Arel::Node = Arel::Nodes::Node
+
+class Arel::SelectManager
+  STRING_OR_SYMBOL_CLASS = ::T.let(nil, ::T.untyped)
+end
+
+class Arel::Visitors::DepthFirst
+  DISPATCH = ::T.let(nil, ::T.untyped)
+end
+
+class Array
+  include ::JSON::Ext::Generator::GeneratorMethods::Array
+  def shelljoin(); end
+
+  def to_h(); end
+end
+
+class Array
+  def self.wrap(object); end
+end
+
+BasicObject::BasicObject = BasicObject
+
+class Benchmark::Job
+  def initialize(width); end
+end
+
+class Benchmark::Report
+  def initialize(width=T.unsafe(nil), format=T.unsafe(nil)); end
+end
+
+class Benchmark::Tms
+  def to_a(); end
+end
+
+class BigDecimal
+  include ::ActiveSupport::BigDecimalWithDefaultFormat
+  def clone(); end
+
+  def to_digits(); end
+  EXCEPTION_NaN = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class BigDecimal
+  def self.new(*args, **kwargs); end
+end
+
+class Binding
+  def clone(); end
+
+  def irb(); end
+end
+
+class Bundler::Dependency
+  def branch(); end
+
+  def expanded_platforms(); end
+
+  def git(); end
+end
+
+Bundler::Deprecate = Gem::Deprecate
+
+class Bundler::Env
+end
+
+class Bundler::Env
+  def self.environment(); end
+
+  def self.report(options=T.unsafe(nil)); end
+
+  def self.write(io); end
+end
+
+class Bundler::Fetcher
+  def fetch_spec(spec); end
+
+  def fetchers(); end
+
+  def http_proxy(); end
+
+  def initialize(remote); end
+
+  def specs(gem_names, source); end
+
+  def specs_with_retry(gem_names, source); end
+
+  def uri(); end
+
+  def use_api(); end
+
+  def user_agent(); end
+  FAIL_ERRORS = ::T.let(nil, ::T.untyped)
+  FETCHERS = ::T.let(nil, ::T.untyped)
+  HTTP_ERRORS = ::T.let(nil, ::T.untyped)
+  NET_ERRORS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Fetcher::AuthenticationRequiredError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::BadAuthenticationError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::Base
+  def api_fetcher?(); end
+
+  def available?(); end
+
+  def display_uri(); end
+
+  def downloader(); end
+
+  def fetch_uri(); end
+
+  def initialize(downloader, remote, display_uri); end
+
+  def remote(); end
+
+  def remote_uri(); end
+end
+
+class Bundler::Fetcher::Base
+end
+
+class Bundler::Fetcher::CertificateFailureError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::CompactIndex
+  def available?(*args, &blk); end
+
+  def fetch_spec(*args, &blk); end
+
+  def specs(*args, &blk); end
+
+  def specs_for_names(gem_names); end
+end
+
+class Bundler::Fetcher::CompactIndex::ClientFetcher
+  def call(path, headers); end
+
+  def fetcher(); end
+
+  def fetcher=(_); end
+
+  def ui(); end
+
+  def ui=(_); end
+end
+
+class Bundler::Fetcher::CompactIndex::ClientFetcher
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::Fetcher::CompactIndex
+  def self.compact_index_request(method_name); end
+end
+
+class Bundler::Fetcher::Dependency
+  def dependency_api_uri(gem_names=T.unsafe(nil)); end
+
+  def dependency_specs(gem_names); end
+
+  def get_formatted_specs_and_deps(gem_list); end
+
+  def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end
+
+  def unmarshalled_dep_gems(gem_names); end
+end
+
+class Bundler::Fetcher::Dependency
+end
+
+class Bundler::Fetcher::Downloader
+  def connection(); end
+
+  def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end
+
+  def initialize(connection, redirect_limit); end
+
+  def redirect_limit(); end
+
+  def request(uri, headers); end
+end
+
+class Bundler::Fetcher::Downloader
+end
+
+class Bundler::Fetcher::Index
+  def fetch_spec(spec); end
+
+  def specs(_gem_names); end
+end
+
+class Bundler::Fetcher::Index
+end
+
+class Bundler::Fetcher::SSLError
+  def initialize(msg=T.unsafe(nil)); end
+end
+
+class Bundler::Fetcher::TooManyRequestsError
+end
+
+class Bundler::Fetcher::TooManyRequestsError
+end
+
+class Bundler::Fetcher
+  def self.api_timeout(); end
+
+  def self.api_timeout=(api_timeout); end
+
+  def self.disable_endpoint(); end
+
+  def self.disable_endpoint=(disable_endpoint); end
+
+  def self.max_retries(); end
+
+  def self.max_retries=(max_retries); end
+
+  def self.redirect_limit(); end
+
+  def self.redirect_limit=(redirect_limit); end
+end
+
+module Bundler::FileUtils
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::FileUtils::Entry_
+  def link(dest); end
+end
+
+module Bundler::FileUtils
+  def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
+
+  def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
+end
+
+class Bundler::GemHelper
+  include ::Rake::DSL
+  include ::Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  def allowed_push_host(); end
+
+  def already_tagged?(); end
+
+  def base(); end
+
+  def build_gem(); end
+
+  def built_gem_path(); end
+
+  def clean?(); end
+
+  def committed?(); end
+
+  def gem_command(); end
+
+  def gem_key(); end
+
+  def gem_push?(); end
+
+  def gem_push_host(); end
+
+  def gemspec(); end
+
+  def git_push(remote=T.unsafe(nil)); end
+
+  def guard_clean(); end
+
+  def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def install(); end
+
+  def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end
+
+  def name(); end
+
+  def perform_git_push(options=T.unsafe(nil)); end
+
+  def rubygem_push(path); end
+
+  def sh(cmd, &block); end
+
+  def sh_with_input(cmd); end
+
+  def sh_with_status(cmd, &block); end
+
+  def spec_path(); end
+
+  def tag_version(); end
+
+  def version(); end
+
+  def version_tag(); end
+end
+
+class Bundler::GemHelper
+  def self.gemspec(&block); end
+
+  def self.install_tasks(opts=T.unsafe(nil)); end
+
+  def self.instance(); end
+
+  def self.instance=(instance); end
+end
+
+class Bundler::GemVersionPromoter
+  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
+
+  def level(); end
+
+  def level=(value); end
+
+  def locked_specs(); end
+
+  def major?(); end
+
+  def minor?(); end
+
+  def prerelease_specified(); end
+
+  def prerelease_specified=(prerelease_specified); end
+
+  def sort_versions(dep, spec_groups); end
+
+  def strict(); end
+
+  def strict=(strict); end
+
+  def unlock_gems(); end
+  DEBUG = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::GemVersionPromoter
+end
+
+class Bundler::Graph
+  def edge_options(); end
+
+  def groups(); end
+
+  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
+
+  def node_options(); end
+
+  def output_file(); end
+
+  def output_format(); end
+
+  def relations(); end
+
+  def viz(); end
+  GRAPH_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Graph::GraphVizClient
+  def g(); end
+
+  def initialize(graph_instance); end
+
+  def run(); end
+end
+
+class Bundler::Graph::GraphVizClient
+end
+
+class Bundler::Graph
+end
+
+class Bundler::Index
+  include ::Enumerable
+end
+
+class Bundler::Injector
+  def initialize(deps, options=T.unsafe(nil)); end
+
+  def inject(gemfile_path, lockfile_path); end
+
+  def remove(gemfile_path, lockfile_path); end
+  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Injector
+  def self.inject(new_deps, options=T.unsafe(nil)); end
+
+  def self.remove(gems, options=T.unsafe(nil)); end
+end
+
+class Bundler::Installer
+  def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
+
+  def generate_standalone_bundler_executable_stubs(spec); end
+
+  def initialize(root, definition); end
+
+  def post_install_messages(); end
+
+  def run(options); end
+end
+
+class Bundler::Installer
+  def self.ambiguous_gems(); end
+
+  def self.ambiguous_gems=(ambiguous_gems); end
+
+  def self.install(root, definition, options=T.unsafe(nil)); end
+end
+
+class Bundler::Molinillo::DependencyGraph
+  include ::Enumerable
+end
+
+class Bundler::Molinillo::DependencyGraph::Log
+  extend ::Enumerable
+end
+
+class Bundler::Molinillo::DependencyGraph::Vertex
+  def _recursive_predecessors(vertices=T.unsafe(nil)); end
+
+  def _recursive_successors(vertices=T.unsafe(nil)); end
+end
+
+module Bundler::Plugin::API::Source
+  def ==(other); end
+
+  def app_cache_dirname(); end
+
+  def app_cache_path(custom_path=T.unsafe(nil)); end
+
+  def bundler_plugin_api_source?(); end
+
+  def cache(spec, custom_path=T.unsafe(nil)); end
+
+  def cached!(); end
+
+  def can_lock?(spec); end
+
+  def dependency_names(); end
+
+  def dependency_names=(dependency_names); end
+
+  def double_check_for(*_); end
+
+  def eql?(other); end
+
+  def fetch_gemspec_files(); end
+
+  def gem_install_dir(); end
+
+  def hash(); end
+
+  def include?(other); end
+
+  def initialize(opts); end
+
+  def install(spec, opts); end
+
+  def install_path(); end
+
+  def installed?(); end
+
+  def name(); end
+
+  def options(); end
+
+  def options_to_lock(); end
+
+  def post_install(spec, disable_exts=T.unsafe(nil)); end
+
+  def remote!(); end
+
+  def root(); end
+
+  def specs(); end
+
+  def to_lock(); end
+
+  def to_s(); end
+
+  def unlock!(); end
+
+  def unmet_deps(); end
+
+  def uri(); end
+
+  def uri_hash(); end
+end
+
+module Bundler::Plugin::API::Source
+end
+
+module Bundler::Plugin::Events
+  GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
+  GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
+  GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
+  GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Plugin::Index
+  def installed_plugins(); end
+
+  def plugin_commands(plugin); end
+end
+
+class Bundler::Plugin::Index::CommandConflict
+  def initialize(plugin, commands); end
+end
+
+class Bundler::Plugin::Index::CommandConflict
+end
+
+class Bundler::Plugin::Index::SourceConflict
+  def initialize(plugin, sources); end
+end
+
+class Bundler::Plugin::Index::SourceConflict
+end
+
+class Bundler::Plugin::Installer
+  def install(names, options); end
+
+  def install_definition(definition); end
+end
+
+class Bundler::Plugin::Installer::Git
+  def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
+end
+
+class Bundler::Plugin::Installer::Git
+end
+
+class Bundler::Plugin::Installer::Rubygems
+end
+
+class Bundler::Plugin::Installer::Rubygems
+end
+
+class Bundler::Plugin::Installer
+end
+
+class Bundler::Plugin::SourceList
+end
+
+class Bundler::Plugin::SourceList
+end
+
+module Bundler::Plugin
+  def self.list(); end
+end
+
+class Bundler::ProcessLock
+end
+
+class Bundler::ProcessLock
+  def self.lock(bundle_path=T.unsafe(nil)); end
+end
+
+class Bundler::Retry
+  def attempt(&block); end
+
+  def attempts(&block); end
+
+  def current_run(); end
+
+  def current_run=(current_run); end
+
+  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def total_runs(); end
+
+  def total_runs=(total_runs); end
+end
+
+class Bundler::Retry
+  def self.attempts(); end
+
+  def self.default_attempts(); end
+
+  def self.default_retries(); end
+end
+
+class Bundler::RubyGemsGemInstaller
+end
+
+class Bundler::RubyGemsGemInstaller
+end
+
+class Bundler::RubygemsIntegration
+  def add_to_load_path(paths); end
+
+  def all_specs(); end
+
+  def backport_ext_builder_monitor(); end
+
+  def correct_for_windows_path(path); end
+
+  def default_stubs(); end
+
+  def find_name(name); end
+
+  def gem_remote_fetcher(); end
+
+  def plain_specs(); end
+
+  def plain_specs=(specs); end
+
+  def stub_rubygems(specs); end
+
+  def use_gemdeps(gemfile); end
+end
+
+class Bundler::Settings::Mirror
+  def ==(other); end
+
+  def fallback_timeout(); end
+
+  def fallback_timeout=(timeout); end
+
+  def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end
+
+  def uri(); end
+
+  def uri=(uri); end
+
+  def valid?(); end
+
+  def validate!(probe=T.unsafe(nil)); end
+  DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Settings::Mirror
+end
+
+class Bundler::Settings::Mirrors
+  def each(&blk); end
+
+  def for(uri); end
+
+  def initialize(prober=T.unsafe(nil)); end
+
+  def parse(key, value); end
+end
+
+class Bundler::Settings::Mirrors
+end
+
+class Bundler::Settings::Validator
+end
+
+class Bundler::Settings::Validator::Rule
+  def description(); end
+
+  def fail!(key, value, *reasons); end
+
+  def initialize(keys, description, &validate); end
+
+  def k(key); end
+
+  def set(settings, key, value, *reasons); end
+
+  def validate!(key, value, settings); end
+end
+
+class Bundler::Settings::Validator::Rule
+end
+
+class Bundler::Settings::Validator
+  def self.validate!(key, value, settings); end
+end
+
+class Bundler::Source::Git
+  def glob(); end
+end
+
+class Bundler::SpecSet
+  include ::Enumerable
+end
+
+class Bundler::Thor
+  include ::Bundler::Thor::Base
+  include ::Bundler::Thor::Invocation
+  include ::Bundler::Thor::Shell
+  def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+  HELP_MAPPINGS = ::T.let(nil, ::T.untyped)
+  TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped)
+  THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+module Bundler::Thor::Actions
+  def _cleanup_options_and_set(options, key); end
+
+  def _shared_configuration(); end
+
+  def action(instance); end
+
+  def add_file(destination, *args, &block); end
+
+  def add_link(destination, *args); end
+
+  def append_file(path, *args, &block); end
+
+  def append_to_file(path, *args, &block); end
+
+  def apply(path, config=T.unsafe(nil)); end
+
+  def behavior(); end
+
+  def behavior=(behavior); end
+
+  def chmod(path, mode, config=T.unsafe(nil)); end
+
+  def comment_lines(path, flag, *args); end
+
+  def copy_file(source, *args, &block); end
+
+  def create_file(destination, *args, &block); end
+
+  def create_link(destination, *args); end
+
+  def destination_root(); end
+
+  def destination_root=(root); end
+
+  def directory(source, *args, &block); end
+
+  def empty_directory(destination, config=T.unsafe(nil)); end
+
+  def find_in_source_paths(file); end
+
+  def get(source, *args, &block); end
+
+  def gsub_file(path, flag, *args, &block); end
+
+  def in_root(); end
+
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
+
+  def inject_into_class(path, klass, *args, &block); end
+
+  def inject_into_file(destination, *args, &block); end
+
+  def inject_into_module(path, module_name, *args, &block); end
+
+  def insert_into_file(destination, *args, &block); end
+
+  def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end
+
+  def link_file(source, *args); end
+
+  def prepend_file(path, *args, &block); end
+
+  def prepend_to_file(path, *args, &block); end
+
+  def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end
+
+  def remove_dir(path, config=T.unsafe(nil)); end
+
+  def remove_file(path, config=T.unsafe(nil)); end
+
+  def run(command, config=T.unsafe(nil)); end
+
+  def run_ruby_script(command, config=T.unsafe(nil)); end
+
+  def source_paths(); end
+
+  def template(source, *args, &block); end
+
+  def thor(command, *args); end
+
+  def uncomment_lines(path, flag, *args); end
+  WARNINGS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Actions::CapturableERB
+end
+
+class Bundler::Thor::Actions::CapturableERB
+end
+
+module Bundler::Thor::Actions::ClassMethods
+  def add_runtime_options!(); end
+
+  def source_paths(); end
+
+  def source_paths_for_search(); end
+
+  def source_root(path=T.unsafe(nil)); end
+end
+
+module Bundler::Thor::Actions::ClassMethods
+end
+
+class Bundler::Thor::Actions::CreateFile
+  def data(); end
+
+  def force_on_collision?(); end
+
+  def force_or_skip_or_conflict(force, skip, &block); end
+
+  def identical?(); end
+
+  def initialize(base, destination, data, config=T.unsafe(nil)); end
+
+  def on_conflict_behavior(&block); end
+
+  def render(); end
+end
+
+class Bundler::Thor::Actions::CreateFile
+end
+
+class Bundler::Thor::Actions::CreateLink
+end
+
+class Bundler::Thor::Actions::CreateLink
+end
+
+class Bundler::Thor::Actions::Directory
+  def execute!(); end
+
+  def file_level_lookup(previous_lookup); end
+
+  def files(lookup); end
+
+  def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end
+
+  def source(); end
+end
+
+class Bundler::Thor::Actions::Directory
+end
+
+class Bundler::Thor::Actions::EmptyDirectory
+  def base(); end
+
+  def config(); end
+
+  def convert_encoded_instructions(filename); end
+
+  def destination(); end
+
+  def destination=(destination); end
+
+  def exists?(); end
+
+  def given_destination(); end
+
+  def initialize(base, destination, config=T.unsafe(nil)); end
+
+  def invoke!(); end
+
+  def invoke_with_conflict_check(&block); end
+
+  def on_conflict_behavior(); end
+
+  def on_file_clash_behavior(); end
+
+  def pretend?(); end
+
+  def relative_destination(); end
+
+  def revoke!(); end
+
+  def say_status(status, color); end
+end
+
+class Bundler::Thor::Actions::EmptyDirectory
+end
+
+class Bundler::Thor::Actions::InjectIntoFile
+  def behavior(); end
+
+  def flag(); end
+
+  def initialize(base, destination, data, config); end
+
+  def replace!(regexp, string, force); end
+
+  def replacement(); end
+
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
+end
+
+class Bundler::Thor::Actions::InjectIntoFile
+end
+
+module Bundler::Thor::Actions
+  def self.included(base); end
+end
+
+class Bundler::Thor::AmbiguousCommandError
+end
+
+class Bundler::Thor::AmbiguousCommandError
+end
+
+Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError
+
+class Bundler::Thor::Argument
+  def banner(); end
+
+  def default(); end
+
+  def default_banner(); end
+
+  def description(); end
+
+  def enum(); end
+
+  def human_name(); end
+
+  def initialize(name, options=T.unsafe(nil)); end
+
+  def name(); end
+
+  def required(); end
+
+  def required?(); end
+
+  def show_default?(); end
+
+  def type(); end
+
+  def usage(); end
+
+  def valid_type?(type); end
+
+  def validate!(); end
+  VALID_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Argument
+end
+
+class Bundler::Thor::Arguments
+  def initialize(arguments=T.unsafe(nil)); end
+
+  def parse(args); end
+
+  def remaining(); end
+  NUMERIC = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Arguments
+  def self.parse(*args); end
+
+  def self.split(args); end
+end
+
+module Bundler::Thor::Base
+  def args(); end
+
+  def args=(args); end
+
+  def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def parent_options(); end
+
+  def parent_options=(parent_options); end
+end
+
+module Bundler::Thor::Base::ClassMethods
+  def all_commands(); end
+
+  def all_tasks(); end
+
+  def allow_incompatible_default_type!(); end
+
+  def argument(name, options=T.unsafe(nil)); end
+
+  def arguments(); end
+
+  def attr_accessor(*_); end
+
+  def attr_reader(*_); end
+
+  def attr_writer(*_); end
+
+  def baseclass(); end
+
+  def basename(); end
+
+  def build_option(name, options, scope); end
+
+  def build_options(options, scope); end
+
+  def check_default_type(); end
+
+  def check_default_type!(); end
+
+  def check_unknown_options(); end
+
+  def check_unknown_options!(); end
+
+  def check_unknown_options?(config); end
+
+  def class_option(name, options=T.unsafe(nil)); end
+
+  def class_options(options=T.unsafe(nil)); end
+
+  def class_options_help(shell, groups=T.unsafe(nil)); end
+
+  def commands(); end
+
+  def create_command(meth); end
+
+  def create_task(meth); end
+
+  def disable_required_check?(command_name); end
+
+  def dispatch(command, given_args, given_opts, config); end
+
+  def exit_on_failure?(); end
+
+  def find_and_refresh_command(name); end
+
+  def find_and_refresh_task(name); end
+
+  def from_superclass(method, default=T.unsafe(nil)); end
+
+  def group(name=T.unsafe(nil)); end
+
+  def handle_argument_error(command, error, args, arity); end
+
+  def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end
+
+  def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end
+
+  def inherited(klass); end
+
+  def initialize_added(); end
+
+  def is_thor_reserved_word?(word, type); end
+
+  def method_added(meth); end
+
+  def namespace(name=T.unsafe(nil)); end
+
+  def no_commands(&block); end
+
+  def no_commands?(); end
+
+  def no_commands_context(); end
+
+  def no_tasks(&block); end
+
+  def print_options(shell, options, group_name=T.unsafe(nil)); end
+
+  def public_command(*names); end
+
+  def public_task(*names); end
+
+  def remove_argument(*names); end
+
+  def remove_class_option(*names); end
+
+  def remove_command(*names); end
+
+  def remove_task(*names); end
+
+  def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end
+
+  def stop_on_unknown_option?(command_name); end
+
+  def strict_args_position(); end
+
+  def strict_args_position!(); end
+
+  def strict_args_position?(config); end
+
+  def tasks(); end
+end
+
+module Bundler::Thor::Base::ClassMethods
+end
+
+module Bundler::Thor::Base
+  def self.included(base); end
+
+  def self.register_klass_file(klass); end
+
+  def self.shell(); end
+
+  def self.shell=(shell); end
+
+  def self.subclass_files(); end
+
+  def self.subclasses(); end
+end
+
+class Bundler::Thor::Command
+  def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+
+  def handle_argument_error?(instance, error, caller); end
+
+  def handle_no_method_error?(instance, error, caller); end
+
+  def hidden?(); end
+
+  def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end
+
+  def local_method?(instance, name); end
+
+  def not_debugging?(instance); end
+
+  def private_method?(instance); end
+
+  def public_method?(instance); end
+
+  def required_arguments_for(klass, usage); end
+
+  def required_options(); end
+
+  def run(instance, args=T.unsafe(nil)); end
+
+  def sans_backtrace(backtrace, caller); end
+  FILE_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Command
+end
+
+module Bundler::Thor::CoreExt
+end
+
+class Bundler::Thor::CoreExt::HashWithIndifferentAccess
+  def [](key); end
+
+  def []=(key, value); end
+
+  def convert_key(key); end
+
+  def delete(key); end
+
+  def fetch(key, *args); end
+
+  def initialize(hash=T.unsafe(nil)); end
+
+  def key?(key); end
+
+  def merge(other); end
+
+  def merge!(other); end
+
+  def method_missing(method, *args); end
+
+  def replace(other_hash); end
+
+  def reverse_merge(other); end
+
+  def values_at(*indices); end
+end
+
+class Bundler::Thor::CoreExt::HashWithIndifferentAccess
+end
+
+module Bundler::Thor::CoreExt
+end
+
+Bundler::Thor::Correctable = DidYouMean::Correctable
+
+class Bundler::Thor::DynamicCommand
+  def initialize(name, options=T.unsafe(nil)); end
+end
+
+class Bundler::Thor::DynamicCommand
+end
+
+Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand
+
+class Bundler::Thor::Error
+end
+
+class Bundler::Thor::Error
+end
+
+class Bundler::Thor::Group
+  include ::Bundler::Thor::Base
+  include ::Bundler::Thor::Invocation
+  include ::Bundler::Thor::Shell
+  def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end
+end
+
+class Bundler::Thor::Group
+  extend ::Bundler::Thor::Base::ClassMethods
+  extend ::Bundler::Thor::Invocation::ClassMethods
+  def self.banner(); end
+
+  def self.desc(description=T.unsafe(nil)); end
+
+  def self.get_options_from_invocations(group_options, base_options); end
+
+  def self.handle_argument_error(command, error, _args, arity); end
+
+  def self.help(shell); end
+
+  def self.invocation_blocks(); end
+
+  def self.invocations(); end
+
+  def self.invoke(*names, &block); end
+
+  def self.invoke_from_option(*names, &block); end
+
+  def self.printable_commands(*_); end
+
+  def self.printable_tasks(*_); end
+
+  def self.remove_invocation(*names); end
+
+  def self.self_command(); end
+
+  def self.self_task(); end
+end
+
+class Bundler::Thor::HiddenCommand
+end
+
+class Bundler::Thor::HiddenCommand
+end
+
+Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand
+
+module Bundler::Thor::Invocation
+  def _parse_initialization_options(args, opts, config); end
+
+  def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end
+
+  def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end
+
+  def _shared_configuration(); end
+
+  def current_command_chain(); end
+
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end
+
+  def invoke(name=T.unsafe(nil), *args); end
+
+  def invoke_all(); end
+
+  def invoke_command(command, *args); end
+
+  def invoke_task(command, *args); end
+
+  def invoke_with_padding(*args); end
+end
+
+module Bundler::Thor::Invocation::ClassMethods
+  def prepare_for_invocation(key, name); end
+end
+
+module Bundler::Thor::Invocation::ClassMethods
+end
+
+module Bundler::Thor::Invocation
+  def self.included(base); end
+end
+
+class Bundler::Thor::InvocationError
+end
+
+class Bundler::Thor::InvocationError
+end
+
+module Bundler::Thor::LineEditor
+end
+
+class Bundler::Thor::LineEditor::Basic
+  def initialize(prompt, options); end
+
+  def options(); end
+
+  def prompt(); end
+
+  def readline(); end
+end
+
+class Bundler::Thor::LineEditor::Basic
+  def self.available?(); end
+end
+
+class Bundler::Thor::LineEditor::Readline
+end
+
+class Bundler::Thor::LineEditor::Readline::PathCompletion
+  def initialize(text); end
+
+  def matches(); end
+end
+
+class Bundler::Thor::LineEditor::Readline::PathCompletion
+end
+
+class Bundler::Thor::LineEditor::Readline
+end
+
+module Bundler::Thor::LineEditor
+  def self.best_available(); end
+
+  def self.readline(prompt, options=T.unsafe(nil)); end
+end
+
+class Bundler::Thor::MalformattedArgumentError
+end
+
+class Bundler::Thor::MalformattedArgumentError
+end
+
+class Bundler::Thor::NestedContext
+  def enter(); end
+
+  def entered?(); end
+end
+
+class Bundler::Thor::NestedContext
+end
+
+class Bundler::Thor::NoKwargSpellChecker
+  def initialize(dictionary); end
+end
+
+class Bundler::Thor::NoKwargSpellChecker
+end
+
+class Bundler::Thor::Option
+  def aliases(); end
+
+  def array?(); end
+
+  def boolean?(); end
+
+  def dasherize(str); end
+
+  def dasherized?(); end
+
+  def group(); end
+
+  def hash?(); end
+
+  def hide(); end
+
+  def lazy_default(); end
+
+  def numeric?(); end
+
+  def repeatable(); end
+
+  def string?(); end
+
+  def switch_name(); end
+
+  def undasherize(str); end
+
+  def usage(padding=T.unsafe(nil)); end
+
+  def validate_default_type!(); end
+  VALID_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Option
+  def self.parse(key, value); end
+end
+
+class Bundler::Thor::Options
+  def assign_result!(option, result); end
+
+  def check_unknown!(); end
+
+  def current_is_switch?(); end
+
+  def current_is_switch_formatted?(); end
+
+  def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end
+
+  def normalize_switch(arg); end
+
+  def parse_boolean(switch); end
+
+  def parse_peek(switch, option); end
+
+  def parsing_options?(); end
+
+  def switch?(arg); end
+
+  def switch_option(arg); end
+  EQ_RE = ::T.let(nil, ::T.untyped)
+  LONG_RE = ::T.let(nil, ::T.untyped)
+  OPTS_END = ::T.let(nil, ::T.untyped)
+  SHORT_NUM = ::T.let(nil, ::T.untyped)
+  SHORT_RE = ::T.let(nil, ::T.untyped)
+  SHORT_SQ_RE = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Options
+  def self.to_switches(options); end
+end
+
+module Bundler::Thor::RakeCompat
+  include ::Rake::DSL
+  include ::Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+end
+
+module Bundler::Thor::RakeCompat
+  def self.included(base); end
+
+  def self.rake_classes(); end
+end
+
+class Bundler::Thor::RequiredArgumentMissingError
+end
+
+class Bundler::Thor::RequiredArgumentMissingError
+end
+
+module Bundler::Thor::Sandbox
+end
+
+module Bundler::Thor::Sandbox
+end
+
+module Bundler::Thor::Shell
+  def _shared_configuration(); end
+
+  def ask(*args, &block); end
+
+  def error(*args, &block); end
+
+  def file_collision(*args, &block); end
+
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
+
+  def no?(*args, &block); end
+
+  def print_in_columns(*args, &block); end
+
+  def print_table(*args, &block); end
+
+  def print_wrapped(*args, &block); end
+
+  def say(*args, &block); end
+
+  def say_status(*args, &block); end
+
+  def set_color(*args, &block); end
+
+  def shell(); end
+
+  def shell=(shell); end
+
+  def terminal_width(*args, &block); end
+
+  def with_padding(); end
+
+  def yes?(*args, &block); end
+  SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Shell::Basic
+  def answer_match(possibilities, answer, case_insensitive); end
+
+  def as_unicode(); end
+
+  def ask(statement, *args); end
+
+  def ask_filtered(statement, color, options); end
+
+  def ask_simply(statement, color, options); end
+
+  def base(); end
+
+  def base=(base); end
+
+  def can_display_colors?(); end
+
+  def dynamic_width(); end
+
+  def dynamic_width_stty(); end
+
+  def dynamic_width_tput(); end
+
+  def error(statement); end
+
+  def file_collision(destination); end
+
+  def file_collision_help(); end
+
+  def git_merge_tool(); end
+
+  def indent(count=T.unsafe(nil)); end
+
+  def is?(value); end
+
+  def lookup_color(color); end
+
+  def merge(destination, content); end
+
+  def merge_tool(); end
+
+  def mute(); end
+
+  def mute?(); end
+
+  def no?(statement, color=T.unsafe(nil)); end
+
+  def padding(); end
+
+  def padding=(value); end
+
+  def prepare_message(message, *color); end
+
+  def print_in_columns(array); end
+
+  def print_table(array, options=T.unsafe(nil)); end
+
+  def print_wrapped(message, options=T.unsafe(nil)); end
+
+  def quiet?(); end
+
+  def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end
+
+  def say_status(status, message, log_status=T.unsafe(nil)); end
+
+  def set_color(string, *_); end
+
+  def show_diff(destination, content); end
+
+  def stderr(); end
+
+  def stdout(); end
+
+  def terminal_width(); end
+
+  def truncate(string, width); end
+
+  def unix?(); end
+
+  def yes?(statement, color=T.unsafe(nil)); end
+  DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Shell::Basic
+end
+
+class Bundler::Thor::Shell::Color
+  def are_colors_disabled?(); end
+
+  def diff_lcs_loaded?(); end
+
+  def output_diff_line(diff); end
+
+  def set_color(string, *colors); end
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Shell::Color
+end
+
+class Bundler::Thor::Shell::HTML
+  def ask(statement, color=T.unsafe(nil)); end
+
+  def diff_lcs_loaded?(); end
+
+  def output_diff_line(diff); end
+
+  def set_color(string, *colors); end
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Thor::Shell::HTML
+end
+
+module Bundler::Thor::Shell
+end
+
+Bundler::Thor::Task = Bundler::Thor::Command
+
+class Bundler::Thor::UndefinedCommandError
+  include ::DidYouMean::Correctable
+  def all_commands(); end
+
+  def command(); end
+
+  def initialize(command, all_commands, namespace); end
+end
+
+class Bundler::Thor::UndefinedCommandError::SpellChecker
+  def corrections(); end
+
+  def error(); end
+
+  def initialize(error); end
+
+  def spell_checker(); end
+end
+
+class Bundler::Thor::UndefinedCommandError::SpellChecker
+end
+
+class Bundler::Thor::UndefinedCommandError
+end
+
+Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError
+
+class Bundler::Thor::UnknownArgumentError
+  include ::DidYouMean::Correctable
+  def initialize(switches, unknown); end
+
+  def switches(); end
+
+  def unknown(); end
+end
+
+class Bundler::Thor::UnknownArgumentError::SpellChecker
+  def corrections(); end
+
+  def error(); end
+
+  def initialize(error); end
+
+  def spell_checker(); end
+end
+
+class Bundler::Thor::UnknownArgumentError::SpellChecker
+end
+
+class Bundler::Thor::UnknownArgumentError
+end
+
+module Bundler::Thor::Util
+end
+
+module Bundler::Thor::Util
+  def self.camel_case(str); end
+
+  def self.escape_globs(path); end
+
+  def self.escape_html(string); end
+
+  def self.find_by_namespace(namespace); end
+
+  def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end
+
+  def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end
+
+  def self.globs_for(path); end
+
+  def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end
+
+  def self.namespace_from_thor_class(constant); end
+
+  def self.namespaces_in_content(contents, file=T.unsafe(nil)); end
+
+  def self.ruby_command(); end
+
+  def self.snake_case(str); end
+
+  def self.thor_classes_in(klass); end
+
+  def self.thor_root(); end
+
+  def self.thor_root_glob(); end
+
+  def self.user_home(); end
+end
+
+class Bundler::Thor
+  extend ::Bundler::Thor::Base::ClassMethods
+  extend ::Bundler::Thor::Invocation::ClassMethods
+  def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+
+  def self.check_unknown_options!(options=T.unsafe(nil)); end
+
+  def self.command_help(shell, command_name); end
+
+  def self.default_command(meth=T.unsafe(nil)); end
+
+  def self.default_task(meth=T.unsafe(nil)); end
+
+  def self.deprecation_warning(message); end
+
+  def self.desc(usage, description, options=T.unsafe(nil)); end
+
+  def self.disable_required_check(); end
+
+  def self.disable_required_check!(*command_names); end
+
+  def self.disable_required_check?(command); end
+
+  def self.dispatch(meth, given_args, given_opts, config); end
+
+  def self.dynamic_command_class(); end
+
+  def self.find_command_possibilities(meth); end
+
+  def self.find_task_possibilities(meth); end
+
+  def self.help(shell, subcommand=T.unsafe(nil)); end
+
+  def self.long_desc(long_description, options=T.unsafe(nil)); end
+
+  def self.map(mappings=T.unsafe(nil), **kw); end
+
+  def self.method_option(name, options=T.unsafe(nil)); end
+
+  def self.method_options(options=T.unsafe(nil)); end
+
+  def self.normalize_command_name(meth); end
+
+  def self.normalize_task_name(meth); end
+
+  def self.option(name, options=T.unsafe(nil)); end
+
+  def self.options(options=T.unsafe(nil)); end
+
+  def self.package_name(name, _=T.unsafe(nil)); end
+
+  def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+
+  def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+
+  def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end
+
+  def self.retrieve_command_name(args); end
+
+  def self.retrieve_task_name(args); end
+
+  def self.stop_on_unknown_option(); end
+
+  def self.stop_on_unknown_option!(*command_names); end
+
+  def self.stop_on_unknown_option?(command); end
+
+  def self.subcommand(subcommand, subcommand_class); end
+
+  def self.subcommand_classes(); end
+
+  def self.subcommand_help(cmd); end
+
+  def self.subcommands(); end
+
+  def self.subtask(subcommand, subcommand_class); end
+
+  def self.subtask_help(cmd); end
+
+  def self.subtasks(); end
+
+  def self.task_help(shell, command_name); end
+end
+
+class Bundler::UI::Shell
+  def add_color(string, *color); end
+
+  def ask(msg); end
+
+  def confirm(msg, newline=T.unsafe(nil)); end
+
+  def debug(msg, newline=T.unsafe(nil)); end
+
+  def debug?(); end
+
+  def error(msg, newline=T.unsafe(nil)); end
+
+  def info(msg, newline=T.unsafe(nil)); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def level(name=T.unsafe(nil)); end
+
+  def level=(level); end
+
+  def no?(); end
+
+  def quiet?(); end
+
+  def shell=(shell); end
+
+  def silence(&blk); end
+
+  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
+
+  def unprinted_warnings(); end
+
+  def warn(msg, newline=T.unsafe(nil)); end
+
+  def yes?(msg); end
+  LEVELS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::UI::Shell
+end
+
+module Bundler::URI
+  include ::Bundler::URI::RFC2396_REGEXP
+  ABS_PATH = ::T.let(nil, ::T.untyped)
+  ABS_URI = ::T.let(nil, ::T.untyped)
+  ABS_URI_REF = ::T.let(nil, ::T.untyped)
+  DEFAULT_PARSER = ::T.let(nil, ::T.untyped)
+  ESCAPED = ::T.let(nil, ::T.untyped)
+  FRAGMENT = ::T.let(nil, ::T.untyped)
+  HOST = ::T.let(nil, ::T.untyped)
+  OPAQUE = ::T.let(nil, ::T.untyped)
+  PORT = ::T.let(nil, ::T.untyped)
+  QUERY = ::T.let(nil, ::T.untyped)
+  REGISTRY = ::T.let(nil, ::T.untyped)
+  REL_PATH = ::T.let(nil, ::T.untyped)
+  REL_URI = ::T.let(nil, ::T.untyped)
+  REL_URI_REF = ::T.let(nil, ::T.untyped)
+  RFC3986_PARSER = ::T.let(nil, ::T.untyped)
+  SCHEME = ::T.let(nil, ::T.untyped)
+  TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped)
+  TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped)
+  UNSAFE = ::T.let(nil, ::T.untyped)
+  URI_REF = ::T.let(nil, ::T.untyped)
+  USERINFO = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  VERSION_CODE = ::T.let(nil, ::T.untyped)
+  WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::BadURIError
+end
+
+class Bundler::URI::BadURIError
+end
+
+class Bundler::URI::Error
+end
+
+class Bundler::URI::Error
+end
+
+module Bundler::URI::Escape
+  def decode(*arg); end
+
+  def encode(*arg); end
+
+  def escape(*arg); end
+
+  def unescape(*arg); end
+end
+
+module Bundler::URI::Escape
+end
+
+class Bundler::URI::FTP
+  def set_typecode(v); end
+
+  def typecode(); end
+
+  def typecode=(typecode); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  TYPECODE = ::T.let(nil, ::T.untyped)
+  TYPECODE_PREFIX = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::FTP
+  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
+end
+
+class Bundler::URI::File
+  def check_password(user); end
+
+  def check_user(user); end
+
+  def check_userinfo(user); end
+
+  def set_userinfo(v); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::File
+end
+
+class Bundler::URI::Generic
+  include ::Bundler::URI
+  include ::Bundler::URI::RFC2396_REGEXP
+  def +(oth); end
+
+  def -(oth); end
+
+  def ==(oth); end
+
+  def absolute(); end
+
+  def absolute?(); end
+
+  def coerce(oth); end
+
+  def component(); end
+
+  def component_ary(); end
+
+  def default_port(); end
+
+  def eql?(oth); end
+
+  def find_proxy(env=T.unsafe(nil)); end
+
+  def fragment(); end
+
+  def fragment=(v); end
+
+  def hierarchical?(); end
+
+  def host(); end
+
+  def host=(v); end
+
+  def hostname(); end
+
+  def hostname=(v); end
+
+  def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end
+
+  def merge(oth); end
+
+  def merge!(oth); end
+
+  def normalize(); end
+
+  def normalize!(); end
+
+  def opaque(); end
+
+  def opaque=(v); end
+
+  def parser(); end
+
+  def password(); end
+
+  def password=(password); end
+
+  def path(); end
+
+  def path=(v); end
+
+  def port(); end
+
+  def port=(v); end
+
+  def query(); end
+
+  def query=(v); end
+
+  def registry(); end
+
+  def registry=(v); end
+
+  def relative?(); end
+
+  def route_from(oth); end
+
+  def route_to(oth); end
+
+  def scheme(); end
+
+  def scheme=(v); end
+
+  def select(*components); end
+
+  def set_host(v); end
+
+  def set_opaque(v); end
+
+  def set_password(v); end
+
+  def set_path(v); end
+
+  def set_port(v); end
+
+  def set_registry(v); end
+
+  def set_scheme(v); end
+
+  def set_user(v); end
+
+  def set_userinfo(user, password=T.unsafe(nil)); end
+
+  def user(); end
+
+  def user=(user); end
+
+  def userinfo(); end
+
+  def userinfo=(userinfo); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  USE_REGISTRY = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::Generic
+  def self.build(args); end
+
+  def self.build2(args); end
+
+  def self.component(); end
+
+  def self.default_port(); end
+
+  def self.use_proxy?(hostname, addr, port, no_proxy); end
+
+  def self.use_registry(); end
+end
+
+class Bundler::URI::HTTP
+  def request_uri(); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::HTTP
+end
+
+class Bundler::URI::HTTPS
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::HTTPS
+end
+
+class Bundler::URI::InvalidComponentError
+end
+
+class Bundler::URI::InvalidComponentError
+end
+
+class Bundler::URI::InvalidURIError
+end
+
+class Bundler::URI::InvalidURIError
+end
+
+class Bundler::URI::LDAP
+  def attributes(); end
+
+  def attributes=(val); end
+
+  def dn(); end
+
+  def dn=(val); end
+
+  def extensions(); end
+
+  def extensions=(val); end
+
+  def filter(); end
+
+  def filter=(val); end
+
+  def initialize(*arg); end
+
+  def scope(); end
+
+  def scope=(val); end
+
+  def set_attributes(val); end
+
+  def set_dn(val); end
+
+  def set_extensions(val); end
+
+  def set_filter(val); end
+
+  def set_scope(val); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  SCOPE = ::T.let(nil, ::T.untyped)
+  SCOPE_BASE = ::T.let(nil, ::T.untyped)
+  SCOPE_ONE = ::T.let(nil, ::T.untyped)
+  SCOPE_SUB = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::LDAP
+end
+
+class Bundler::URI::LDAPS
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::LDAPS
+end
+
+class Bundler::URI::MailTo
+  def headers(); end
+
+  def headers=(v); end
+
+  def initialize(*arg); end
+
+  def set_headers(v); end
+
+  def set_to(v); end
+
+  def to(); end
+
+  def to=(v); end
+
+  def to_mailtext(); end
+
+  def to_rfc822text(); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  EMAIL_REGEXP = ::T.let(nil, ::T.untyped)
+  HEADER_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::MailTo
+end
+
+Bundler::URI::Parser = Bundler::URI::RFC2396_Parser
+
+Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP
+
+class Bundler::URI::RFC2396_Parser
+  include ::Bundler::URI::RFC2396_REGEXP
+  def escape(str, unsafe=T.unsafe(nil)); end
+
+  def extract(str, schemes=T.unsafe(nil)); end
+
+  def initialize(opts=T.unsafe(nil)); end
+
+  def join(*uris); end
+
+  def make_regexp(schemes=T.unsafe(nil)); end
+
+  def parse(uri); end
+
+  def pattern(); end
+
+  def regexp(); end
+
+  def split(uri); end
+
+  def unescape(str, escaped=T.unsafe(nil)); end
+end
+
+class Bundler::URI::RFC2396_Parser
+end
+
+module Bundler::URI::RFC2396_REGEXP
+end
+
+module Bundler::URI::RFC2396_REGEXP::PATTERN
+  ABS_PATH = ::T.let(nil, ::T.untyped)
+  ABS_URI = ::T.let(nil, ::T.untyped)
+  ALNUM = ::T.let(nil, ::T.untyped)
+  ALPHA = ::T.let(nil, ::T.untyped)
+  DOMLABEL = ::T.let(nil, ::T.untyped)
+  ESCAPED = ::T.let(nil, ::T.untyped)
+  FRAGMENT = ::T.let(nil, ::T.untyped)
+  HEX = ::T.let(nil, ::T.untyped)
+  HIER_PART = ::T.let(nil, ::T.untyped)
+  HOST = ::T.let(nil, ::T.untyped)
+  HOSTNAME = ::T.let(nil, ::T.untyped)
+  HOSTPORT = ::T.let(nil, ::T.untyped)
+  IPV4ADDR = ::T.let(nil, ::T.untyped)
+  IPV6ADDR = ::T.let(nil, ::T.untyped)
+  IPV6REF = ::T.let(nil, ::T.untyped)
+  NET_PATH = ::T.let(nil, ::T.untyped)
+  OPAQUE_PART = ::T.let(nil, ::T.untyped)
+  PATH_SEGMENTS = ::T.let(nil, ::T.untyped)
+  PORT = ::T.let(nil, ::T.untyped)
+  QUERY = ::T.let(nil, ::T.untyped)
+  REG_NAME = ::T.let(nil, ::T.untyped)
+  REL_PATH = ::T.let(nil, ::T.untyped)
+  REL_SEGMENT = ::T.let(nil, ::T.untyped)
+  REL_URI = ::T.let(nil, ::T.untyped)
+  RESERVED = ::T.let(nil, ::T.untyped)
+  SCHEME = ::T.let(nil, ::T.untyped)
+  TOPLABEL = ::T.let(nil, ::T.untyped)
+  UNRESERVED = ::T.let(nil, ::T.untyped)
+  URIC = ::T.let(nil, ::T.untyped)
+  URIC_NO_SLASH = ::T.let(nil, ::T.untyped)
+  URI_REF = ::T.let(nil, ::T.untyped)
+  USERINFO = ::T.let(nil, ::T.untyped)
+  X_ABS_URI = ::T.let(nil, ::T.untyped)
+  X_REL_URI = ::T.let(nil, ::T.untyped)
+end
+
+module Bundler::URI::RFC2396_REGEXP::PATTERN
+end
+
+module Bundler::URI::RFC2396_REGEXP
+end
+
+class Bundler::URI::RFC3986_Parser
+  def join(*uris); end
+
+  def parse(uri); end
+
+  def regexp(); end
+
+  def split(uri); end
+  RFC3986_URI = ::T.let(nil, ::T.untyped)
+  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::RFC3986_Parser
+end
+
+module Bundler::URI::Util
+end
+
+module Bundler::URI::Util
+  def self.make_components_hash(klass, array_hash); end
+end
+
+module Bundler::URI
+  extend ::Bundler::URI::Escape
+  def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end
+
+  def self.decode_www_form_component(str, enc=T.unsafe(nil)); end
+
+  def self.encode_www_form(enum, enc=T.unsafe(nil)); end
+
+  def self.encode_www_form_component(str, enc=T.unsafe(nil)); end
+
+  def self.extract(str, schemes=T.unsafe(nil), &block); end
+
+  def self.get_encoding(label); end
+
+  def self.join(*str); end
+
+  def self.parse(uri); end
+
+  def self.regexp(schemes=T.unsafe(nil)); end
+
+  def self.scheme_list(); end
+
+  def self.split(uri); end
+end
+
+module Bundler::VersionRanges
+end
+
+class Bundler::VersionRanges::NEq
+  def version(); end
+
+  def version=(_); end
+end
+
+class Bundler::VersionRanges::NEq
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::VersionRanges::ReqR
+  def cover?(v); end
+
+  def empty?(); end
+
+  def left(); end
+
+  def left=(_); end
+
+  def right(); end
+
+  def right=(_); end
+
+  def single?(); end
+  INFINITY = ::T.let(nil, ::T.untyped)
+  UNIVERSAL = ::T.let(nil, ::T.untyped)
+  ZERO = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::VersionRanges::ReqR::Endpoint
+  def inclusive(); end
+
+  def inclusive=(_); end
+
+  def version(); end
+
+  def version=(_); end
+end
+
+class Bundler::VersionRanges::ReqR::Endpoint
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::VersionRanges::ReqR
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+module Bundler::VersionRanges
+  def self.empty?(ranges, neqs); end
+
+  def self.for(requirement); end
+
+  def self.for_many(requirements); end
+end
+
+module Bundler
+  def self.original_exec(*args); end
+
+  def self.original_system(*args); end
+
+  def self.unbundled_env(); end
+
+  def self.unbundled_exec(*args); end
+
+  def self.unbundled_system(*args); end
+
+  def self.with_unbundled_env(); end
+end
+
+module CGI::HtmlExtension
+  def a(href=T.unsafe(nil)); end
+
+  def base(href=T.unsafe(nil)); end
+
+  def blockquote(cite=T.unsafe(nil)); end
+
+  def caption(align=T.unsafe(nil)); end
+
+  def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
+
+  def checkbox_group(name=T.unsafe(nil), *values); end
+
+  def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end
+
+  def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end
+
+  def html(attributes=T.unsafe(nil)); end
+
+  def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end
+
+  def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end
+
+  def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end
+
+  def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def popup_menu(name=T.unsafe(nil), *values); end
+
+  def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
+
+  def radio_group(name=T.unsafe(nil), *values); end
+
+  def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def scrolling_list(name=T.unsafe(nil), *values); end
+
+  def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end
+end
+
+module CGI::HtmlExtension
+end
+
+class Class
+  def json_creatable?(); end
+end
+
+module CodeRay
+  CODERAY_PATH = ::T.let(nil, ::T.untyped)
+  TokenKinds = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class CodeRay::Duo
+  def call(code, options=T.unsafe(nil)); end
+
+  def encode(code, options=T.unsafe(nil)); end
+
+  def encoder(); end
+
+  def format(); end
+
+  def format=(format); end
+
+  def highlight(code, options=T.unsafe(nil)); end
+
+  def initialize(lang=T.unsafe(nil), format=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def lang(); end
+
+  def lang=(lang); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def scanner(); end
+end
+
+class CodeRay::Duo
+  def self.[](*_); end
+end
+
+class CodeRay::Encoders::Encoder
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders
+
+class CodeRay::Encoders::Terminal
+  TOKEN_COLORS = ::T.let(nil, ::T.untyped)
+end
+
+module CodeRay::FileType
+  TypeFromExt = ::T.let(nil, ::T.untyped)
+  TypeFromName = ::T.let(nil, ::T.untyped)
+  TypeFromShebang = ::T.let(nil, ::T.untyped)
+end
+
+class CodeRay::FileType::UnknownFileType
+end
+
+class CodeRay::FileType::UnknownFileType
+end
+
+module CodeRay::FileType
+  def self.[](filename, read_shebang=T.unsafe(nil)); end
+
+  def self.fetch(filename, default=T.unsafe(nil), read_shebang=T.unsafe(nil)); end
+
+  def self.type_from_shebang(filename); end
+end
+
+module CodeRay::PluginHost
+  PLUGIN_HOSTS = ::T.let(nil, ::T.untyped)
+  PLUGIN_HOSTS_BY_ID = ::T.let(nil, ::T.untyped)
+end
+
+module CodeRay::Scanners
+end
+
+class CodeRay::Scanners::Scanner
+  include ::Enumerable
+  def binary_string(); end
+
+  def column(pos=T.unsafe(nil)); end
+
+  def each(&block); end
+
+  def file_extension(); end
+
+  def initialize(code=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def lang(); end
+
+  def line(pos=T.unsafe(nil)); end
+
+  def raise_inspect(message, tokens, state=T.unsafe(nil), ambit=T.unsafe(nil), backtrace=T.unsafe(nil)); end
+
+  def raise_inspect_arguments(message, tokens, state, ambit); end
+
+  def reset_instance(); end
+
+  def scan_rest(); end
+
+  def scan_tokens(tokens, options); end
+
+  def scanner_state_info(state); end
+
+  def set_string_from_source(source); end
+
+  def set_tokens_from_options(options); end
+
+  def setup(); end
+
+  def state(); end
+
+  def state=(state); end
+
+  def string=(code); end
+
+  def tokenize(source=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def tokens(); end
+
+  def tokens_last(tokens, n); end
+
+  def tokens_size(tokens); end
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+  KINDS_NOT_LOC = ::T.let(nil, ::T.untyped)
+  SCANNER_STATE_INFO = ::T.let(nil, ::T.untyped)
+  SCAN_ERROR_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners
+
+class CodeRay::Scanners::Scanner::ScanError
+end
+
+class CodeRay::Scanners::Scanner::ScanError
+end
+
+class CodeRay::Scanners::Scanner
+  extend ::CodeRay::Plugin
+  def self.encode_with_encoding(code, target_encoding); end
+
+  def self.encoding(name=T.unsafe(nil)); end
+
+  def self.file_extension(extension=T.unsafe(nil)); end
+
+  def self.guess_encoding(s); end
+
+  def self.lang(); end
+
+  def self.normalize(code); end
+
+  def self.to_unix(code); end
+end
+
+module CodeRay::Scanners
+  extend ::CodeRay::PluginHost
+end
+
+module CodeRay::Styles
+end
+
+class CodeRay::Styles::Style
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles
+
+class CodeRay::Styles::Style
+  extend ::CodeRay::Plugin
+end
+
+module CodeRay::Styles
+  extend ::CodeRay::PluginHost
+end
+
+class CodeRay::Tokens
+  def begin_group(kind); end
+
+  def begin_line(kind); end
+
+  def count(); end
+
+  def encode(encoder, options=T.unsafe(nil)); end
+
+  def end_group(kind); end
+
+  def end_line(kind); end
+
+  def method_missing(meth, options=T.unsafe(nil)); end
+
+  def scanner(); end
+
+  def scanner=(scanner); end
+
+  def split_into_parts(*sizes); end
+
+  def text_token(*_); end
+
+  def to_s(); end
+
+  def tokens(*_); end
+end
+
+class CodeRay::Tokens
+end
+
+class CodeRay::TokensProxy
+  def block(); end
+
+  def block=(block); end
+
+  def each(*args, &blk); end
+
+  def encode(encoder, options=T.unsafe(nil)); end
+
+  def initialize(input, lang, options=T.unsafe(nil), block=T.unsafe(nil)); end
+
+  def input(); end
+
+  def input=(input); end
+
+  def lang(); end
+
+  def lang=(lang); end
+
+  def method_missing(method, *args, &blk); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def scanner(); end
+
+  def tokens(); end
+end
+
+class CodeRay::TokensProxy
+end
+
+class Comment
+  include ::Comment::GeneratedAttributeMethods
+  include ::Comment::GeneratedAssociationMethods
+  def autosave_associated_records_for_post(*args); end
+
+  def autosave_associated_records_for_user(*args); end
+end
+
+module Comment::GeneratedAssociationMethods
+  def build_post(*args, &block); end
+
+  def build_user(*args, &block); end
+
+  def create_post(*args, &block); end
+
+  def create_post!(*args, &block); end
+
+  def create_user(*args, &block); end
+
+  def create_user!(*args, &block); end
+
+  def post(); end
+
+  def post=(value); end
+
+  def reload_post(); end
+
+  def reload_user(); end
+
+  def user(); end
+
+  def user=(value); end
+end
+
+module Comment::GeneratedAssociationMethods
+end
+
+module Comment::GeneratedAttributeMethods
+end
+
+module Comment::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+module Concurrent
+  NULL = ::T.let(nil, ::T.untyped)
+  NULL_LOGGER = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::AbstractExecutorService
+  FALLBACK_POLICIES = ::T.let(nil, ::T.untyped)
+end
+
+Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
+
+class Concurrent::ConcurrentUpdateError
+  CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::LockFreeStack
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::MVar
+  EMPTY = ::T.let(nil, ::T.untyped)
+  TIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::Maybe
+  NONE = ::T.let(nil, ::T.untyped)
+end
+
+module Concurrent::Promises::InternalStates
+  PENDING = ::T.let(nil, ::T.untyped)
+  RESERVED = ::T.let(nil, ::T.untyped)
+  RESOLVED = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::ReadWriteLock
+  MAX_READERS = ::T.let(nil, ::T.untyped)
+  MAX_WRITERS = ::T.let(nil, ::T.untyped)
+  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
+  WAITING_WRITER = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::ReentrantReadWriteLock
+  MAX_READERS = ::T.let(nil, ::T.untyped)
+  MAX_WRITERS = ::T.let(nil, ::T.untyped)
+  READER_BITS = ::T.let(nil, ::T.untyped)
+  READ_LOCK_MASK = ::T.let(nil, ::T.untyped)
+  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
+  WAITING_WRITER = ::T.let(nil, ::T.untyped)
+  WRITER_BITS = ::T.let(nil, ::T.untyped)
+  WRITE_LOCK_HELD = ::T.let(nil, ::T.untyped)
+  WRITE_LOCK_MASK = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::RubyThreadPoolExecutor
+  DEFAULT_MAX_POOL_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_SYNCHRONOUS = ::T.let(nil, ::T.untyped)
+  DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
+
+module Concurrent::ThreadSafe::Util
+  CPU_COUNT = ::T.let(nil, ::T.untyped)
+  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
+  MAX_INT = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::TimerTask
+  EXECUTION_INTERVAL = ::T.let(nil, ::T.untyped)
+  TIMEOUT_INTERVAL = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::Transaction
+  ABORTED = ::T.let(nil, ::T.untyped)
+end
+
+module Concurrent::Utility::NativeInteger
+  MAX_VALUE = ::T.let(nil, ::T.untyped)
+  MIN_VALUE = ::T.let(nil, ::T.untyped)
+end
+
+module DRb::DRbUndumped
+  def _dump(dummy); end
+end
+
+class DatabaseCleaner::Safeguard
+  CHECKS = ::T.let(nil, ::T.untyped)
+end
+
+class DatabaseCleaner::Safeguard::Production
+  KEYS = ::T.let(nil, ::T.untyped)
+end
+
+class DatabaseCleaner::Safeguard::RemoteDatabaseUrl
+  LOCAL = ::T.let(nil, ::T.untyped)
+end
+
+class Date
+  DATE_FORMATS = ::T.let(nil, ::T.untyped)
+end
+
+class Date::Infinity
+  def initialize(d=T.unsafe(nil)); end
+end
+
+module DateAndTime::Calculations
+  DAYS_INTO_WEEK = ::T.let(nil, ::T.untyped)
+  WEEKEND_DAYS = ::T.let(nil, ::T.untyped)
+end
+
+class DidYouMean::ClassNameChecker
+  def class_name(); end
+
+  def class_names(); end
+
+  def corrections(); end
+
+  def initialize(exception); end
+
+  def scopes(); end
+end
+
+module DidYouMean::Correctable
+  def corrections(); end
+
+  def original_message(); end
+
+  def spell_checker(); end
+
+  def to_s(); end
+end
+
+module DidYouMean::Jaro
+  def self.distance(str1, str2); end
+end
+
+module DidYouMean::JaroWinkler
+  def self.distance(str1, str2); end
+end
+
+class DidYouMean::KeyErrorChecker
+  def corrections(); end
+
+  def initialize(key_error); end
+end
+
+class DidYouMean::KeyErrorChecker
+end
+
+module DidYouMean::Levenshtein
+  def self.distance(str1, str2); end
+
+  def self.min3(a, b, c); end
+end
+
+class DidYouMean::MethodNameChecker
+  def corrections(); end
+
+  def initialize(exception); end
+
+  def method_name(); end
+
+  def method_names(); end
+
+  def receiver(); end
+  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+class DidYouMean::NullChecker
+  def corrections(); end
+
+  def initialize(*_); end
+end
+
+class DidYouMean::PlainFormatter
+  def message_for(corrections); end
+end
+
+class DidYouMean::PlainFormatter
+end
+
+class DidYouMean::VariableNameChecker
+  def corrections(); end
+
+  def cvar_names(); end
+
+  def initialize(exception); end
+
+  def ivar_names(); end
+
+  def lvar_names(); end
+
+  def method_names(); end
+
+  def name(); end
+  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+module DidYouMean
+  def self.formatter(); end
+
+  def self.formatter=(formatter); end
+end
+
+module Digest::UUID
+  DNS_NAMESPACE = ::T.let(nil, ::T.untyped)
+  OID_NAMESPACE = ::T.let(nil, ::T.untyped)
+  URL_NAMESPACE = ::T.let(nil, ::T.untyped)
+  X500_NAMESPACE = ::T.let(nil, ::T.untyped)
+end
+
+module Digest::UUID
+  def self.uuid_from_hash(hash_class, uuid_namespace, name); end
+
+  def self.uuid_v3(uuid_namespace, name); end
+
+  def self.uuid_v4(); end
+
+  def self.uuid_v5(uuid_namespace, name); end
+end
+
+class Dir
+  def children(); end
+
+  def each_child(); end
+end
+
+class Dir
+  def self.exists?(_); end
+end
+
+module Docile
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Docile::FallbackContextProxy
+  NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped)
+  NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped)
+  NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class ERB
+  def def_method(mod, methodname, fname=T.unsafe(nil)); end
+
+  def def_module(methodname=T.unsafe(nil)); end
+end
+
+class ERB::Compiler::Scanner
+  DEFAULT_ETAGS = ::T.let(nil, ::T.untyped)
+  DEFAULT_STAGS = ::T.let(nil, ::T.untyped)
+end
+
+module ERB::Util
+  HTML_ESCAPE = ::T.let(nil, ::T.untyped)
+  HTML_ESCAPE_ONCE_REGEXP = ::T.let(nil, ::T.untyped)
+  JSON_ESCAPE = ::T.let(nil, ::T.untyped)
+  JSON_ESCAPE_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+module ERB::Util
+  def self.html_escape_once(s); end
+
+  def self.json_escape(s); end
+
+  def self.unwrapped_html_escape(s); end
+end
+
+class Encoding
+  def _dump(*_); end
+end
+
+class Encoding::Converter
+  def initialize(*_); end
+end
+
+class Encoding
+  def self._load(_); end
+end
+
+module Enumerable
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  def chain(*_); end
+
+  def sum(identity=T.unsafe(nil), &block); end
+end
+
+class Enumerator
+  def +(_); end
+
+  def each_with_index(); end
+end
+
+class Enumerator::ArithmeticSequence
+  def begin(); end
+
+  def each(&blk); end
+
+  def end(); end
+
+  def exclude_end?(); end
+
+  def last(*_); end
+
+  def step(); end
+end
+
+class Enumerator::ArithmeticSequence
+end
+
+class Enumerator::Chain
+end
+
+class Enumerator::Chain
+end
+
+class Enumerator::Generator
+  def each(*_, &blk); end
+
+  def initialize(*_); end
+end
+
+class Errno::EAUTH
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EAUTH
+end
+
+class Errno::EBADARCH
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADARCH
+end
+
+class Errno::EBADEXEC
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADEXEC
+end
+
+class Errno::EBADMACHO
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADMACHO
+end
+
+class Errno::EBADRPC
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EBADRPC
+end
+
+Errno::ECAPMODE = Errno::NOERROR
+
+Errno::EDEADLOCK = Errno::NOERROR
+
+class Errno::EDEVERR
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EDEVERR
+end
+
+Errno::EDOOFUS = Errno::NOERROR
+
+class Errno::EFTYPE
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EFTYPE
+end
+
+Errno::EIPSEC = Errno::NOERROR
+
+class Errno::ELAST
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ELAST
+end
+
+class Errno::ENEEDAUTH
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENEEDAUTH
+end
+
+class Errno::ENOATTR
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENOATTR
+end
+
+class Errno::ENOPOLICY
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENOPOLICY
+end
+
+Errno::ENOTCAPABLE = Errno::NOERROR
+
+class Errno::ENOTSUP
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENOTSUP
+end
+
+class Errno::EPROCLIM
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPROCLIM
+end
+
+class Errno::EPROCUNAVAIL
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPROCUNAVAIL
+end
+
+class Errno::EPROGMISMATCH
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPROGMISMATCH
+end
+
+class Errno::EPROGUNAVAIL
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPROGUNAVAIL
+end
+
+class Errno::EPWROFF
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::EPWROFF
+end
+
+Errno::EQFULL = Errno::ELAST
+
+class Errno::ERPCMISMATCH
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ERPCMISMATCH
+end
+
+class Errno::ESHLIBVERS
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ESHLIBVERS
+end
+
+class Etc::Group
+  def gid(); end
+
+  def gid=(_); end
+
+  def mem(); end
+
+  def mem=(_); end
+
+  def name(); end
+
+  def name=(_); end
+
+  def passwd(); end
+
+  def passwd=(_); end
+end
+
+class Etc::Group
+  extend ::Enumerable
+  def self.[](*_); end
+
+  def self.each(&blk); end
+
+  def self.members(); end
+end
+
+class Etc::Passwd
+  def change(); end
+
+  def change=(_); end
+
+  def dir=(_); end
+
+  def expire(); end
+
+  def expire=(_); end
+
+  def gecos(); end
+
+  def gecos=(_); end
+
+  def gid=(_); end
+
+  def name=(_); end
+
+  def passwd=(_); end
+
+  def shell=(_); end
+
+  def uclass(); end
+
+  def uclass=(_); end
+
+  def uid=(_); end
+end
+
+class Etc::Passwd
+  extend ::Enumerable
+  def self.[](*_); end
+
+  def self.each(&blk); end
+
+  def self.members(); end
+end
+
+class ExitCalledError
+end
+
+class ExitCalledError
+end
+
+class FalseClass
+  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+end
+
+class Fiber
+  def transfer(*_); end
+end
+
+class Fiber
+  def self.current(); end
+end
+
+class File
+  def self.exists?(_); end
+end
+
+FileList = Rake::FileList
+
+module FileUtils
+  include ::FileUtils::StreamUtils_
+  LN_SUPPORTED = ::T.let(nil, ::T.untyped)
+  RUBY = ::T.let(nil, ::T.untyped)
+end
+
+module FileUtils::DryRun
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils::LowMethods
+end
+
+module FileUtils::DryRun
+  extend ::FileUtils::DryRun
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils::LowMethods
+end
+
+module FileUtils::NoWrite
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils::LowMethods
+end
+
+module FileUtils::NoWrite
+  extend ::FileUtils::NoWrite
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils::LowMethods
+end
+
+module FileUtils::Verbose
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+end
+
+module FileUtils::Verbose
+  extend ::FileUtils::Verbose
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+end
+
+module FileUtils
+  extend ::FileUtils::StreamUtils_
+end
+
+class Float
+  include ::JSON::Ext::Generator::GeneratorMethods::Float
+end
+
+module Forwardable
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Forwardable
+  def self._compile_method(src, file, line); end
+
+  def self._delegator_method(obj, accessor, method, ali); end
+
+  def self._valid_method?(method); end
+
+  def self.debug(); end
+
+  def self.debug=(debug); end
+end
+
+module GC
+  def garbage_collect(*_); end
+end
+
+module GC
+  def self.verify_transient_heap_internal_consistency(); end
+end
+
+module Gem
+  ConfigMap = ::T.let(nil, ::T.untyped)
+  RbConfigPriorities = ::T.let(nil, ::T.untyped)
+  RubyGemsPackageVersion = ::T.let(nil, ::T.untyped)
+  RubyGemsVersion = ::T.let(nil, ::T.untyped)
+  USE_BUNDLER_FOR_GEMDEPS = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::DependencyInstaller
+  def _deprecated_add_found_dependencies(to_do, dependency_list); end
+
+  def _deprecated_gather_dependencies(); end
+
+  def add_found_dependencies(*args, &block); end
+
+  def gather_dependencies(*args, &block); end
+end
+
+class Gem::Exception
+  extend ::Gem::Deprecate
+end
+
+class Gem::Ext::BuildError
+end
+
+class Gem::Ext::BuildError
+end
+
+class Gem::Ext::Builder
+  def self.redirector(); end
+end
+
+class Gem::Ext::ExtConfBuilder
+end
+
+Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
+
+class Gem::Ext::ExtConfBuilder
+  def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil)); end
+
+  def self.get_relative_path(path); end
+end
+
+class Gem::Package::DigestIO
+  def digests(); end
+
+  def initialize(io, digests); end
+
+  def write(data); end
+end
+
+class Gem::Package::DigestIO
+  def self.wrap(io, digests); end
+end
+
+class Gem::Package::FileSource
+  def initialize(path); end
+
+  def path(); end
+
+  def start(); end
+
+  def with_read_io(&block); end
+
+  def with_write_io(&block); end
+end
+
+class Gem::Package::FileSource
+end
+
+class Gem::Package::IOSource
+  def initialize(io); end
+
+  def io(); end
+
+  def path(); end
+
+  def start(); end
+
+  def with_read_io(); end
+
+  def with_write_io(); end
+end
+
+class Gem::Package::IOSource
+end
+
+class Gem::Package::Old
+  def extract_files(destination_dir); end
+
+  def file_list(io); end
+
+  def read_until_dashes(io); end
+
+  def skip_ruby(io); end
+end
+
+class Gem::Package::Old
+end
+
+class Gem::Package::Source
+end
+
+class Gem::Package::Source
+end
+
+class Gem::Package::TarHeader
+  def ==(other); end
+
+  def checksum(); end
+
+  def devmajor(); end
+
+  def devminor(); end
+
+  def empty?(); end
+
+  def gid(); end
+
+  def gname(); end
+
+  def initialize(vals); end
+
+  def linkname(); end
+
+  def magic(); end
+
+  def mode(); end
+
+  def mtime(); end
+
+  def name(); end
+
+  def prefix(); end
+
+  def size(); end
+
+  def typeflag(); end
+
+  def uid(); end
+
+  def uname(); end
+
+  def update_checksum(); end
+
+  def version(); end
+  EMPTY_HEADER = ::T.let(nil, ::T.untyped)
+  FIELDS = ::T.let(nil, ::T.untyped)
+  PACK_FORMAT = ::T.let(nil, ::T.untyped)
+  UNPACK_FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::Package::TarHeader
+  def self.from(stream); end
+
+  def self.strict_oct(str); end
+end
+
+class Gem::Package::TarReader::Entry
+  def bytes_read(); end
+
+  def check_closed(); end
+
+  def close(); end
+
+  def closed?(); end
+
+  def directory?(); end
+
+  def eof?(); end
+
+  def file?(); end
+
+  def full_name(); end
+
+  def getc(); end
+
+  def header(); end
+
+  def initialize(header, io); end
+
+  def length(); end
+
+  def pos(); end
+
+  def read(len=T.unsafe(nil)); end
+
+  def readpartial(maxlen=T.unsafe(nil), outbuf=T.unsafe(nil)); end
+
+  def rewind(); end
+
+  def size(); end
+
+  def symlink?(); end
+end
+
+class Gem::Package::TarReader::Entry
+end
+
+class Gem::Package::TarReader
+  def self.new(io); end
+end
+
+class Gem::Package::TarWriter
+  def self.new(io); end
+end
+
+class Gem::Package
+  def self.new(gem, security_policy=T.unsafe(nil)); end
+end
+
+class Gem::PathSupport
+  def home(); end
+
+  def initialize(env); end
+
+  def path(); end
+
+  def spec_cache_dir(); end
+end
+
+class Gem::RemoteFetcher
+  def correct_for_windows_path(path); end
+
+  def s3_expiration(); end
+
+  def sign_s3_url(uri, expiration=T.unsafe(nil)); end
+  BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::RemoteFetcher::FetchError
+  def initialize(message, uri); end
+
+  def uri(); end
+
+  def uri=(uri); end
+end
+
+class Gem::RemoteFetcher::FetchError
+end
+
+class Gem::RemoteFetcher::UnknownHostError
+end
+
+class Gem::RemoteFetcher::UnknownHostError
+end
+
+class Gem::Request
+  extend ::Gem::UserInteraction
+  extend ::Gem::DefaultUserInteraction
+  extend ::Gem::Text
+end
+
+class Gem::Resolver::ActivationRequest
+  def others_possible?(); end
+end
+
+class Gem::Resolver::CurrentSet
+end
+
+class Gem::Resolver::CurrentSet
+end
+
+Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict
+
+class Gem::Resolver::LocalSpecification
+end
+
+class Gem::Resolver::LocalSpecification
+end
+
+class Gem::Resolver::Molinillo::DependencyGraph::Log
+  def add_edge_no_circular(graph, origin, destination, requirement); end
+
+  def add_vertex(graph, name, payload, root); end
+
+  def delete_edge(graph, origin_name, destination_name, requirement); end
+
+  def detach_vertex_named(graph, name); end
+
+  def each(&blk); end
+
+  def pop!(graph); end
+
+  def reverse_each(); end
+
+  def rewind_to(graph, tag); end
+
+  def set_payload(graph, name, payload); end
+
+  def tag(graph, tag); end
+end
+
+class Gem::Resolver::Molinillo::DependencyGraph::Log
+  extend ::Enumerable
+end
+
+class Gem::RuntimeRequirementNotMetError
+  def suggestion(); end
+
+  def suggestion=(suggestion); end
+end
+
+class Gem::RuntimeRequirementNotMetError
+end
+
+class Gem::Security::Exception
+end
+
+class Gem::Security::Exception
+end
+
+class Gem::Security::KEY_ALGORITHM
+  def d(); end
+
+  def dmp1(); end
+
+  def dmq1(); end
+
+  def e(); end
+
+  def export(*_); end
+
+  def initialize(*_); end
+
+  def iqmp(); end
+
+  def n(); end
+
+  def p(); end
+
+  def params(); end
+
+  def private?(); end
+
+  def private_decrypt(*_); end
+
+  def private_encrypt(*_); end
+
+  def public?(); end
+
+  def public_decrypt(*_); end
+
+  def public_encrypt(*_); end
+
+  def public_key(); end
+
+  def q(); end
+
+  def set_crt_params(_, _1, _2); end
+
+  def set_factors(_, _1); end
+
+  def set_key(_, _1, _2); end
+
+  def sign_pss(*_); end
+
+  def to_der(); end
+
+  def to_pem(*_); end
+
+  def to_s(*_); end
+
+  def to_text(); end
+
+  def verify_pss(*_); end
+  NO_PADDING = ::T.let(nil, ::T.untyped)
+  PKCS1_OAEP_PADDING = ::T.let(nil, ::T.untyped)
+  PKCS1_PADDING = ::T.let(nil, ::T.untyped)
+  SSLV23_PADDING = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::Security::KEY_ALGORITHM
+  def self.generate(*_); end
+end
+
+class Gem::Security::Policy
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def check_cert(signer, issuer, time); end
+
+  def check_chain(chain, time); end
+
+  def check_data(public_key, digest, signature, data); end
+
+  def check_key(signer, key); end
+
+  def check_root(chain, time); end
+
+  def check_trust(chain, digester, trust_dir); end
+
+  def initialize(name, policy=T.unsafe(nil), opt=T.unsafe(nil)); end
+
+  def name(); end
+
+  def only_signed(); end
+
+  def only_signed=(only_signed); end
+
+  def only_trusted(); end
+
+  def only_trusted=(only_trusted); end
+
+  def subject(certificate); end
+
+  def verify(chain, key=T.unsafe(nil), digests=T.unsafe(nil), signatures=T.unsafe(nil), full_name=T.unsafe(nil)); end
+
+  def verify_chain(); end
+
+  def verify_chain=(verify_chain); end
+
+  def verify_data(); end
+
+  def verify_data=(verify_data); end
+
+  def verify_root(); end
+
+  def verify_root=(verify_root); end
+
+  def verify_signatures(spec, digests, signatures); end
+
+  def verify_signer(); end
+
+  def verify_signer=(verify_signer); end
+end
+
+class Gem::Security::Policy
+end
+
+class Gem::Security::Signer
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def cert_chain(); end
+
+  def cert_chain=(cert_chain); end
+
+  def digest_algorithm(); end
+
+  def digest_name(); end
+
+  def extract_name(cert); end
+
+  def initialize(key, cert_chain, passphrase=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def key(); end
+
+  def key=(key); end
+
+  def load_cert_chain(); end
+
+  def options(); end
+
+  def re_sign_key(expiration_length: T.unsafe(nil)); end
+
+  def sign(data); end
+end
+
+class Gem::Security::Signer
+  def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
+end
+
+class Gem::Security::TrustDir
+  def cert_path(certificate); end
+
+  def dir(); end
+
+  def each_certificate(); end
+
+  def initialize(dir, permissions=T.unsafe(nil)); end
+
+  def issuer_of(certificate); end
+
+  def load_certificate(certificate_file); end
+
+  def name_path(name); end
+
+  def trust_cert(certificate); end
+
+  def verify(); end
+end
+
+module Gem::Security
+  def self.alt_name_or_x509_entry(certificate, x509_entry); end
+
+  def self.create_cert(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
+
+  def self.create_cert_email(email, key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
+
+  def self.create_cert_self_signed(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
+
+  def self.create_key(length=T.unsafe(nil), algorithm=T.unsafe(nil)); end
+
+  def self.email_to_name(email_address); end
+
+  def self.re_sign(expired_certificate, private_key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
+
+  def self.reset(); end
+
+  def self.sign(certificate, signing_key, signing_cert, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
+
+  def self.trust_dir(); end
+
+  def self.trusted_certificates(&block); end
+
+  def self.write(pemmable, path, permissions=T.unsafe(nil), passphrase=T.unsafe(nil), cipher=T.unsafe(nil)); end
+end
+
+class Gem::SpecFetcher
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def available_specs(type); end
+
+  def detect(type=T.unsafe(nil)); end
+
+  def initialize(sources=T.unsafe(nil)); end
+
+  def latest_specs(); end
+
+  def prerelease_specs(); end
+
+  def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
+
+  def sources(); end
+
+  def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
+
+  def specs(); end
+
+  def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end
+
+  def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end
+end
+
+class Gem::SpecFetcher
+  def self.fetcher(); end
+
+  def self.fetcher=(fetcher); end
+end
+
+class Gem::Specification
+  include ::Bundler::MatchPlatform
+  include ::Bundler::GemHelpers
+  def to_ruby(); end
+end
+
+class Gem::Specification
+  extend ::Gem::Deprecate
+  extend ::Enumerable
+  def self.add_spec(spec); end
+
+  def self.add_specs(*specs); end
+
+  def self.remove_spec(spec); end
+end
+
+class Gem::SpecificationPolicy
+  def initialize(specification); end
+
+  def packaging(); end
+
+  def packaging=(packaging); end
+
+  def validate(strict=T.unsafe(nil)); end
+
+  def validate_dependencies(); end
+
+  def validate_metadata(); end
+
+  def validate_permissions(); end
+  HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped)
+  LAZY = ::T.let(nil, ::T.untyped)
+  LAZY_PATTERN = ::T.let(nil, ::T.untyped)
+  METADATA_LINK_KEYS = ::T.let(nil, ::T.untyped)
+  SPECIAL_CHARACTERS = ::T.let(nil, ::T.untyped)
+  VALID_NAME_PATTERN = ::T.let(nil, ::T.untyped)
+  VALID_URI_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::SpecificationPolicy
+end
+
+class Gem::StreamUI
+  def _deprecated_debug(statement); end
+end
+
+class Gem::StubSpecification
+  def build_extensions(); end
+
+  def extensions(); end
+
+  def initialize(filename, base_dir, gems_dir, default_gem); end
+
+  def missing_extensions?(); end
+
+  def valid?(); end
+end
+
+class Gem::StubSpecification::StubLine
+  def extensions(); end
+
+  def full_name(); end
+
+  def initialize(data, extensions); end
+
+  def name(); end
+
+  def platform(); end
+
+  def require_paths(); end
+
+  def version(); end
+end
+
+class Gem::StubSpecification
+  def self.default_gemspec_stub(filename, base_dir, gems_dir); end
+
+  def self.gemspec_stub(filename, base_dir, gems_dir); end
+end
+
+class Gem::UninstallError
+  def spec(); end
+
+  def spec=(spec); end
+end
+
+class Gem::UninstallError
+end
+
+Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
+
+Gem::Version::Requirement = Gem::Requirement
+
+module Gem
+  def self.default_gems_use_full_paths?(); end
+
+  def self.remove_unresolved_default_spec(spec); end
+end
+
+class Hash
+  include ::JSON::Ext::Generator::GeneratorMethods::Hash
+end
+
+class Hash
+  def self.try_convert(_); end
+end
+
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+
+module I18n
+  DEFAULT_INTERPOLATION_PATTERNS = ::T.let(nil, ::T.untyped)
+  EMPTY_HASH = ::T.let(nil, ::T.untyped)
+  INTERPOLATION_PATTERN = ::T.let(nil, ::T.untyped)
+  RESERVED_KEYS = ::T.let(nil, ::T.untyped)
+  RESERVED_KEYS_PATTERN = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Backend
+end
+
+module I18n::Backend::Base
+  include ::I18n::Backend::Transliterator
+  def available_locales(); end
+
+  def deep_interpolate(locale, data, values=T.unsafe(nil)); end
+
+  def default(locale, object, subject, options=T.unsafe(nil)); end
+
+  def eager_load!(); end
+
+  def eager_loaded?(); end
+
+  def exists?(locale, key, options=T.unsafe(nil)); end
+
+  def interpolate(locale, subject, values=T.unsafe(nil)); end
+
+  def load_file(filename); end
+
+  def load_json(filename); end
+
+  def load_rb(filename); end
+
+  def load_translations(*filenames); end
+
+  def load_yaml(filename); end
+
+  def load_yml(filename); end
+
+  def localize(locale, object, format=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def pluralization_key(entry, count); end
+
+  def pluralize(locale, entry, count); end
+
+  def reload!(); end
+
+  def resolve(locale, object, subject, options=T.unsafe(nil)); end
+
+  def store_translations(locale, data, options=T.unsafe(nil)); end
+
+  def subtrees?(); end
+
+  def translate(locale, key, options=T.unsafe(nil)); end
+
+  def translate_localization_format(locale, object, format, options); end
+end
+
+module I18n::Backend::Base
+end
+
+module I18n::Backend::Cache
+  def _fetch(cache_key, &block); end
+
+  def cache_key(locale, key, options); end
+
+  def fetch(cache_key, &block); end
+
+  def translate(locale, key, options=T.unsafe(nil)); end
+end
+
+module I18n::Backend::Cache
+end
+
+module I18n::Backend::CacheFile
+  def load_file(filename); end
+
+  def normalized_path(file); end
+
+  def path_roots(); end
+
+  def path_roots=(path_roots); end
+end
+
+module I18n::Backend::CacheFile
+end
+
+module I18n::Backend::Cascade
+  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
+end
+
+module I18n::Backend::Cascade
+end
+
+module I18n::Backend::Fallbacks
+  def exists?(locale, key, options=T.unsafe(nil)); end
+
+  def extract_non_symbol_default!(options); end
+
+  def translate(locale, key, options=T.unsafe(nil)); end
+end
+
+module I18n::Backend::Fallbacks
+end
+
+module I18n::Backend::Flatten
+  def escape_default_separator(key); end
+
+  def find_link(locale, key); end
+
+  def flatten_keys(hash, escape, prev_key=T.unsafe(nil), &block); end
+
+  def flatten_translations(locale, data, escape, subtree); end
+
+  def links(); end
+
+  def normalize_flat_keys(locale, key, scope, separator); end
+
+  def resolve_link(locale, key); end
+
+  def store_link(locale, key, link); end
+  FLATTEN_SEPARATOR = ::T.let(nil, ::T.untyped)
+  SEPARATOR_ESCAPE_CHAR = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Backend::Flatten
+  def self.escape_default_separator(key); end
+
+  def self.normalize_flat_keys(locale, key, scope, separator); end
+end
+
+module I18n::Backend::InterpolationCompiler
+  def compile_all_strings_in(data); end
+
+  def interpolate(locale, string, values); end
+
+  def store_translations(locale, data, options=T.unsafe(nil)); end
+end
+
+module I18n::Backend::InterpolationCompiler::Compiler
+  def compile_if_an_interpolation(string); end
+
+  def compile_interpolation_token(key); end
+
+  def compiled_interpolation_body(str); end
+
+  def direct_key(key); end
+
+  def escape_key_sym(key); end
+
+  def escape_plain_str(str); end
+
+  def handle_interpolation_token(interpolation, matchdata); end
+
+  def interpolate_key(key); end
+
+  def interpolate_or_raise_missing(key); end
+
+  def interpolated_str?(str); end
+
+  def missing_key(key); end
+
+  def nil_key(key); end
+
+  def reserved_key(key); end
+
+  def tokenize(str); end
+  INTERPOLATION_SYNTAX_PATTERN = ::T.let(nil, ::T.untyped)
+  TOKENIZER = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Backend::InterpolationCompiler::Compiler
+  extend ::I18n::Backend::InterpolationCompiler::Compiler
+end
+
+module I18n::Backend::InterpolationCompiler
+end
+
+class I18n::Backend::KeyValue
+  include ::I18n::Backend::KeyValue::Implementation
+  include ::I18n::Backend::Flatten
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Transliterator
+end
+
+module I18n::Backend::KeyValue::Implementation
+  include ::I18n::Backend::Flatten
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Transliterator
+  def available_locales(); end
+
+  def init_translations(); end
+
+  def initialize(store, subtrees=T.unsafe(nil)); end
+
+  def initialized?(); end
+
+  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def pluralize(locale, entry, count); end
+
+  def store(); end
+
+  def store=(store); end
+
+  def store_translations(locale, data, options=T.unsafe(nil)); end
+
+  def subtrees?(); end
+
+  def translations(); end
+end
+
+module I18n::Backend::KeyValue::Implementation
+end
+
+class I18n::Backend::KeyValue::SubtreeProxy
+  def [](key); end
+
+  def has_key?(key); end
+
+  def initialize(master_key, store); end
+
+  def instance_of?(klass); end
+
+  def is_a?(klass); end
+
+  def kind_of?(klass); end
+end
+
+class I18n::Backend::KeyValue::SubtreeProxy
+end
+
+class I18n::Backend::KeyValue
+end
+
+module I18n::Backend::Memoize
+  def available_locales(); end
+
+  def eager_load!(); end
+
+  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def memoized_lookup(); end
+
+  def reload!(); end
+
+  def reset_memoizations!(locale=T.unsafe(nil)); end
+
+  def store_translations(locale, data, options=T.unsafe(nil)); end
+end
+
+module I18n::Backend::Memoize
+end
+
+module I18n::Backend::Metadata
+  def interpolate(locale, entry, values=T.unsafe(nil)); end
+
+  def pluralize(locale, entry, count); end
+
+  def translate(locale, key, options=T.unsafe(nil)); end
+
+  def with_metadata(metadata, &block); end
+end
+
+module I18n::Backend::Metadata
+  def self.included(base); end
+end
+
+module I18n::Backend::Pluralization
+  def pluralize(locale, entry, count); end
+
+  def pluralizer(locale); end
+
+  def pluralizers(); end
+end
+
+module I18n::Backend::Pluralization
+end
+
+class I18n::Backend::Simple
+  include ::I18n::Backend::Simple::Implementation
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Transliterator
+end
+
+module I18n::Backend::Simple::Implementation
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Transliterator
+  def available_locales(); end
+
+  def eager_load!(); end
+
+  def init_translations(); end
+
+  def initialized?(); end
+
+  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def reload!(); end
+
+  def store_translations(locale, data, options=T.unsafe(nil)); end
+
+  def translations(do_init: T.unsafe(nil)); end
+end
+
+module I18n::Backend::Simple::Implementation
+end
+
+class I18n::Backend::Simple
+end
+
+module I18n::Backend::Transliterator
+  def transliterate(locale, string, replacement=T.unsafe(nil)); end
+  DEFAULT_REPLACEMENT_CHAR = ::T.let(nil, ::T.untyped)
+end
+
+class I18n::Backend::Transliterator::HashTransliterator
+  def initialize(rule=T.unsafe(nil)); end
+
+  def transliterate(string, replacement=T.unsafe(nil)); end
+  DEFAULT_APPROXIMATIONS = ::T.let(nil, ::T.untyped)
+end
+
+class I18n::Backend::Transliterator::HashTransliterator
+end
+
+class I18n::Backend::Transliterator::ProcTransliterator
+  def initialize(rule); end
+
+  def transliterate(string, replacement=T.unsafe(nil)); end
+end
+
+class I18n::Backend::Transliterator::ProcTransliterator
+end
+
+module I18n::Backend::Transliterator
+  def self.get(rule=T.unsafe(nil)); end
+end
+
+module I18n::Backend
+end
+
+module I18n::Gettext
+  CONTEXT_SEPARATOR = ::T.let(nil, ::T.untyped)
+  PLURAL_SEPARATOR = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Gettext::Helpers
+  def N_(msgsid); end
+
+  def _(msgid, options=T.unsafe(nil)); end
+
+  def gettext(msgid, options=T.unsafe(nil)); end
+
+  def n_(msgid, msgid_plural, n=T.unsafe(nil)); end
+
+  def ngettext(msgid, msgid_plural, n=T.unsafe(nil)); end
+
+  def np_(msgctxt, msgid, msgid_plural, n=T.unsafe(nil)); end
+
+  def npgettext(msgctxt, msgid, msgid_plural, n=T.unsafe(nil)); end
+
+  def ns_(msgid, msgid_plural, n=T.unsafe(nil), separator=T.unsafe(nil)); end
+
+  def nsgettext(msgid, msgid_plural, n=T.unsafe(nil), separator=T.unsafe(nil)); end
+
+  def p_(msgctxt, msgid); end
+
+  def pgettext(msgctxt, msgid); end
+
+  def s_(msgid, separator=T.unsafe(nil)); end
+
+  def sgettext(msgid, separator=T.unsafe(nil)); end
+end
+
+module I18n::Gettext::Helpers
+end
+
+module I18n::Gettext
+  def self.extract_scope(msgid, separator); end
+
+  def self.plural_keys(*args); end
+end
+
+module I18n::Locale
+end
+
+class I18n::Locale::Fallbacks
+  def [](locale); end
+
+  def compute(tags, include_defaults=T.unsafe(nil), exclude=T.unsafe(nil)); end
+
+  def defaults(); end
+
+  def defaults=(defaults); end
+
+  def initialize(*mappings); end
+
+  def map(mappings); end
+end
+
+class I18n::Locale::Fallbacks
+end
+
+module I18n::Locale::Tag
+  RFC4646_FORMATS = ::T.let(nil, ::T.untyped)
+  RFC4646_SUBTAGS = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Locale::Tag::Parents
+  def parent(); end
+
+  def parents(); end
+
+  def self_and_parents(); end
+end
+
+module I18n::Locale::Tag::Parents
+end
+
+class I18n::Locale::Tag::Rfc4646
+  include ::I18n::Locale::Tag::Parents
+  def to_sym(); end
+end
+
+module I18n::Locale::Tag::Rfc4646::Parser
+  PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module I18n::Locale::Tag::Rfc4646::Parser
+  def self.match(tag); end
+end
+
+class I18n::Locale::Tag::Rfc4646
+  def self.parser(); end
+
+  def self.parser=(parser); end
+
+  def self.tag(tag); end
+end
+
+class I18n::Locale::Tag::Simple
+  include ::I18n::Locale::Tag::Parents
+  def initialize(*tag); end
+
+  def subtags(); end
+
+  def tag(); end
+
+  def to_a(); end
+
+  def to_sym(); end
+end
+
+class I18n::Locale::Tag::Simple
+  def self.tag(tag); end
+end
+
+module I18n::Locale::Tag
+  def self.implementation(); end
+
+  def self.implementation=(implementation); end
+
+  def self.tag(tag); end
+end
+
+module I18n::Locale
+end
+
+class I18n::Middleware
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class I18n::Middleware
+end
+
+module I18n::Tests
+end
+
+module I18n::Tests::Localization
+end
+
+module I18n::Tests::Localization
+  def self.included(base); end
+end
+
+module I18n::Tests
+end
+
+module I18n
+  def self.cache_key_digest(); end
+
+  def self.cache_key_digest=(key_digest); end
+
+  def self.cache_namespace(); end
+
+  def self.cache_namespace=(namespace); end
+
+  def self.cache_store(); end
+
+  def self.cache_store=(store); end
+
+  def self.fallbacks(); end
+
+  def self.fallbacks=(fallbacks); end
+
+  def self.perform_caching?(); end
+end
+
+class IO
+  def nonblock(*_); end
+
+  def nonblock=(nonblock); end
+
+  def nonblock?(); end
+
+  def nread(); end
+
+  def pathconf(_); end
+
+  def ready?(); end
+
+  def wait(*_); end
+
+  def wait_readable(*_); end
+
+  def wait_writable(*_); end
+end
+
+IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
+
+IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
+
+class IPAddr
+  def ==(other); end
+
+  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
+end
+
+class Integer
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+  def to_bn(); end
+  GMP_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class JSON::Ext::Generator::State
+  def self.from_state(_); end
+end
+
+class JSON::Ext::Parser
+  def initialize(*_); end
+end
+
+JSON::Parser = JSON::Ext::Parser
+
+JSON::State = JSON::Ext::Generator::State
+
+JSON::UnparserError = JSON::GeneratorError
+
+module Kernel
+  def itself(); end
+
+  def object_id(); end
+
+  def pretty_inspect(); end
+
+  def then(); end
+
+  def yield_self(); end
+end
+
+module Kernel
+  def self.at_exit(); end
+
+  def self.load(*_); end
+
+  def self.require(_); end
+end
+
+class KeyError
+  include ::DidYouMean::Correctable
+end
+
+class Logger
+  SEV_LABEL = ::T.let(nil, ::T.untyped)
+end
+
+class Logger::Formatter
+  Format = ::T.let(nil, ::T.untyped)
+end
+
+class Logger::LogDevice
+  include ::MonitorMixin
+end
+
+module Logger::Period
+  SiD = ::T.let(nil, ::T.untyped)
+end
+
+module Marshal
+  extend ::ActiveSupport::MarshalWithAutoloading
+end
+
+module MethodSource
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module MethodSource::CodeHelpers::IncompleteExpression
+  GENERIC_REGEXPS = ::T.let(nil, ::T.untyped)
+  RBX_ONLY_REGEXPS = ::T.let(nil, ::T.untyped)
+end
+
+module Minitest::Assertions
+  def _synchronize(); end
+
+  def assert_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_in_epsilon(exp, act, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_instance_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def assert_kind_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def assert_match(matcher, obj, msg=T.unsafe(nil)); end
+
+  def assert_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def assert_output(stdout=T.unsafe(nil), stderr=T.unsafe(nil)); end
+
+  def assert_path_exists(path, msg=T.unsafe(nil)); end
+
+  def assert_predicate(o1, op, msg=T.unsafe(nil)); end
+
+  def assert_respond_to(obj, meth, msg=T.unsafe(nil)); end
+
+  def assert_same(exp, act, msg=T.unsafe(nil)); end
+
+  def assert_send(send_ary, m=T.unsafe(nil)); end
+
+  def assert_silent(); end
+
+  def assert_throws(sym, msg=T.unsafe(nil)); end
+
+  def capture_io(); end
+
+  def capture_subprocess_io(); end
+
+  def diff(exp, act); end
+
+  def exception_details(e, msg); end
+
+  def fail_after(y, m, d, msg); end
+
+  def flunk(msg=T.unsafe(nil)); end
+
+  def message(msg=T.unsafe(nil), ending=T.unsafe(nil), &default); end
+
+  def mu_pp(obj); end
+
+  def mu_pp_for_diff(obj); end
+
+  def pass(_msg=T.unsafe(nil)); end
+
+  def refute_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def refute_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def refute_instance_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def refute_kind_of(cls, obj, msg=T.unsafe(nil)); end
+
+  def refute_match(matcher, obj, msg=T.unsafe(nil)); end
+
+  def refute_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
+
+  def refute_path_exists(path, msg=T.unsafe(nil)); end
+
+  def refute_predicate(o1, op, msg=T.unsafe(nil)); end
+
+  def refute_respond_to(obj, meth, msg=T.unsafe(nil)); end
+
+  def refute_same(exp, act, msg=T.unsafe(nil)); end
+
+  def skip(msg=T.unsafe(nil), bt=T.unsafe(nil)); end
+
+  def skip_until(y, m, d, msg); end
+
+  def skipped?(); end
+
+  def things_to_diff(exp, act); end
+  E = ::T.let(nil, ::T.untyped)
+  UNDEFINED = ::T.let(nil, ::T.untyped)
+end
+
+module Minitest::Assertions
+  def self.diff(); end
+
+  def self.diff=(o); end
+end
+
+module Minitest::Guard
+  def jruby?(platform=T.unsafe(nil)); end
+
+  def maglev?(platform=T.unsafe(nil)); end
+
+  def mri?(platform=T.unsafe(nil)); end
+
+  def osx?(platform=T.unsafe(nil)); end
+
+  def rubinius?(platform=T.unsafe(nil)); end
+
+  def windows?(platform=T.unsafe(nil)); end
+end
+
+module Minitest::Guard
+end
+
+module Minitest::Reportable
+  def class_name(); end
+
+  def error?(); end
+
+  def location(); end
+
+  def passed?(); end
+
+  def result_code(); end
+
+  def skipped?(); end
+end
+
+module Minitest::Reportable
+end
+
+class Minitest::Runnable
+  def assertions(); end
+
+  def assertions=(assertions); end
+
+  def failure(); end
+
+  def failures(); end
+
+  def failures=(failures); end
+
+  def initialize(name); end
+
+  def marshal_dump(); end
+
+  def marshal_load(ary); end
+
+  def name(); end
+
+  def name=(o); end
+
+  def passed?(); end
+
+  def result_code(); end
+
+  def run(); end
+
+  def skipped?(); end
+
+  def time(); end
+
+  def time=(time); end
+
+  def time_it(); end
+  SIGNALS = ::T.let(nil, ::T.untyped)
+end
+
+class Minitest::Runnable
+  def self.inherited(klass); end
+
+  def self.methods_matching(re); end
+
+  def self.on_signal(name, action); end
+
+  def self.reset(); end
+
+  def self.run(reporter, options=T.unsafe(nil)); end
+
+  def self.run_one_method(klass, method_name, reporter); end
+
+  def self.runnable_methods(); end
+
+  def self.runnables(); end
+
+  def self.with_info_handler(reporter, &block); end
+end
+
+class Minitest::Test
+  include ::Minitest::Reportable
+  include ::Minitest::Test::LifecycleHooks
+  include ::Minitest::Guard
+  def capture_exceptions(); end
+
+  def with_info_handler(&block); end
+  PASSTHROUGH_EXCEPTIONS = ::T.let(nil, ::T.untyped)
+  TEARDOWN_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module Minitest::Test::LifecycleHooks
+  def after_setup(); end
+
+  def after_teardown(); end
+
+  def before_setup(); end
+
+  def before_teardown(); end
+
+  def setup(); end
+
+  def teardown(); end
+end
+
+module Minitest::Test::LifecycleHooks
+end
+
+class Minitest::Test
+  extend ::Minitest::Guard
+  def self.i_suck_and_my_tests_are_order_dependent!(); end
+
+  def self.io_lock(); end
+
+  def self.io_lock=(io_lock); end
+
+  def self.make_my_diffs_pretty!(); end
+
+  def self.parallelize_me!(); end
+
+  def self.test_order(); end
+end
+
+class Module
+  DELEGATION_RESERVED_KEYWORDS = ::T.let(nil, ::T.untyped)
+  DELEGATION_RESERVED_METHOD_NAMES = ::T.let(nil, ::T.untyped)
+  RUBY_RESERVED_KEYWORDS = ::T.let(nil, ::T.untyped)
+end
+
+class Monitor
+  def enter(); end
+
+  def exit(); end
+
+  def try_enter(); end
+end
+
+module MonitorMixin
+  def initialize(*args); end
+  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
+  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
+end
+
+class MonitorMixin::ConditionVariable
+  def initialize(monitor); end
+end
+
+module Mutex_m
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class NameError
+  include ::DidYouMean::Correctable
+end
+
+class NilClass
+  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+  def to_d(); end
+end
+
+class Object
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::TappingDevice::Trackable
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  def html_safe?(); end
+
+  def to_yaml(options=T.unsafe(nil)); end
+  ARGF = ::T.let(nil, ::T.untyped)
+  ARGV = ::T.let(nil, ::T.untyped)
+  CROSS_COMPILING = ::T.let(nil, ::T.untyped)
+  ENV = ::T.let(nil, ::T.untyped)
+  RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
+  RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
+  RUBY_ENGINE = ::T.let(nil, ::T.untyped)
+  RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
+  RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
+  RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
+  RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped)
+  RUBY_REVISION = ::T.let(nil, ::T.untyped)
+  RUBY_VERSION = ::T.let(nil, ::T.untyped)
+  STDERR = ::T.let(nil, ::T.untyped)
+  STDIN = ::T.let(nil, ::T.untyped)
+  STDOUT = ::T.let(nil, ::T.untyped)
+  TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
+end
+
+class Object
+  def self.yaml_tag(url); end
+end
+
+module Pastel
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Pastel::ANSI
+  ATTRIBUTES = ::T.let(nil, ::T.untyped)
+end
+
+class Pastel::Color
+  ALIASES = ::T.let(nil, ::T.untyped)
+  ANSI_COLOR_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+class Pastel::ColorParser
+  CSI = ::T.let(nil, ::T.untyped)
+  ESC = ::T.let(nil, ::T.untyped)
+end
+
+class Pathname
+  def fnmatch?(*_); end
+
+  def glob(*_); end
+
+  def make_symlink(_); end
+end
+
+class Post
+  include ::Post::GeneratedAttributeMethods
+  include ::Post::GeneratedAssociationMethods
+  def after_add_for_comments(); end
+
+  def after_add_for_comments=(val); end
+
+  def after_add_for_comments?(); end
+
+  def after_remove_for_comments(); end
+
+  def after_remove_for_comments=(val); end
+
+  def after_remove_for_comments?(); end
+
+  def autosave_associated_records_for_comments(*args); end
+
+  def autosave_associated_records_for_user(*args); end
+
+  def before_add_for_comments(); end
+
+  def before_add_for_comments=(val); end
+
+  def before_add_for_comments?(); end
+
+  def before_remove_for_comments(); end
+
+  def before_remove_for_comments=(val); end
+
+  def before_remove_for_comments?(); end
+
+  def validate_associated_records_for_comments(*args); end
+end
+
+module Post::GeneratedAssociationMethods
+  def build_user(*args, &block); end
+
+  def comment_ids(); end
+
+  def comment_ids=(ids); end
+
+  def comments(); end
+
+  def comments=(value); end
+
+  def create_user(*args, &block); end
+
+  def create_user!(*args, &block); end
+
+  def reload_user(); end
+
+  def user(); end
+
+  def user=(value); end
+end
+
+module Post::GeneratedAssociationMethods
+end
+
+module Post::GeneratedAttributeMethods
+end
+
+module Post::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+class Post
+  def self.after_add_for_comments(); end
+
+  def self.after_add_for_comments=(val); end
+
+  def self.after_add_for_comments?(); end
+
+  def self.after_remove_for_comments(); end
+
+  def self.after_remove_for_comments=(val); end
+
+  def self.after_remove_for_comments?(); end
+
+  def self.before_add_for_comments(); end
+
+  def self.before_add_for_comments=(val); end
+
+  def self.before_add_for_comments?(); end
+
+  def self.before_remove_for_comments(); end
+
+  def self.before_remove_for_comments=(val); end
+
+  def self.before_remove_for_comments?(); end
+end
+
+class Proc
+  def <<(_); end
+
+  def >>(_); end
+
+  def clone(); end
+end
+
+class Pry
+  BINDING_METHOD_IMPL = ::T.let(nil, ::T.untyped)
+  Commands = ::T.let(nil, ::T.untyped)
+  EMPTY_COMPLETIONS = ::T.let(nil, ::T.untyped)
+  HAS_SAFE_LEVEL = ::T.let(nil, ::T.untyped)
+  LOCAL_RC_FILE = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::BasicObject
+  ENV = ::T.let(nil, ::T.untyped)
+end
+
+Pry::BasicObject::Dir = Dir
+
+Pry::BasicObject::File = File
+
+Pry::BasicObject::Kernel = Kernel
+
+Pry::BasicObject::LoadError = LoadError
+
+Pry::BasicObject::Pry = Pry
+
+class Pry::Code
+  extend ::MethodSource::CodeHelpers
+end
+
+class Pry::CodeFile
+  DEFAULT_EXT = ::T.let(nil, ::T.untyped)
+  EXTENSIONS = ::T.let(nil, ::T.untyped)
+  FILES = ::T.let(nil, ::T.untyped)
+  INITIAL_PWD = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Command
+  VOID_VALUE = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Command::Ls
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Command::Ls::Constants
+  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Command::Ls::Globals
+  BUILTIN_GLOBALS = ::T.let(nil, ::T.untyped)
+  PSEUDO_GLOBALS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Command::Wtf
+  RUBY_FRAME_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+module Pry::Helpers::DocumentationHelpers
+  YARD_TAGS = ::T.let(nil, ::T.untyped)
+end
+
+module Pry::Helpers::Text
+  COLORS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Indent
+  IGNORE_TOKENS = ::T.let(nil, ::T.untyped)
+  MIDWAY_TOKENS = ::T.let(nil, ::T.untyped)
+  OPEN_TOKENS = ::T.let(nil, ::T.untyped)
+  OPTIONAL_DO_TOKENS = ::T.let(nil, ::T.untyped)
+  SINGLELINE_TOKENS = ::T.let(nil, ::T.untyped)
+  SPACES = ::T.let(nil, ::T.untyped)
+  STATEMENT_END_TOKENS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::InputCompleter
+  ARRAY_REGEXP = ::T.let(nil, ::T.untyped)
+  CONSTANT_OR_METHOD_REGEXP = ::T.let(nil, ::T.untyped)
+  CONSTANT_REGEXP = ::T.let(nil, ::T.untyped)
+  GLOBALVARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
+  HEX_REGEXP = ::T.let(nil, ::T.untyped)
+  NUMERIC_REGEXP = ::T.let(nil, ::T.untyped)
+  PROC_OR_HASH_REGEXP = ::T.let(nil, ::T.untyped)
+  REGEX_REGEXP = ::T.let(nil, ::T.untyped)
+  RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+  SYMBOL_METHOD_CALL_REGEXP = ::T.let(nil, ::T.untyped)
+  SYMBOL_REGEXP = ::T.let(nil, ::T.untyped)
+  TOPLEVEL_LOOKUP_REGEXP = ::T.let(nil, ::T.untyped)
+  VARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
+  WORD_ESCAPE_STR = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Inspector
+  MAP = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::ObjectPath
+  SPECIAL_TERMS = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Output
+  DEFAULT_SIZE = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::PluginManager
+  PRY_PLUGIN_PREFIX = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Slop
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Pry::Slop::Option
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+module Psych
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Psych
+  def self.add_builtin_type(type_tag, &block); end
+
+  def self.add_domain_type(domain, type_tag, &block); end
+
+  def self.add_tag(tag, klass); end
+
+  def self.domain_types(); end
+
+  def self.domain_types=(domain_types); end
+
+  def self.dump_tags(); end
+
+  def self.dump_tags=(dump_tags); end
+
+  def self.libyaml_version(); end
+
+  def self.load_tags(); end
+
+  def self.load_tags=(load_tags); end
+
+  def self.remove_type(type_tag); end
+end
+
+module RSpec
+  MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::CallerFilter
+  ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
+  IGNORE_REGEX = ::T.let(nil, ::T.untyped)
+  LIB_REGEX = ::T.let(nil, ::T.untyped)
+  RSPEC_LIBS = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Configuration
+  DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
+  FAILED_STATUS = ::T.let(nil, ::T.untyped)
+  MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
+  PASSED_STATUS = ::T.let(nil, ::T.untyped)
+  PENDING_STATUS = ::T.let(nil, ::T.untyped)
+  RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
+  UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
+  VALID_STATUSES = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::ConfigurationOptions
+  OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
+  UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
+  UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+
+class RSpec::Core::ExampleGroup
+  INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
+
+class RSpec::Core::FilterRules
+  PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
+  PROJECT_DIR = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::BaseBisectFormatter
+  def example_failed(notification); end
+
+  def example_finished(notification); end
+
+  def initialize(expected_failures); end
+
+  def start_dump(_notification); end
+end
+
+class RSpec::Core::Formatters::BaseBisectFormatter
+  def self.inherited(formatter); end
+end
+
+class RSpec::Core::Formatters::BaseFormatter
+  def close(_notification); end
+
+  def example_group(); end
+
+  def example_group=(example_group); end
+
+  def example_group_started(notification); end
+
+  def initialize(output); end
+
+  def output(); end
+
+  def start(notification); end
+end
+
+class RSpec::Core::Formatters::BaseFormatter
+end
+
+class RSpec::Core::Formatters::BaseTextFormatter
+  def dump_failures(notification); end
+
+  def dump_pending(notification); end
+
+  def dump_summary(summary); end
+
+  def message(notification); end
+
+  def seed(notification); end
+end
+
+class RSpec::Core::Formatters::BaseTextFormatter
+end
+
+class RSpec::Core::Formatters::BisectDRbFormatter
+  def initialize(_output); end
+
+  def notify_results(results); end
+end
+
+class RSpec::Core::Formatters::BisectDRbFormatter
+end
+
+module RSpec::Core::Formatters::ConsoleCodes
+  VT100_CODES = ::T.let(nil, ::T.untyped)
+  VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter
+  DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
+  RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
+  TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
+  TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::DocumentationFormatter
+  def example_failed(failure); end
+
+  def example_group_finished(_notification); end
+
+  def example_passed(passed); end
+
+  def example_pending(pending); end
+end
+
+class RSpec::Core::Formatters::DocumentationFormatter
+end
+
+class RSpec::Core::Formatters::ExceptionPresenter
+  PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::FallbackMessageFormatter
+  def initialize(output); end
+
+  def message(notification); end
+
+  def output(); end
+end
+
+class RSpec::Core::Formatters::FallbackMessageFormatter
+end
+
+module RSpec::Core::Formatters::Helpers
+  DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
+  SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Formatters::HtmlFormatter
+  def dump_summary(summary); end
+
+  def example_failed(failure); end
+
+  def example_passed(passed); end
+
+  def example_pending(pending); end
+
+  def example_started(_notification); end
+
+  def start_dump(_notification); end
+end
+
+class RSpec::Core::Formatters::HtmlFormatter
+end
+
+class RSpec::Core::Formatters::JsonFormatter
+  def dump_profile(profile); end
+
+  def dump_profile_slowest_example_groups(profile); end
+
+  def dump_profile_slowest_examples(profile); end
+
+  def dump_summary(summary); end
+
+  def message(notification); end
+
+  def output_hash(); end
+
+  def seed(notification); end
+
+  def stop(notification); end
+end
+
+class RSpec::Core::Formatters::JsonFormatter
+end
+
+class RSpec::Core::Formatters::ProfileFormatter
+  def dump_profile(profile); end
+
+  def initialize(output); end
+
+  def output(); end
+end
+
+class RSpec::Core::Formatters::ProfileFormatter
+end
+
+class RSpec::Core::Formatters::ProgressFormatter
+  def example_failed(_notification); end
+
+  def example_passed(_notification); end
+
+  def example_pending(_notification); end
+
+  def start_dump(_notification); end
+end
+
+class RSpec::Core::Formatters::ProgressFormatter
+end
+
+module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
+  RESET_CODE = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+
+class RSpec::Core::Hooks::HookCollections
+  EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
+  HOOK_TYPES = ::T.let(nil, ::T.untyped)
+  SCOPES = ::T.let(nil, ::T.untyped)
+  SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Core::Metadata
+  RESERVED_KEYS = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Ordering::Random
+  MAX_32_BIT = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Core::Pending
+  NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
+  NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Profiler
+  NOTIFICATIONS = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Core::Reporter
+  RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Core::ShellEscape
+  SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Core::Version
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Expectations::Configuration
+  FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
+
+module RSpec::Expectations::Version
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Matchers
+  def write_to_file(*expected, &block_arg); end
+  BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped)
+  DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped)
+  HAS_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+class RSpec::Matchers::BuiltIn::BaseMatcher
+  UNDEFINED = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Matchers::BuiltIn::Equal
+  LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
+
+RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
+
+module RSpec::Matchers::DSL::Macros
+  RAISE_NOTIFIER = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Matchers::ExpectedsForMultipleDiffs
+  DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped)
+  DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Mocks
+  DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped)
+  IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::AnyInstance::PositiveExpectationChain
+  ExpectationInvocationOrder = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::AnyInstance::Recorder
+  include ::T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions
+end
+
+class RSpec::Mocks::AnyInstance::StubChain
+  EmptyInvocationOrder = ::T.let(nil, ::T.untyped)
+  InvocationOrder = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::ArgumentListMatcher
+  MATCH_ALL = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher
+  INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher
+  INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::ArgumentMatchers::BooleanMatcher
+  INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher
+  INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::Matchers::HaveReceived
+  ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped)
+  CONSTRAINTS = ::T.let(nil, ::T.untyped)
+  COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::MethodDouble
+  include ::T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions
+end
+
+class RSpec::Mocks::ObjectReference
+  MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Mocks::Proxy
+  DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Mocks::Version
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Support
+  DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped)
+  DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
+  KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+  AVOID_RESCUING = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Support::Differ
+  def color?(); end
+
+  def diff(actual, expected); end
+
+  def diff_as_object(actual, expected); end
+
+  def diff_as_string(actual, expected); end
+
+  def initialize(opts=T.unsafe(nil)); end
+end
+
+class RSpec::Support::Differ
+end
+
+class RSpec::Support::EncodedString
+  ENCODE_NO_CONVERTER = ::T.let(nil, ::T.untyped)
+  ENCODE_UNCONVERTABLE_BYTES = ::T.let(nil, ::T.untyped)
+  REPLACE = ::T.let(nil, ::T.untyped)
+  US_ASCII = ::T.let(nil, ::T.untyped)
+  UTF_8 = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Support::MethodSignature
+  INFINITY = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Support::Mutex = Thread::Mutex
+
+class RSpec::Support::ObjectFormatter
+  ELLIPSIS = ::T.let(nil, ::T.untyped)
+  INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Support::ObjectFormatter::DateTimeInspector
+  FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Support::ObjectFormatter::TimeInspector
+  FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class RSpec::Support::ObjectFormatter::UninspectableObjectInspector
+  OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
+
+module RSpec::Support::Version
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+module RSpec::Version
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+module Rake
+  EARLY = ::T.let(nil, ::T.untyped)
+  EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped)
+  LATE = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Application
+  DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::Backtrace
+  SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped)
+  SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped)
+  SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped)
+  SYS_KEYS = ::T.let(nil, ::T.untyped)
+  SYS_PATHS = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::DSL
+  include ::FileUtils::StreamUtils_
+end
+
+class Rake::FileList
+  ARRAY_METHODS = ::T.let(nil, ::T.untyped)
+  DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped)
+  DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped)
+  DELEGATING_METHODS = ::T.let(nil, ::T.untyped)
+  GLOB_PATTERN = ::T.let(nil, ::T.untyped)
+  MUST_DEFINE = ::T.let(nil, ::T.untyped)
+  MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped)
+  SPECIAL_RETURN = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::FileUtilsExt
+  include ::FileUtils::StreamUtils_
+  DEFAULT = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::FileUtilsExt
+  extend ::FileUtils::StreamUtils_
+end
+
+class Rake::InvocationChain
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::LinkedList
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Promise
+  NOT_SET = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Scope
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::Version
+  BUILD = ::T.let(nil, ::T.untyped)
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  NUMBERS = ::T.let(nil, ::T.untyped)
+  OTHER = ::T.let(nil, ::T.untyped)
+end
+
+module Rake
+  extend ::FileUtils::StreamUtils_
+end
+
+RakeFileUtils = Rake::FileUtilsExt
+
+class Random
+  def self.bytes(_); end
+end
+
+class Range
+  include ::ActiveSupport::RangeWithFormat
+  include ::ActiveSupport::CompareWithRange
+  include ::ActiveSupport::IncludeTimeWithZone
+  include ::ActiveSupport::EachTimeWithZone
+  def %(_); end
+
+  def entries(); end
+
+  def to_a(); end
+end
+
+module RbConfig
+  def self.expand(val, config=T.unsafe(nil)); end
+
+  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+
+  def self.ruby(); end
+end
+
+module RubyVM::AbstractSyntaxTree
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+  def children(); end
+
+  def first_column(); end
+
+  def first_lineno(); end
+
+  def last_column(); end
+
+  def last_lineno(); end
+
+  def pretty_print_children(q, names=T.unsafe(nil)); end
+
+  def type(); end
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+end
+
+module RubyVM::AbstractSyntaxTree
+  def self.of(_); end
+
+  def self.parse(_); end
+
+  def self.parse_file(_); end
+end
+
+module RubyVM::MJIT
+end
+
+module RubyVM::MJIT
+  def self.enabled?(); end
+
+  def self.pause(*_); end
+
+  def self.resume(); end
+end
+
+class RubyVM
+  def self.resolve_feature_path(_); end
+end
+
+module SQLite3
+  SQLITE_VERSION = ::T.let(nil, ::T.untyped)
+  SQLITE_VERSION_NUMBER = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class SQLite3::Blob
+end
+
+class SQLite3::Blob
+end
+
+module SQLite3::Constants::ColumnType
+  BLOB = ::T.let(nil, ::T.untyped)
+  FLOAT = ::T.let(nil, ::T.untyped)
+  INTEGER = ::T.let(nil, ::T.untyped)
+  NULL = ::T.let(nil, ::T.untyped)
+  TEXT = ::T.let(nil, ::T.untyped)
+end
+
+module SQLite3::Constants::ErrorCode
+  ABORT = ::T.let(nil, ::T.untyped)
+  AUTH = ::T.let(nil, ::T.untyped)
+  BUSY = ::T.let(nil, ::T.untyped)
+  CANTOPEN = ::T.let(nil, ::T.untyped)
+  CONSTRAINT = ::T.let(nil, ::T.untyped)
+  CORRUPT = ::T.let(nil, ::T.untyped)
+  DONE = ::T.let(nil, ::T.untyped)
+  EMPTY = ::T.let(nil, ::T.untyped)
+  ERROR = ::T.let(nil, ::T.untyped)
+  FULL = ::T.let(nil, ::T.untyped)
+  INTERNAL = ::T.let(nil, ::T.untyped)
+  INTERRUPT = ::T.let(nil, ::T.untyped)
+  IOERR = ::T.let(nil, ::T.untyped)
+  LOCKED = ::T.let(nil, ::T.untyped)
+  MISMATCH = ::T.let(nil, ::T.untyped)
+  MISUSE = ::T.let(nil, ::T.untyped)
+  NOLFS = ::T.let(nil, ::T.untyped)
+  NOMEM = ::T.let(nil, ::T.untyped)
+  NOTFOUND = ::T.let(nil, ::T.untyped)
+  OK = ::T.let(nil, ::T.untyped)
+  PERM = ::T.let(nil, ::T.untyped)
+  PROTOCOL = ::T.let(nil, ::T.untyped)
+  READONLY = ::T.let(nil, ::T.untyped)
+  ROW = ::T.let(nil, ::T.untyped)
+  SCHEMA = ::T.let(nil, ::T.untyped)
+  TOOBIG = ::T.let(nil, ::T.untyped)
+end
+
+module SQLite3::Constants::Open
+  AUTOPROXY = ::T.let(nil, ::T.untyped)
+  CREATE = ::T.let(nil, ::T.untyped)
+  DELETEONCLOSE = ::T.let(nil, ::T.untyped)
+  EXCLUSIVE = ::T.let(nil, ::T.untyped)
+  FULLMUTEX = ::T.let(nil, ::T.untyped)
+  MAIN_DB = ::T.let(nil, ::T.untyped)
+  MAIN_JOURNAL = ::T.let(nil, ::T.untyped)
+  MASTER_JOURNAL = ::T.let(nil, ::T.untyped)
+  MEMORY = ::T.let(nil, ::T.untyped)
+  NOMUTEX = ::T.let(nil, ::T.untyped)
+  PRIVATECACHE = ::T.let(nil, ::T.untyped)
+  READONLY = ::T.let(nil, ::T.untyped)
+  READWRITE = ::T.let(nil, ::T.untyped)
+  SHAREDCACHE = ::T.let(nil, ::T.untyped)
+  SUBJOURNAL = ::T.let(nil, ::T.untyped)
+  TEMP_DB = ::T.let(nil, ::T.untyped)
+  TEMP_JOURNAL = ::T.let(nil, ::T.untyped)
+  TRANSIENT_DB = ::T.let(nil, ::T.untyped)
+  URI = ::T.let(nil, ::T.untyped)
+  WAL = ::T.let(nil, ::T.untyped)
+end
+
+module SQLite3::Constants::Open
+end
+
+module SQLite3::Constants::TextRep
+  ANY = ::T.let(nil, ::T.untyped)
+  DETERMINISTIC = ::T.let(nil, ::T.untyped)
+  UTF16 = ::T.let(nil, ::T.untyped)
+  UTF16BE = ::T.let(nil, ::T.untyped)
+  UTF16LE = ::T.let(nil, ::T.untyped)
+  UTF8 = ::T.let(nil, ::T.untyped)
+end
+
+class SQLite3::Database
+  NULL_TRANSLATOR = ::T.let(nil, ::T.untyped)
+end
+
+module SQLite3::Pragmas
+  AUTO_VACUUM_MODES = ::T.let(nil, ::T.untyped)
+  ENCODINGS = ::T.let(nil, ::T.untyped)
+  JOURNAL_MODES = ::T.let(nil, ::T.untyped)
+  LOCKING_MODES = ::T.let(nil, ::T.untyped)
+  SYNCHRONOUS_MODES = ::T.let(nil, ::T.untyped)
+  TEMP_STORE_MODES = ::T.let(nil, ::T.untyped)
+  WAL_CHECKPOINTS = ::T.let(nil, ::T.untyped)
+end
+
+module SQLite3::VersionProxy
+  BUILD = ::T.let(nil, ::T.untyped)
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  STRING = ::T.let(nil, ::T.untyped)
+  TINY = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+ScanError = StringScanner::Error
+
+class Set
+  def ==(other); end
+
+  def ===(o); end
+
+  def compare_by_identity(); end
+
+  def compare_by_identity?(); end
+
+  def divide(&func); end
+
+  def eql?(o); end
+
+  def flatten_merge(set, seen=T.unsafe(nil)); end
+
+  def pretty_print(pp); end
+
+  def pretty_print_cycle(pp); end
+
+  def reset(); end
+  InspectKey = ::T.let(nil, ::T.untyped)
+end
+
+module SimpleCov
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module SimpleCov::ExitCodes
+  EXCEPTION = ::T.let(nil, ::T.untyped)
+  MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped)
+  MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped)
+  SUCCESS = ::T.let(nil, ::T.untyped)
+end
+
+class SimpleCov::Formatter::HTMLFormatter
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class SimpleCov::LinesClassifier
+  COMMENT_LINE = ::T.let(nil, ::T.untyped)
+  NOT_RELEVANT = ::T.let(nil, ::T.untyped)
+  RELEVANT = ::T.let(nil, ::T.untyped)
+  WHITESPACE_LINE = ::T.let(nil, ::T.untyped)
+  WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped)
+end
+
+module Singleton
+  def _dump(depth=T.unsafe(nil)); end
+
+  def clone(); end
+
+  def dup(); end
+end
+
+module Singleton::SingletonClassMethods
+  def _load(str); end
+
+  def clone(); end
+end
+
+module Singleton
+  def self.__init__(klass); end
+end
+
+class SortedSet
+  def initialize(*args, &block); end
+end
+
+class SortedSet
+  def self.setup(); end
+end
+
+class String
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  def shellescape(); end
+
+  def shellsplit(); end
+  BLANK_RE = ::T.let(nil, ::T.untyped)
+  ENCODED_BLANKS = ::T.let(nil, ::T.untyped)
+end
+
+class StringScanner
+  def bol?(); end
+
+  def initialize(*_); end
+  Id = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
+end
+
+class Struct
+  def filter(*_); end
+end
+
+Struct::Group = Etc::Group
+
+Struct::Passwd = Etc::Passwd
+
+Struct::Tms = Process::Tms
+
+module TTY::Color
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class TTY::Color::Mode
+  METHODS = ::T.let(nil, ::T.untyped)
+  TERM_16 = ::T.let(nil, ::T.untyped)
+  TERM_256 = ::T.let(nil, ::T.untyped)
+  TERM_52 = ::T.let(nil, ::T.untyped)
+  TERM_64 = ::T.let(nil, ::T.untyped)
+  TERM_8 = ::T.let(nil, ::T.untyped)
+end
+
+class TTY::Color::Support
+  ENV_VARS = ::T.let(nil, ::T.untyped)
+  SOURCES = ::T.let(nil, ::T.untyped)
+end
+
+module TZInfo::RubyCoreSupport
+  HALF_DAYS_IN_DAY = ::T.let(nil, ::T.untyped)
+end
+
+class TZInfo::ZoneinfoDataSource
+  DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = ::T.let(nil, ::T.untyped)
+  DEFAULT_SEARCH_PATH = ::T.let(nil, ::T.untyped)
+end
+
+class TZInfo::ZoneinfoTimezoneInfo
+  MAX_TIMESTAMP = ::T.let(nil, ::T.untyped)
+  MIN_TIMESTAMP = ::T.let(nil, ::T.untyped)
+end
+
+class TappingDevice
+  include ::ActiveSupport::Configurable
+end
+
+class TappingDevice::Output::Payload
+  def arguments_and_defined_class(options=T.unsafe(nil)); end
+
+  def arguments_and_defined_class_with_color(options=T.unsafe(nil)); end
+
+  def arguments_and_ivar_changes(options=T.unsafe(nil)); end
+
+  def arguments_and_ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def arguments_and_location(options=T.unsafe(nil)); end
+
+  def arguments_and_location_with_color(options=T.unsafe(nil)); end
+
+  def arguments_and_method_name(options=T.unsafe(nil)); end
+
+  def arguments_and_method_name_with_color(options=T.unsafe(nil)); end
+
+  def arguments_and_return_value(options=T.unsafe(nil)); end
+
+  def arguments_and_return_value_with_color(options=T.unsafe(nil)); end
+
+  def arguments_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_and_arguments(options=T.unsafe(nil)); end
+
+  def defined_class_and_arguments_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_and_ivar_changes(options=T.unsafe(nil)); end
+
+  def defined_class_and_ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_and_location(options=T.unsafe(nil)); end
+
+  def defined_class_and_location_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_and_method_name(options=T.unsafe(nil)); end
+
+  def defined_class_and_method_name_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_and_return_value(options=T.unsafe(nil)); end
+
+  def defined_class_and_return_value_with_color(options=T.unsafe(nil)); end
+
+  def defined_class_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_arguments(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_arguments_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_defined_class(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_defined_class_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_location(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_location_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_method_name(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_method_name_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_return_value(options=T.unsafe(nil)); end
+
+  def ivar_changes_and_return_value_with_color(options=T.unsafe(nil)); end
+
+  def ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def location_and_arguments(options=T.unsafe(nil)); end
+
+  def location_and_arguments_with_color(options=T.unsafe(nil)); end
+
+  def location_and_defined_class(options=T.unsafe(nil)); end
+
+  def location_and_defined_class_with_color(options=T.unsafe(nil)); end
+
+  def location_and_ivar_changes(options=T.unsafe(nil)); end
+
+  def location_and_ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def location_and_method_name(options=T.unsafe(nil)); end
+
+  def location_and_method_name_with_color(options=T.unsafe(nil)); end
+
+  def location_and_return_value(options=T.unsafe(nil)); end
+
+  def location_and_return_value_with_color(options=T.unsafe(nil)); end
+
+  def location_with_color(options=T.unsafe(nil)); end
+
+  def method_name_and_arguments(options=T.unsafe(nil)); end
+
+  def method_name_and_arguments_with_color(options=T.unsafe(nil)); end
+
+  def method_name_and_defined_class(options=T.unsafe(nil)); end
+
+  def method_name_and_defined_class_with_color(options=T.unsafe(nil)); end
+
+  def method_name_and_ivar_changes(options=T.unsafe(nil)); end
+
+  def method_name_and_ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def method_name_and_location(options=T.unsafe(nil)); end
+
+  def method_name_and_location_with_color(options=T.unsafe(nil)); end
+
+  def method_name_and_return_value(options=T.unsafe(nil)); end
+
+  def method_name_and_return_value_with_color(options=T.unsafe(nil)); end
+
+  def method_name_with_color(options=T.unsafe(nil)); end
+
+  def original_arguments(options=T.unsafe(nil)); end
+
+  def original_defined_class(options=T.unsafe(nil)); end
+
+  def original_ivar_changes(options=T.unsafe(nil)); end
+
+  def original_location(options=T.unsafe(nil)); end
+
+  def original_method_name(options=T.unsafe(nil)); end
+
+  def original_return_value(options=T.unsafe(nil)); end
+
+  def return_value_and_arguments(options=T.unsafe(nil)); end
+
+  def return_value_and_arguments_with_color(options=T.unsafe(nil)); end
+
+  def return_value_and_defined_class(options=T.unsafe(nil)); end
+
+  def return_value_and_defined_class_with_color(options=T.unsafe(nil)); end
+
+  def return_value_and_ivar_changes(options=T.unsafe(nil)); end
+
+  def return_value_and_ivar_changes_with_color(options=T.unsafe(nil)); end
+
+  def return_value_and_location(options=T.unsafe(nil)); end
+
+  def return_value_and_location_with_color(options=T.unsafe(nil)); end
+
+  def return_value_and_method_name(options=T.unsafe(nil)); end
+
+  def return_value_and_method_name_with_color(options=T.unsafe(nil)); end
+
+  def return_value_with_color(options=T.unsafe(nil)); end
+end
+
+class TappingDevice::Payload
+  def arguments(options=T.unsafe(nil)); end
+
+  def defined_class(options=T.unsafe(nil)); end
+
+  def filepath(options=T.unsafe(nil)); end
+
+  def is_private_call?(options=T.unsafe(nil)); end
+
+  def ivar_changes(options=T.unsafe(nil)); end
+
+  def line_number(options=T.unsafe(nil)); end
+
+  def method_name(options=T.unsafe(nil)); end
+
+  def method_object(options=T.unsafe(nil)); end
+
+  def receiver(options=T.unsafe(nil)); end
+
+  def return_value(options=T.unsafe(nil)); end
+
+  def tag(options=T.unsafe(nil)); end
+
+  def target(options=T.unsafe(nil)); end
+
+  def tp(options=T.unsafe(nil)); end
+
+  def trace(options=T.unsafe(nil)); end
+end
+
+module TappingDevice::Trackable
+  def print_calls(target, options=T.unsafe(nil)); end
+
+  def print_instance_calls(target_klass, options=T.unsafe(nil)); end
+
+  def print_instance_mutations(target_klass, options=T.unsafe(nil)); end
+
+  def print_instance_traces(target_klass, options=T.unsafe(nil)); end
+
+  def print_mutations(target, options=T.unsafe(nil)); end
+
+  def print_traces(target, options=T.unsafe(nil)); end
+
+  def with_print_calls(options=T.unsafe(nil)); end
+
+  def with_print_mutations(options=T.unsafe(nil)); end
+
+  def with_print_traces(options=T.unsafe(nil)); end
+
+  def with_write_calls(options=T.unsafe(nil)); end
+
+  def with_write_mutations(options=T.unsafe(nil)); end
+
+  def with_write_traces(options=T.unsafe(nil)); end
+
+  def write_calls(target, options=T.unsafe(nil)); end
+
+  def write_instance_calls(target_klass, options=T.unsafe(nil)); end
+
+  def write_instance_mutations(target_klass, options=T.unsafe(nil)); end
+
+  def write_instance_traces(target_klass, options=T.unsafe(nil)); end
+
+  def write_mutations(target, options=T.unsafe(nil)); end
+
+  def write_traces(target, options=T.unsafe(nil)); end
+end
+
+class TappingDevice
+  extend ::ActiveSupport::Configurable::ClassMethods
+end
+
+class Tempfile
+  def _close(); end
+
+  def inspect(); end
+end
+
+class Tempfile::Remover
+  def call(*args); end
+
+  def initialize(tmpfile); end
+end
+
+class Tempfile::Remover
+end
+
+module ThreadSafe
+  NULL = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+ThreadSafe::Array = Array
+
+class ThreadSafe::AtomicReferenceCacheBackend
+  def [](key); end
+
+  def []=(key, value); end
+
+  def clear(); end
+
+  def compute(key); end
+
+  def compute_if_absent(key); end
+
+  def compute_if_present(key); end
+
+  def delete(key); end
+
+  def delete_pair(key, value); end
+
+  def each_pair(); end
+
+  def empty?(); end
+
+  def get_and_set(key, value); end
+
+  def get_or_default(key, else_value=T.unsafe(nil)); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def key?(key); end
+
+  def merge_pair(key, value); end
+
+  def replace_if_exists(key, new_value); end
+
+  def replace_pair(key, old_value, new_value); end
+
+  def size(); end
+  DEFAULT_CAPACITY = ::T.let(nil, ::T.untyped)
+  HASH_BITS = ::T.let(nil, ::T.untyped)
+  LOCKED = ::T.let(nil, ::T.untyped)
+  MAX_CAPACITY = ::T.let(nil, ::T.untyped)
+  MOVED = ::T.let(nil, ::T.untyped)
+  NOW_RESIZING = ::T.let(nil, ::T.untyped)
+  TRANSFER_BUFFER_SIZE = ::T.let(nil, ::T.untyped)
+  WAITING = ::T.let(nil, ::T.untyped)
+end
+
+class ThreadSafe::AtomicReferenceCacheBackend::Node
+  include ::ThreadSafe::Util::CheapLockable
+  def initialize(hash, key, value, next_node=T.unsafe(nil)); end
+
+  def key(); end
+
+  def key?(key); end
+
+  def locked?(); end
+
+  def matches?(key, hash); end
+
+  def pure_hash(); end
+
+  def try_await_lock(table, i); end
+
+  def try_lock_via_hash(node_hash=T.unsafe(nil)); end
+
+  def unlock_via_hash(locked_hash, node_hash); end
+  HASH_BITS = ::T.let(nil, ::T.untyped)
+  LOCKED = ::T.let(nil, ::T.untyped)
+  MOVED = ::T.let(nil, ::T.untyped)
+  SPIN_LOCK_ATTEMPTS = ::T.let(nil, ::T.untyped)
+  WAITING = ::T.let(nil, ::T.untyped)
+end
+
+class ThreadSafe::AtomicReferenceCacheBackend::Node
+  extend ::ThreadSafe::Util::Volatile
+  def self.locked_hash?(hash); end
+end
+
+class ThreadSafe::AtomicReferenceCacheBackend::Table
+  def cas_new_node(i, hash, key, value); end
+
+  def delete_node_at(i, node, predecessor_node); end
+
+  def try_lock_via_hash(i, node, node_hash); end
+
+  def try_to_cas_in_computed(i, hash, key); end
+end
+
+class ThreadSafe::AtomicReferenceCacheBackend::Table
+end
+
+class ThreadSafe::AtomicReferenceCacheBackend
+  extend ::ThreadSafe::Util::Volatile
+end
+
+ThreadSafe::ConcurrentCacheBackend = ThreadSafe::MriCacheBackend
+
+ThreadSafe::Hash = Hash
+
+class ThreadSafe::MriCacheBackend
+  WRITE_LOCK = ::T.let(nil, ::T.untyped)
+end
+
+class ThreadSafe::SynchronizedCacheBackend
+  include ::Mutex_m
+  def lock(); end
+
+  def locked?(); end
+
+  def synchronize(&block); end
+
+  def try_lock(); end
+
+  def unlock(); end
+end
+
+class ThreadSafe::SynchronizedCacheBackend
+end
+
+module ThreadSafe::Util
+  CPU_COUNT = ::T.let(nil, ::T.untyped)
+  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
+  MAX_INT = ::T.let(nil, ::T.untyped)
+end
+
+class ThreadSafe::Util::Adder
+  def add(x); end
+
+  def decrement(); end
+
+  def increment(); end
+
+  def reset(); end
+
+  def sum(); end
+end
+
+class ThreadSafe::Util::Adder
+end
+
+class ThreadSafe::Util::AtomicReference
+  def compare_and_set(old_value, new_value); end
+
+  def get(); end
+
+  def initialize(value=T.unsafe(nil)); end
+
+  def set(new_value); end
+
+  def value(); end
+
+  def value=(new_value); end
+end
+
+class ThreadSafe::Util::AtomicReference
+end
+
+module ThreadSafe::Util::CheapLockable
+  def cas_mutex(old_value, new_value); end
+
+  def compare_and_set_mutex(old_value, new_value); end
+
+  def lazy_set_mutex(value); end
+
+  def mutex(); end
+
+  def mutex=(value); end
+end
+
+module ThreadSafe::Util::CheapLockable
+  extend ::ThreadSafe::Util::Volatile
+end
+
+class ThreadSafe::Util::PowerOfTwoTuple
+  def hash_to_index(hash); end
+
+  def next_in_size_table(); end
+
+  def volatile_get_by_hash(hash); end
+
+  def volatile_set_by_hash(hash, value); end
+end
+
+class ThreadSafe::Util::PowerOfTwoTuple
+end
+
+class ThreadSafe::Util::Striped64
+  def busy?(); end
+
+  def initialize(); end
+
+  def retry_update(x, hash_code, was_uncontended); end
+  THREAD_LOCAL_KEY = ::T.let(nil, ::T.untyped)
+end
+
+class ThreadSafe::Util::Striped64::Cell
+  def cas(old_value, new_value); end
+
+  def cas_computed(); end
+
+  def padding_(); end
+end
+
+class ThreadSafe::Util::Striped64::Cell
+end
+
+class ThreadSafe::Util::Striped64
+  extend ::ThreadSafe::Util::Volatile
+end
+
+module ThreadSafe::Util::Volatile
+  def attr_volatile(*attr_names); end
+end
+
+module ThreadSafe::Util::Volatile
+end
+
+class ThreadSafe::Util::VolatileTuple
+  include ::Enumerable
+  def cas(i, old_value, new_value); end
+
+  def compare_and_set(i, old_value, new_value); end
+
+  def each(&blk); end
+
+  def initialize(size); end
+
+  def size(); end
+
+  def volatile_get(i); end
+
+  def volatile_set(i, value); end
+end
+
+class ThreadSafe::Util::VolatileTuple
+end
+
+module ThreadSafe::Util::XorShiftRandom
+  def get(); end
+
+  def xorshift(x); end
+  MAX_XOR_SHIFTABLE_INT = ::T.let(nil, ::T.untyped)
+end
+
+module ThreadSafe::Util::XorShiftRandom
+  extend ::ThreadSafe::Util::XorShiftRandom
+end
+
+module ThreadSafe::Util
+end
+
+class Time
+  COMMON_YEAR_DAYS_IN_MONTH = ::T.let(nil, ::T.untyped)
+  DATE_FORMATS = ::T.let(nil, ::T.untyped)
+end
+
+class TracePoint
+  def __enable(_, _1); end
+
+  def eval_script(); end
+
+  def instruction_sequence(); end
+
+  def parameters(); end
+end
+
+class TrueClass
+  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
+end
+
+module URI
+  include ::URI::RFC2396_REGEXP
+end
+
+class URI::FTP
+  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
+end
+
+class URI::File
+  def check_password(user); end
+
+  def check_user(user); end
+
+  def check_userinfo(user); end
+
+  def set_userinfo(v); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class URI::File
+end
+
+class URI::LDAP
+  def attributes(); end
+
+  def attributes=(val); end
+
+  def dn(); end
+
+  def dn=(val); end
+
+  def extensions(); end
+
+  def extensions=(val); end
+
+  def filter(); end
+
+  def filter=(val); end
+
+  def initialize(*arg); end
+
+  def scope(); end
+
+  def scope=(val); end
+
+  def set_attributes(val); end
+
+  def set_dn(val); end
+
+  def set_extensions(val); end
+
+  def set_filter(val); end
+
+  def set_scope(val); end
+end
+
+class URI::MailTo
+  def initialize(*arg); end
+end
+
+URI::Parser = URI::RFC2396_Parser
+
+URI::REGEXP = URI::RFC2396_REGEXP
+
+class URI::RFC2396_Parser
+  def initialize(opts=T.unsafe(nil)); end
+end
+
+class URI::RFC3986_Parser
+  def join(*uris); end
+
+  def parse(uri); end
+
+  def regexp(); end
+
+  def split(uri); end
+  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
+end
+
+module URI::Util
+  def self.make_components_hash(klass, array_hash); end
+end
+
+module URI
+  extend ::URI::Escape
+  def self.get_encoding(label); end
+end
+
+module UnicodeNormalize
+end
+
+module UnicodeNormalize
+end
+
+class User
+  include ::User::GeneratedAttributeMethods
+  include ::User::GeneratedAssociationMethods
+  def after_add_for_comments(); end
+
+  def after_add_for_comments=(val); end
+
+  def after_add_for_comments?(); end
+
+  def after_add_for_posts(); end
+
+  def after_add_for_posts=(val); end
+
+  def after_add_for_posts?(); end
+
+  def after_remove_for_comments(); end
+
+  def after_remove_for_comments=(val); end
+
+  def after_remove_for_comments?(); end
+
+  def after_remove_for_posts(); end
+
+  def after_remove_for_posts=(val); end
+
+  def after_remove_for_posts?(); end
+
+  def autosave_associated_records_for_comments(*args); end
+
+  def autosave_associated_records_for_posts(*args); end
+
+  def before_add_for_comments(); end
+
+  def before_add_for_comments=(val); end
+
+  def before_add_for_comments?(); end
+
+  def before_add_for_posts(); end
+
+  def before_add_for_posts=(val); end
+
+  def before_add_for_posts?(); end
+
+  def before_remove_for_comments(); end
+
+  def before_remove_for_comments=(val); end
+
+  def before_remove_for_comments?(); end
+
+  def before_remove_for_posts(); end
+
+  def before_remove_for_posts=(val); end
+
+  def before_remove_for_posts?(); end
+
+  def validate_associated_records_for_comments(*args); end
+
+  def validate_associated_records_for_posts(*args); end
+end
+
+module User::GeneratedAssociationMethods
+  def comment_ids(); end
+
+  def comment_ids=(ids); end
+
+  def comments(); end
+
+  def comments=(value); end
+
+  def post_ids(); end
+
+  def post_ids=(ids); end
+
+  def posts(); end
+
+  def posts=(value); end
+end
+
+module User::GeneratedAssociationMethods
+end
+
+module User::GeneratedAttributeMethods
+end
+
+module User::GeneratedAttributeMethods
+  extend ::Mutex_m
+end
+
+class User
+  def self.after_add_for_comments(); end
+
+  def self.after_add_for_comments=(val); end
+
+  def self.after_add_for_comments?(); end
+
+  def self.after_add_for_posts(); end
+
+  def self.after_add_for_posts=(val); end
+
+  def self.after_add_for_posts?(); end
+
+  def self.after_remove_for_comments(); end
+
+  def self.after_remove_for_comments=(val); end
+
+  def self.after_remove_for_comments?(); end
+
+  def self.after_remove_for_posts(); end
+
+  def self.after_remove_for_posts=(val); end
+
+  def self.after_remove_for_posts?(); end
+
+  def self.before_add_for_comments(); end
+
+  def self.before_add_for_comments=(val); end
+
+  def self.before_add_for_comments?(); end
+
+  def self.before_add_for_posts(); end
+
+  def self.before_add_for_posts=(val); end
+
+  def self.before_add_for_posts?(); end
+
+  def self.before_remove_for_comments(); end
+
+  def self.before_remove_for_comments=(val); end
+
+  def self.before_remove_for_comments?(); end
+
+  def self.before_remove_for_posts(); end
+
+  def self.before_remove_for_posts=(val); end
+
+  def self.before_remove_for_posts?(); end
+end
+
+module Warning
+  extend ::Warning
+end
+
+class WeakRef
+  def initialize(orig); end
+end
+
+class Zlib::Deflate
+  def initialize(*_); end
+end
+
+class Zlib::GzipReader
+  def initialize(*_); end
+end
+
+class Zlib::GzipWriter
+  def initialize(*_); end
+end
+
+class Zlib::Inflate
+  def initialize(*_); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi b/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi
new file mode 100644
index 0000000..5258b3f
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi
@@ -0,0 +1,597 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activemodel/all/activemodel.rbi
+#
+# typed: false
+
+module ActiveModel::Dirty
+  extend T::Sig
+  sig { params(attr: Symbol, from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  def attribute_changed?(attr, from: nil, to: nil); end
+
+  sig { params(attr_name: Symbol).returns(T::Boolean) }
+  def attribute_changed_in_place?(attr_name); end
+
+  sig { params(attr_name: Symbol).returns(T::Boolean) }
+  def attribute_previously_changed?(attr_name); end
+
+  sig { returns(T::Boolean) }
+  def changed?; end
+end
+
+module ActiveModel::Validations
+  # Returns the `Errors` object that holds all information about attribute
+  # error messages.
+  #
+  # ```ruby
+  # class Person
+  #   include ActiveModel::Validations
+  #
+  #   attr_accessor :name
+  #   validates_presence_of :name
+  # end
+  #
+  # person = Person.new
+  # person.valid? # => false
+  # person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>
+  # ```
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+
+  module ClassMethods
+    # https://github.com/rails/rails/blob/v5.2.3/activemodel/lib/active_model/validations.rb#L136-L154
+    sig do
+      params(
+        names: T.any(Symbol, String),
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        prepend: T::Boolean,
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      ).void
+    end
+    def validate(
+      *names,
+      if: nil,
+      on: nil,
+      prepend: false,
+      unless: nil
+    ); end
+
+    # https://github.com/rails/rails/blob/v5.2.3/activemodel/lib/active_model/validations/validates.rb#L75-L105
+    sig do
+      params(
+        names: T.any(Symbol, String), # a splat of at least one attribute name
+        absence: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        acceptance: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        allow_blank: T::Boolean,
+        allow_nil: T::Boolean,
+        confirmation: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        # `exclusion` and `inclusion` are tricky to type without better support
+        # for overloading and shapes. Value can be anything that responds to
+        # `include?` (e.g. (1..3)), or a hash having an `in` or `within` key,
+        # like { in: [1, 2, 3], ... }
+        exclusion: T::Enumerable[T.untyped],
+        # `format` hash must additionally contain either :with or :without keys.
+        # Alternatively, it can be a Regexp.
+        format: T.any(T::Hash[T.untyped, T.untyped], Regexp),
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        # `exclusion` and `inclusion` are tricky to type without better support
+        # for overloading and shapes. Value can be anything that responds to
+        # `include?` (e.g. (1..3)), or a hash having an `in` or `within` key,
+        # like { in: [1, 2, 3], ... }
+        inclusion: T::Enumerable[T.untyped],
+        # if Hash, must contain :in, :within, :maximum, :minimum, or :is keys
+        length: T.any(T::Range[T.untyped], T::Hash[T.untyped, T.untyped]),
+        numericality: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        presence: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        size: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        strict: T::Boolean,
+        uniqueness: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        kwargs: T.untyped
+      ).void
+    end
+    def validates(
+      *names,
+      absence: false,
+      acceptance: {},
+      allow_blank: false,
+      allow_nil: false,
+      confirmation: false,
+      exclusion: [],
+      format: {},
+      if: nil,
+      inclusion: [],
+      length: {},
+      numericality: false,
+      on: :_,
+      presence: false,
+      size: false,
+      strict: false,
+      uniqueness: false,
+      unless: :_,
+      **kwargs
+    )
+    end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end
+
+class ActiveModel::Type::Value
+  extend T::Sig
+
+  sig { params(precision: T.untyped, limit: T.untyped, scale: T.untyped).void }
+  def initialize(precision: nil, limit: nil, scale: nil); end
+
+  sig { params(value: T.untyped).returns(T.untyped) }
+  def cast(value); end
+end
+
+class ActiveModel::Type::Boolean < ActiveModel::Type::Value
+  sig { params(arg0: T.untyped).returns(T.nilable(T::Boolean))}
+  def cast(arg0); end
+end
+
+class ActiveModel::Type::ImmutableString < ActiveModel::Type::Value
+  sig { params(arg0: T.untyped).returns(T.nilable(String))}
+  def cast(arg0); end
+end
+
+class ActiveModel::Type::String < ActiveModel::Type::ImmutableString
+  sig { params(arg0: T.untyped).returns(T.nilable(String))}
+  def cast(arg0); end
+end
+
+module ActiveModel::Validations::HelperMethods
+  # A type alias for the in/within parameters on the
+  # validates_(inclusion/exclusion)_of methods.
+  InWithinType = T.type_alias do
+    T.nilable(
+      T.any(
+        Symbol,
+        String,
+        T::Array[T.any(String, Symbol)],
+        T::Range[Integer],
+        T::Array[T::Boolean],
+        T.proc.params(arg0: T.untyped).returns(T::Boolean)
+      )
+    )
+  end
+
+  module ClassMethods
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_absence_of(
+      *attr_names,
+      message: 'must be blank',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        accept: T.untyped,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_acceptance_of(
+      *attr_names,
+      message: 'must be accepted',
+      accept: ['1', true],
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        case_sensitive: T::Boolean,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_confirmation_of(
+      *attr_names,
+      message: "doesn't match %{translated_attribute_name}",
+      case_sensitive: true,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        in: InWithinType,
+        within: InWithinType,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_exclusion_of(
+      *attr_names,
+      message: 'is reserved',
+      in: nil,
+      within: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        with: T.untyped,
+        without: T.untyped,
+        multiline: T.untyped,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_format_of(
+      *attr_names,
+      message: 'is invalid',
+      with: nil,
+      without: nil,
+      multiline: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        in: InWithinType,
+        within: InWithinType,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_inclusion_of(
+      *attr_names,
+      message: 'is not included in the list',
+      in: nil,
+      within: nil,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: T.nilable(String),
+        minimum: T.nilable(Integer),
+        maximum: T.nilable(Integer),
+        is: T.nilable(Integer),
+        within: T.nilable(T::Range[Integer]),
+        in: T.nilable(T::Range[Integer]),
+        too_long: String,
+        too_short: String,
+        wrong_length: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_length_of(
+      *attr_names,
+      message: nil,
+      minimum: nil,
+      maximum: nil,
+      is: nil,
+      within: nil,
+      in: nil,
+      too_long: 'is too long (maximum is %{count} characters)',
+      too_short: 'is too short (minimum is %{count} characters)',
+      wrong_length: 'is the wrong length (should be %{count} characters)',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    # validates_size_of is an alias of validates_length_of
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: T.nilable(String),
+        minimum: T.nilable(Integer),
+        maximum: T.nilable(Integer),
+        is: T.nilable(Integer),
+        within: T.nilable(T::Range[Integer]),
+        in: T.nilable(T::Range[Integer]),
+        too_long: String,
+        too_short: String,
+        wrong_length: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_size_of(
+      *attr_names,
+      message: nil,
+      minimum: nil,
+      maximum: nil,
+      is: nil,
+      within: nil,
+      in: nil,
+      too_long: 'is too long (maximum is %{count} characters)',
+      too_short: 'is too short (minimum is %{count} characters)',
+      wrong_length: 'is the wrong length (should be %{count} characters)',
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    # Create a type alias so we don't have to repeat this long type signature 6 times.
+    NumberComparatorType = T.type_alias {T.nilable(T.any(Integer, Float, T.proc.params(arg0: T.untyped).returns(T::Boolean), Symbol))}
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        only_integer: T::Boolean,
+        greater_than: NumberComparatorType,
+        greater_than_or_equal_to: NumberComparatorType,
+        equal_to: NumberComparatorType,
+        less_than: NumberComparatorType,
+        less_than_or_equal_to: NumberComparatorType,
+        other_than: NumberComparatorType,
+        odd: T::Boolean,
+        even: T::Boolean,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_numericality_of(
+      *attr_names,
+      message: 'is not a number',
+      only_integer: false,
+      greater_than: nil,
+      greater_than_or_equal_to: nil,
+      equal_to: nil,
+      less_than: nil,
+      less_than_or_equal_to: nil,
+      other_than: nil,
+      odd: false,
+      even: false,
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+
+    sig do
+      params(
+        attr_names: T.any(String, Symbol),
+        message: String,
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        allow_nil: T::Boolean,
+        allow_blank: T::Boolean,
+        strict: T::Boolean
+      ).void
+    end
+    def validates_presence_of(
+      *attr_names,
+      message: "can't be blank",
+      if: nil,
+      unless: :_,
+      on: :_,
+      allow_nil: false,
+      allow_blank: false,
+      strict: false
+    ); end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end
+
+class ActiveModel::Errors
+  # Adds `message` to the error messages and used validator type to `details` on `attribute`.
+  # More than one error can be added to the same `attribute`.
+  # If no `message` is supplied, `:invalid` is assumed.
+  #
+  # ```ruby
+  # person.errors.add(:name)
+  # # => ["is invalid"]
+  # person.errors.add(:name, :not_implemented, message: "must be implemented")
+  # # => ["is invalid", "must be implemented"]
+  # ```
+  #
+  # ```ruby
+  # person.errors.messages
+  # # => {:name=>["is invalid", "must be implemented"]}
+  # ```
+  #
+  # ```ruby
+  # person.errors.details
+  # # => {:name=>[{error: :not_implemented}, {error: :invalid}]}
+  # ```
+  #
+  # If `message` is a symbol, it will be translated using the appropriate
+  # scope (see `generate_message`).
+  #
+  # If `message` is a proc, it will be called, allowing for things like
+  # `Time.now` to be used within an error.
+  #
+  # If the `:strict` option is set to `true`, it will raise
+  # ActiveModel::StrictValidationFailed instead of adding the error.
+  # `:strict` option can also be set to any other exception.
+  #
+  # ```ruby
+  # person.errors.add(:name, :invalid, strict: true)
+  # # => ActiveModel::StrictValidationFailed: Name is invalid
+  # person.errors.add(:name, :invalid, strict: NameIsInvalid)
+  # # => NameIsInvalid: Name is invalid
+  #
+  # person.errors.messages # => {}
+  # ```
+  #
+  # `attribute` should be set to `:base` if the error is not
+  # directly associated with a single attribute.
+  #
+  # ```ruby
+  # person.errors.add(:base, :name_or_email_blank,
+  #   message: "either name or email must be present")
+  # person.errors.messages
+  # # => {:base=>["either name or email must be present"]}
+  # person.errors.details
+  # # => {:base=>[{error: :name_or_email_blank}]}
+  # ```
+  sig do
+    params(
+      attribute: Symbol,
+      message: T.any(String, Symbol),
+      options: T::Hash[T.untyped, T.untyped]
+    ).returns(T.untyped)
+  end
+  def add(attribute, message = :invalid, options = {}); end
+
+  # Returns `true` if an error on the attribute with the given message is
+  # present, or `false` otherwise. `message` is treated the same as for `add`.
+  #
+  # ```ruby
+  # person.errors.add :name, :blank
+  # person.errors.added? :name, :blank           # => true
+  # person.errors.added? :name, "can't be blank" # => true
+  # ```
+  #
+  # If the error message requires options, then it returns `true` with
+  # the correct options, or `false` with incorrect or missing options.
+  #
+  # ```ruby
+  # person.errors.add :name, :too_long, { count: 25 }
+  # person.errors.added? :name, :too_long, count: 25                     # => true
+  # person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
+  # person.errors.added? :name, :too_long, count: 24                     # => false
+  # person.errors.added? :name, :too_long                                # => false
+  # person.errors.added? :name, "is too long"                            # => false
+  # ```
+  sig do
+    params(
+      attribute: Symbol,
+      message: T.any(String, Symbol),
+      options: T::Hash[T.untyped, T.untyped]
+    ).returns(T::Boolean)
+  end
+  def added?(attribute, message = :invalid, options = {}); end
+
+  # Returns `true` if an error on the attribute with the given message is
+  # present, or `false` otherwise. `message` is treated the same as for `add`.
+  #
+  # ```ruby
+  # person.errors.add :age
+  # person.errors.add :name, :too_long, { count: 25 }
+  # person.errors.of_kind? :age                                            # => true
+  # person.errors.of_kind? :name                                           # => false
+  # person.errors.of_kind? :name, :too_long                                # => true
+  # person.errors.of_kind? :name, "is too long (maximum is 25 characters)" # => true
+  # person.errors.of_kind? :name, :not_too_long                            # => false
+  # person.errors.of_kind? :name, "is too long"                            # => false
+  # ```
+  sig do
+    params(
+      attribute: Symbol,
+      message: T.any(String, Symbol)
+    ).returns(T::Boolean)
+  end
+  def of_kind?(attribute, message = :invalid); end
+
+  # Returns all the full error messages in an array.
+  #
+  # ```ruby
+  # class Person
+  #   validates_presence_of :name, :address, :email
+  #   validates_length_of :name, in: 5..30
+  # end
+  #
+  # person = Person.create(address: '123 First St.')
+  # person.errors.full_messages
+  # # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+  # ```
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi
new file mode 100644
index 0000000..3088344
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi
@@ -0,0 +1,16 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/>=5.2/activerecord.rbi
+#
+# typed: strong
+
+class ActiveRecord::Base
+  extend ActiveRecord::Delegation::DelegateCache
+  include ActiveRecord::DefineCallbacks
+  include ActiveRecord::TouchLater
+  include ActiveRecord::SecureToken
+  include ActiveRecord::Suppressor
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/>=5/activerecord.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/>=5/activerecord.rbi
new file mode 100644
index 0000000..906524b
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/>=5/activerecord.rbi
@@ -0,0 +1,53 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/>=5/activerecord.rbi
+#
+# typed: strict
+
+class ActiveRecord::Base
+
+  sig do
+  params(
+    arg: T.any(Symbol, T.proc.returns(T.untyped)),
+    if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+    unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+  ).void
+  end
+  def self.after_create_commit(
+    arg,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+  params(
+    arg: T.any(Symbol, T.proc.returns(T.untyped)),
+    if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+    unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+  ).void
+  end
+  def self.after_update_commit(
+    arg,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+  params(
+    arg: T.any(Symbol, T.proc.returns(T.untyped)),
+    if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+    unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+  ).void
+  end
+  def self.after_destroy_commit(
+    arg,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig { params(attribute: T.any(Symbol, String)).void }
+  def self.has_secure_token(attribute); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi
new file mode 100644
index 0000000..7a05dfe
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi
@@ -0,0 +1,1454 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/all/activerecord.rbi
+#
+# typed: false
+
+VariadicUntypedFunction = T.type_alias { Proc }
+AssociationCallback = T.type_alias do
+  # docs in https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html - jump to "Association callbacks"
+  T.nilable(
+    T.any(
+      Symbol, # reference to a method
+      String, # reference to a method? not clear: no string examples in docs
+      T.proc.void, # a lambda that contains the callback
+      Proc, # a proc that contains the callback
+      T::Array[T.any(Symbol, Proc, T.proc.void)] # multiple callbacks
+    )
+  )
+end
+
+module ActiveRecord::Associations::ClassMethods
+  sig do
+    params(
+      name: Symbol,
+      scope: T.nilable(T.proc.void),
+      after_add: AssociationCallback,
+      after_remove: AssociationCallback,
+      anonymous_class: T.nilable(T.any(Symbol, String)),
+      as: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      before_add: AssociationCallback,
+      before_remove: AssociationCallback,
+      class_name: T.nilable(T.any(Symbol, String)),
+      counter_cache: T.nilable(T.any(Symbol, String)),
+      dependent: T.nilable(T.any(Symbol, String)),
+      extend: T.nilable(T.any(Module, T::Array[Module])),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      index_errors: T.nilable(T::Boolean),
+      inverse_of: T.nilable(T.any(Symbol, String, FalseClass)),
+      join_table: T.nilable(T.any(Symbol, String)),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      source: T.nilable(T.any(Symbol, String)),
+      source_type: T.nilable(T.any(Symbol, String)),
+      table_name: T.nilable(T.any(Symbol, String)),
+      through: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_many(
+    name,
+    scope = nil,
+    after_add: nil,
+    after_remove: nil,
+    anonymous_class: nil,
+    as: nil,
+    autosave: nil,
+    before_add: nil,
+    before_remove: nil,
+    class_name: nil,
+    counter_cache: nil,
+    dependent: nil,
+    extend: nil,
+    foreign_key: nil,
+    foreign_type: nil,
+    index_errors: nil,
+    inverse_of: nil,
+    join_table: nil,
+    primary_key: nil,
+    source: nil,
+    source_type: nil,
+    table_name: nil,
+    through: nil,
+    validate: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      name: Symbol,
+      scope: T.nilable(T.proc.void),
+      anonymous_class: T.nilable(T.any(Symbol, String)),
+      as: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      class_name: T.nilable(T.any(Symbol, String)),
+      dependent: T.nilable(T.any(Symbol, String)),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      inverse_of: T.nilable(T.any(Symbol, String, FalseClass)),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      required: T.nilable(T::Boolean),
+      source: T.nilable(T.any(Symbol, String)),
+      source_type: T.nilable(T.any(Symbol, String)),
+      through: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_one(
+    name,
+    scope = nil,
+    anonymous_class: nil,
+    as: nil,
+    autosave: nil,
+    class_name: nil,
+    dependent: nil,
+    foreign_key: nil,
+    foreign_type: nil,
+    inverse_of: nil,
+    primary_key: nil,
+    required: nil,
+    source: nil,
+    source_type: nil,
+    through: nil,
+    validate: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      name: T.nilable(T.any(Symbol, String)),
+      scope: T.nilable(T.proc.void),
+      autosave: T.nilable(T::Boolean),
+      class_name: T.nilable(T.any(Symbol, String)),
+      counter_cache: T.nilable(T.any(Symbol, String, T::Boolean)),
+      dependent: T.nilable(T.any(Symbol, String)),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      inverse_of: T.nilable(T.any(Symbol, String, FalseClass)),
+      optional: T.nilable(T::Boolean),
+      polymorphic: T.nilable(T::Boolean),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      required: T.nilable(T::Boolean),
+      touch: T.nilable(T.any(T::Boolean, Symbol)),
+      validate: T.nilable(T::Boolean),
+      default: T.nilable(T.proc.returns(T.untyped))
+    ).void
+  end
+  def belongs_to(
+    name,
+    scope = nil,
+    autosave: nil,
+    class_name: nil,
+    counter_cache: nil,
+    dependent: nil,
+    foreign_key: nil,
+    foreign_type: nil,
+    inverse_of: nil,
+    optional: nil,
+    polymorphic: nil,
+    primary_key: nil,
+    required: nil,
+    touch: nil,
+    validate: nil,
+    default: nil
+  ); end
+
+  sig do
+    params(
+      name: T.nilable(T.any(Symbol, String)),
+      scope: T.nilable(T.proc.void),
+      after_add: AssociationCallback,
+      after_remove: AssociationCallback,
+      association_foreign_key: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      before_add: AssociationCallback,
+      before_remove: AssociationCallback,
+      class_name: T.nilable(T.any(Symbol, String)),
+      extend: T.nilable(T.any(Module, T::Array[Module])),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      join_table: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_and_belongs_to_many(
+    name,
+    scope = nil,
+    after_add: nil,
+    after_remove: nil,
+    association_foreign_key: nil,
+    autosave: nil,
+    before_add: nil,
+    before_remove: nil,
+    class_name: nil,
+    extend: nil,
+    foreign_key: nil,
+    join_table: nil,
+    validate: nil,
+    &blk
+  ); end
+end
+
+module ActiveRecord::AttributeMethods
+  include ActiveModel::AttributeMethods
+end
+
+module ActiveRecord::AttributeMethods::Serialization::ClassMethods
+  sig { params(attr_name: Symbol, class_name_or_coder: T.untyped).void }
+  def serialize(attr_name, class_name_or_coder = Object); end
+end
+
+module ActiveRecord::NestedAttributes::ClassMethods
+  sig do
+    params(
+      attr_names: T.any(T.any(Symbol, String), T::Array[T.any(Symbol, String)]),
+      allow_destroy: T.nilable(T::Boolean),
+      reject_if: T.any(Symbol, T.proc.returns(T::Boolean)),
+      limit: T.any(Integer, Symbol, T.proc.returns(Integer)),
+      update_only: T.nilable(T::Boolean),
+    ).void
+  end
+  def accepts_nested_attributes_for(
+    attr_names,
+    allow_destroy: nil,
+    reject_if: nil,
+    limit: nil,
+    update_only: nil
+  ); end
+end
+
+module ActiveRecord::Scoping::Named::ClassMethods
+  sig do
+    params(
+      name: T.nilable(T.any(Symbol, String)),
+      body: VariadicUntypedFunction,
+      blk: T.nilable(VariadicUntypedFunction)
+    ).void
+  end
+  def scope(
+    name,
+    body,
+    &blk
+  ); end
+end
+
+module ActiveRecord::Scoping::Default::ClassMethods
+end
+
+module ActiveRecord::Inheritance
+  mixes_in_class_methods(ActiveRecord::Inheritance::ClassMethods)
+end
+
+module ActiveRecord::Transactions
+  mixes_in_class_methods(ActiveRecord::Transactions::ClassMethods)
+end
+
+class ActiveRecord::Base
+  extend ActiveModel::Naming
+
+  extend ActiveSupport::Benchmarkable
+  extend ActiveSupport::DescendantsTracker
+
+  extend ActiveRecord::ConnectionHandling
+  extend ActiveRecord::QueryCache::ClassMethods
+  extend ActiveRecord::Querying
+  extend ActiveRecord::Translation
+  extend ActiveRecord::DynamicMatchers
+  extend ActiveRecord::Explain
+  extend ActiveRecord::Enum
+
+  include ActiveRecord::Core
+  include ActiveRecord::Persistence
+  include ActiveRecord::ReadonlyAttributes
+  include ActiveRecord::ModelSchema
+  extend ActiveRecord::ModelSchema::ClassMethods # via ActiveRecord::ModelSchema concern inclusion
+  include ActiveRecord::Sanitization
+  extend ActiveRecord::Sanitization::ClassMethods # via ActiveRecord::Sanitization concern inclusion
+  include ActiveRecord::Inheritance
+  include ActiveRecord::Scoping
+  include ActiveRecord::Scoping::Default # via ActiveRecord::Scoping#included hook
+  extend ActiveRecord::Scoping::Default::ClassMethods # via ActiveRecord::Scoping::Default Concern inclusion
+  include ActiveRecord::Scoping::Named # via ActiveRecord::Scoping#included hook
+  extend ActiveRecord::Scoping::Named::ClassMethods # via ActiveRecord::Scoping::Named Concern inclusion
+  include ActiveRecord::AttributeAssignment
+  include ActiveModel::Conversion
+  include ActiveRecord::Integration
+  include ActiveModel::Validations
+  include ActiveModel::Validations::HelperMethods
+  include ActiveRecord::CounterCache
+  include ActiveRecord::Attributes
+  include ActiveRecord::AttributeDecorators
+  include ActiveRecord::Locking::Optimistic
+  include ActiveRecord::Locking::Pessimistic
+  include ActiveRecord::AttributeMethods
+  include ActiveRecord::AttributeMethods::Read # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Write # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::BeforeTypeCast # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Query # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::PrimaryKey # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::TimeZoneConversion # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Dirty # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Serialization # via ActiveRecord::AttributeMethods#included hook
+  extend ActiveRecord::AttributeMethods::Serialization::ClassMethods # via ActiveRecord::AttributeMethods::Serialization Concern inclusion
+  include ActiveRecord::Callbacks
+  include ActiveRecord::Timestamp
+  include ActiveRecord::Associations
+  include ActiveModel::SecurePassword
+  include ActiveRecord::AutosaveAssociation
+  include ActiveRecord::NestedAttributes
+  extend ActiveRecord::NestedAttributes::ClassMethods # via ActiveRecord::NestedAttributes Concern inclusion
+  include ActiveRecord::Aggregations
+  include ActiveRecord::Transactions
+  include ActiveRecord::NoTouching
+  include ActiveRecord::Reflection
+  include ActiveRecord::Serialization
+  include ActiveRecord::Store
+
+  sig do
+    params(
+      arg: Symbol,
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      on: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_commit(
+    arg,
+    if: nil,
+    on: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_rollback(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      on: T.nilable(T.any(Symbol, T::Array[Symbol]))
+    ).void
+  end
+  def self.after_validation(
+    arg = nil,
+    if: nil,
+    unless: nil,
+    on: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      prepend: T::Boolean
+    ).void
+  end
+  def self.before_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil,
+    prepend: false
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, Proc, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      on: T.nilable(T.any(Symbol, T::Array[Symbol]))
+    ).void
+  end
+  def self.before_validation(
+    arg = nil,
+    if: nil,
+    unless: nil,
+    on: nil
+  ); end
+
+  sig { params(comparison_object: T.untyped).returns(T::Boolean) }
+  def ==(comparison_object); end
+end
+
+module ActiveRecord::Inheritance::ClassMethods
+  sig { params(value: T::Boolean).void }
+  def abstract_class=(value); end
+
+  sig { returns(T::Boolean) }
+  def abstract_class; end
+end
+
+module ActiveRecord::Transactions::ClassMethods
+  sig do
+    params(
+      options: T.nilable(T::Hash[T.any(Symbol, String), T.untyped]),
+      block: T.proc.returns(T.untyped)
+    ).returns(T.untyped)
+  end
+  def transaction(options = {}, &block); end
+end
+
+module ActiveRecord::Persistence
+  mixes_in_class_methods(ActiveRecord::Persistence::ClassMethods)
+
+  sig { params(klass: Class).returns(T.untyped) }
+  def becomes!(klass); end
+
+  sig { params(klass: Class).returns(T.untyped) }
+  def becomes(klass); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer),
+      touch: T.nilable(T::Boolean)
+    ).returns(T.self_type)
+  end
+  def decrement!(attribute, by = 1, touch: nil); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer)
+    ).returns(T.self_type)
+  end
+  def decrement(attribute, by = 1); end
+
+  sig { returns(T::Boolean) }
+  def destroyed?(); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer),
+      touch: T.nilable(T::Boolean)
+    ).returns(T.self_type)
+  end
+  def increment!(attribute, by = 1, touch: nil); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer)
+    ).returns(T.self_type)
+  end
+  def increment(attribute, by = 1); end
+
+  sig { returns(T::Boolean) }
+  def new_record?(); end
+
+  sig { returns(T::Boolean) }
+  def persisted?(); end
+
+  sig do
+    params(
+      options: T.nilable({ lock: T.nilable(T::Boolean) })
+    ).returns(T.self_type)
+  end
+  def reload(options = nil); end
+
+  sig do
+    params(
+      args: T.untyped,
+      blk: T.nilable(T.proc.void),
+    ).returns(TrueClass)
+  end
+  def save!(*args, &blk); end
+
+  sig do
+    params(
+      args: T.untyped,
+      blk: T.nilable(T.proc.void),
+    ).returns(T::Boolean)
+  end
+  def save(*args, &blk); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(TrueClass) }
+  def toggle!(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T.self_type) }
+  def toggle(attribute); end
+
+  sig do
+    params(
+      names: T.any(
+        Symbol,
+        String,
+        T::Array[T.any(Symbol, String)]
+      ),
+      time: T.nilable(Time)
+    ).returns(T::Boolean)
+  end
+  def touch(*names, time: nil); end
+
+  sig do
+    params(
+      name: T.any(Symbol, String),
+      value: T.untyped,
+    ).returns(T::Boolean)
+  end
+  def update_attribute(name, value); end
+
+  sig do
+    params(
+      name: T.any(Symbol, String),
+      value: T.untyped,
+    ).returns(T::Boolean)
+  end
+  def update_column(name, value); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(T::Boolean)
+  end
+  def update_columns(attributes); end
+
+  sig do
+    params(
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        ActionController::Parameters
+      )
+    ).returns(TrueClass)
+  end
+  def update!(attributes); end
+
+  # update_attributes! is an alias of update!
+  sig do
+    params(
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        ActionController::Parameters
+      )
+    ).returns(TrueClass)
+  end
+  def update_attributes!(attributes); end
+
+  sig do
+    params(
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        ActionController::Parameters
+      )
+    ).returns(T::Boolean)
+  end
+  def update(attributes); end
+
+  # update_attributes is an alias of update
+  sig do
+    params(
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        ActionController::Parameters
+      )
+    ).returns(T::Boolean)
+  end
+  def update_attributes(attributes); end
+end
+
+module ActiveRecord::Persistence::ClassMethods
+  sig do
+    params(
+      attributes: T.nilable(T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )),
+      blk: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def create!(attributes = nil, &blk); end
+
+  sig do
+    params(
+      attributes: T.nilable(T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )),
+      blk: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def create(attributes = nil, &blk); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def delete(id_or_array); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def destroy!(id_or_array); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def destroy(id_or_array); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)]))
+    ).returns(ActiveRecord::Result)
+  end
+  def insert_all!(attributes, returning: nil); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert_all(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert!(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert(attributes, returning: nil, unique_by: nil); end
+
+  sig { params(attributes: T.untyped, column_types: T::Hash[T.untyped, T.untyped], blk: T.proc.void).returns(T.untyped) }
+  def instantiate(attributes, column_types = {}, &blk); end
+
+  # The 'attributes' parameter can take either a hash or an array of hashes.
+  sig do
+    params(
+      id: T.any(T.untyped, T::Array[T.untyped], Symbol),
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )
+    ).returns(T.any(T::Array[T.untyped], T.untyped))
+  end
+  def update(id = :all, attributes); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def upsert_all(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def upsert(attributes, returning: nil, unique_by: nil); end
+end
+
+class ActiveRecord::Result; end
+
+ActiveRecord::Type::Value = ActiveModel::Type::Value
+ActiveRecord::Type::Boolean = ActiveModel::Type::Boolean
+ActiveRecord::Type::String = ActiveModel::Type::String
+
+module ActiveRecord
+  class ActiveRecordError < StandardError; end
+  class AdapterNotFound < ActiveRecordError; end
+  class AdapterNotSpecified < ActiveRecordError; end
+  class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError; end
+  class AssociationNotFoundError < ConfigurationError; end
+  class AssociationTypeMismatch < ActiveRecordError; end
+  class AttributeAssignmentError < ActiveRecordError; end
+  class ConcurrentMigrationError < MigrationError; end
+  class ConfigurationError < ActiveRecordError; end
+  class ConnectionNotEstablished < ActiveRecordError; end
+  class ConnectionTimeoutError < ConnectionNotEstablished; end
+  class DangerousAttributeError < ActiveRecordError; end
+  class Deadlocked < TransactionRollbackError; end
+  class DeleteRestrictionError < ActiveRecordError; end
+  class DuplicateMigrationNameError < MigrationError; end
+  class DuplicateMigrationVersionError < MigrationError; end
+  class EagerLoadPolymorphicError < ActiveRecordError; end
+  class EnvironmentMismatchError < ActiveRecordError; end
+  class ExclusiveConnectionTimeoutError < ConnectionTimeoutError; end
+  class FixtureClassNotFound < ActiveRecordError; end
+  class HasManyThroughAssociationNotFoundError < ActiveRecordError; end
+  class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError; end
+  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError; end
+  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError; end
+  class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection; end
+  class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly; end
+  class HasManyThroughOrderError < ActiveRecordError; end
+  class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError; end
+  class HasOneAssociationPolymorphicThroughError < ActiveRecordError; end
+  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError; end
+  class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection; end
+  class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly; end
+  class IllegalMigrationNameError < MigrationError; end
+  class ImmutableRelation < ActiveRecordError; end
+  class InvalidForeignKey < WrappedDatabaseException; end
+  class InverseOfAssociationNotFoundError < ActiveRecordError; end
+  class IrreversibleMigration < MigrationError; end
+  class IrreversibleOrderError < ActiveRecordError; end
+  class LockWaitTimeout < StatementInvalid; end
+  class MigrationError < ActiveRecordError; end
+  class MismatchedForeignKey < StatementInvalid; end
+  class MultiparameterAssignmentErrors < ActiveRecordError; end
+  class NoDatabaseError < StatementInvalid; end
+  class NoEnvironmentInSchemaError < MigrationError; end
+  class NotNullViolation < StatementInvalid; end
+  class PendingMigrationError < MigrationError; end
+  class PreparedStatementCacheExpired < StatementInvalid; end
+  class PreparedStatementInvalid < ActiveRecordError; end
+  class ProtectedEnvironmentError < ActiveRecordError; end
+  class QueryCanceled < StatementInvalid; end
+  class RangeError < StatementInvalid; end
+  class ReadOnlyRecord < ActiveRecordError; end
+  class RecordInvalid < ActiveRecordError; end
+  class RecordNotDestroyed < ActiveRecordError; end
+  class RecordNotFound < ActiveRecordError; end
+  class RecordNotSaved < ActiveRecordError; end
+  class RecordNotUnique < WrappedDatabaseException; end
+  class Rollback < ActiveRecordError; end
+  class SerializationFailure < TransactionRollbackError; end
+  class SerializationTypeMismatch < ActiveRecordError; end
+  class StaleObjectError < ActiveRecordError; end
+  class StatementInvalid < ActiveRecordError; end
+  class StatementTimeout < StatementInvalid; end
+  class SubclassNotFound < ActiveRecordError; end
+  class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError; end
+  class ThroughNestedAssociationsAreReadonly < ActiveRecordError; end
+  class TransactionIsolationError < ActiveRecordError; end
+  class TransactionRollbackError < StatementInvalid; end
+  class TypeConflictError < StandardError; end
+  UnknownAttributeError = ActiveModel::UnknownAttributeError
+  class UnknownAttributeReference < ActiveRecordError; end
+  class UnknownMigrationVersionError < MigrationError; end
+  class UnknownPrimaryKey < ActiveRecordError; end
+  class ValueTooLong < StatementInvalid; end
+  class WrappedDatabaseException < StatementInvalid; end
+end
+
+class ActiveRecord::Schema < ActiveRecord::Migration::Current
+  sig {params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void}
+  def self.define(info = nil, &blk); end
+end
+
+module ActiveRecord::AttributeMethods::Dirty
+  extend T::Sig
+  sig { params(attr_name: Symbol, options: T.untyped).returns(T::Boolean) }
+  def saved_change_to_attribute?(attr_name, **options); end
+end
+
+module ActiveRecord::Associations
+  mixes_in_class_methods(ActiveRecord::Associations::ClassMethods)
+end
+
+# Represents the schema of an SQL table in an abstract way. This class
+# provides methods for manipulating the schema representation.
+#
+# Inside migration files, the `t` object in `create_table`
+# is actually of this type:
+#
+# ```ruby
+# class SomeMigration < ActiveRecord::Migration[5.0]
+#   def up
+#     create_table :foo do |t|
+#       puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
+#     end
+#   end
+#
+#   def down
+#     # ...
+#   end
+# end
+# ```
+class ActiveRecord::ConnectionAdapters::TableDefinition
+  include ActiveRecord::ConnectionAdapters::ColumnMethods
+
+  # Returns an array of ColumnDefinition objects for the columns of the table.
+  sig { returns(T::Array[ActiveRecord::ConnectionAdapters::ColumnDefinition]) }
+  def columns; end
+
+  # Returns a ColumnDefinition for the column with name `name`.
+  sig { params(name: T.any(String, Symbol)).returns(ActiveRecord::ConnectionAdapters::ColumnDefinition) }
+  def [](name); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol),
+      type: T.untyped,
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).returns(T.self_type)
+  end
+  def column(
+    name,
+    type,
+    index: nil,
+    default: nil,
+    **options
+  ); end
+
+  # Remove the column `name` from the table.
+  #
+  # ```ruby
+  # remove_column(:account_id)
+  # ```
+  sig { params(name: T.any(String, Symbol)).void }
+  def remove_column(name); end
+
+  # Adds index options to the indexes hash, keyed by column name
+  # This is primarily used to track indexes that need to be created after the table
+  #
+  # ```ruby
+  # index(:account_id, name: 'index_projects_on_account_id')
+  # ```
+  sig do
+    params(
+      column_name: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped
+    ).void
+  end
+  def index(column_name, options = {}); end
+
+  # Appends `:datetime` columns `:created_at` and
+  # `:updated_at` to the table.
+  #
+  # ```ruby
+  # t.timestamps null: false
+  # ```
+  sig { params(options: T.untyped).void }
+  def timestamps(**options); end
+
+  # Adds a reference.
+  #
+  # ```ruby
+  # t.references(:user)
+  # t.belongs_to(:supplier, foreign_key: true)
+  # t.belongs_to(:supplier, foreign_key: true, type: :integer)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def references(*args, **options); end
+
+  # Adds a reference.
+  #
+  # ```ruby
+  # t.references(:user)
+  # t.belongs_to(:supplier, foreign_key: true)
+  # t.belongs_to(:supplier, foreign_key: true, type: :integer)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def belongs_to(*args, **options); end
+end
+
+module ActiveRecord::ConnectionAdapters::ColumnMethods
+  # Appends a primary key definition to the table definition.
+  # Can be called multiple times, but this is probably not a good idea.
+  sig do
+    params(
+      name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      options: T.untyped
+    ).void
+  end
+  def primary_key(name, type = :primary_key, **options); end
+
+  ########
+  # NOTE: The following methods are all generated dynamically and have the same parameters.
+  # See https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L217
+  ########
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def bigint(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def binary(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def boolean(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def date(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def datetime(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def decimal(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def numeric(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def float(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def integer(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def json(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def string(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def text(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def time(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def timestamp(*names, index: nil, default: nil, **options); end
+
+  sig do
+    params(
+      names: T.any(String, Symbol),
+      index: T.any(T::Hash[T.untyped, T.untyped], T::Boolean),
+      default: T.untyped,
+      options: T.untyped
+    ).void
+  end
+  def virtual(*names, index: nil, default: nil, **options); end
+end
+
+# Represents an SQL table in an abstract way for updating a table.
+#
+# Available transformations are:
+#
+# ```ruby
+# change_table :table do |t|
+#   t.primary_key
+#   t.column
+#   t.index
+#   t.rename_index
+#   t.timestamps
+#   t.change
+#   t.change_default
+#   t.rename
+#   t.references
+#   t.belongs_to
+#   t.string
+#   t.text
+#   t.integer
+#   t.bigint
+#   t.float
+#   t.decimal
+#   t.numeric
+#   t.datetime
+#   t.timestamp
+#   t.time
+#   t.date
+#   t.binary
+#   t.boolean
+#   t.foreign_key
+#   t.json
+#   t.virtual
+#   t.remove
+#   t.remove_foreign_key
+#   t.remove_references
+#   t.remove_belongs_to
+#   t.remove_index
+#   t.remove_timestamps
+# end
+# ```
+class ActiveRecord::ConnectionAdapters::Table
+  include ActiveRecord::ConnectionAdapters::ColumnMethods
+
+  # Adds a new column to the named table.
+  #
+  # ```ruby
+  # t.column(:name, :string)
+  # ```
+  sig { params(column_name: T.any(String, Symbol), type: Symbol, options: T.untyped).void }
+  def column(column_name, type, **options); end
+
+  # Checks to see if a column exists.
+  #
+  # ```ruby
+  # t.string(:name) unless t.column_exists?(:name, :string)
+  # ```
+  sig { params(column_name: T.any(String, Symbol), type: Symbol, options: T.untyped).returns(T::Boolean) }
+  def column_exists?(column_name, type = nil, options = {}); end
+
+  # Adds a new index to the table. `column_name` can be a single Symbol, or
+  # an Array of Symbols.
+  #
+  # ```ruby
+  # t.index(:name)
+  # t.index([:branch_id, :party_id], unique: true)
+  # t.index([:branch_id, :party_id], unique: true, name: 'by_branch_party')
+  # ```
+  sig do
+    params(
+      column_name: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped
+    ).void
+  end
+  def index(column_name, options = {}); end
+
+  # Checks to see if an index exists.
+  #
+  # ```ruby
+  # unless t.index_exists?(:branch_id)
+  #   t.index(:branch_id)
+  # end
+  # ```
+  sig { params(column_name: T.any(String, Symbol), options: T.untyped).returns(T::Boolean) }
+  def index_exists?(column_name, options = {}); end
+
+  # Renames the given index on the table.
+  #
+  # ```ruby
+  # t.rename_index(:user_id, :account_id)
+  # ```
+  sig { params(index_name: T.any(String, Symbol), new_index_name: T.any(String, Symbol)).void }
+  def rename_index(index_name, new_index_name); end
+
+  # Adds timestamps (`created_at` and `updated_at`) columns to the table.
+  #
+  # ```ruby
+  # t.timestamps(null: false)
+  # ```
+  def timestamps(options = {}); end
+
+  # Changes the column's definition according to the new options.
+  #
+  # ```ruby
+  # t.change(:name, :string, limit: 80)
+  # t.change(:description, :text)
+  # ```
+  sig { params(column_name: T.any(String, Symbol), type: Symbol, options: T.untyped).void }
+  def change(column_name, type, options = {}); end
+
+  # Sets a new default value for a column.
+  #
+  # ```ruby
+  # t.change_default(:qualification, 'new')
+  # t.change_default(:authorized, 1)
+  # t.change_default(:status, from: nil, to: "draft")
+  # ```
+  sig { params(column_name: T.any(String, Symbol), default_or_changes: T.untyped).void }
+  def change_default(column_name, default_or_changes); end
+
+  # Removes the column(s) from the table definition.
+  #
+  # ```ruby
+  # t.remove(:qualification)
+  # t.remove(:qualification, :experience)
+  # ```
+  sig { params(column_names: T.any(String, Symbol)).void }
+  def remove(*column_names); end
+
+  # Removes the given index from the table.
+  #
+  # ```ruby
+  # t.remove_index(:branch_id)
+  # t.remove_index(column: [:branch_id, :party_id])
+  # t.remove_index(name: :by_branch_party)
+  # ```
+  sig { params(options: T.untyped).void }
+  def remove_index(options = {}); end
+
+  # Removes the timestamp columns (`created_at` and `updated_at`) from the table.
+  #
+  # ```ruby
+  # t.remove_timestamps
+  # ```
+  sig { params(options: T.untyped).void }
+  def remove_timestamps(options = {}); end
+
+  # Renames a column.
+  #
+  # ```ruby
+  # t.rename(:description, :name)
+  # ```
+  sig { params(column_name: T.any(String, Symbol), new_column_name: T.any(String, Symbol)).void }
+  def rename(column_name, new_column_name); end
+
+  # Adds a reference.
+  #
+  # ```ruby
+  # t.references(:user)
+  # t.belongs_to(:supplier, foreign_key: true)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def references(*args, **options); end
+
+  # Adds a reference.
+  #
+  # ```ruby
+  # t.references(:user)
+  # t.belongs_to(:supplier, foreign_key: true)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def belongs_to(*args, **options); end
+
+  # Removes a reference. Optionally removes a `type` column.
+  #
+  # ```ruby
+  # t.remove_references(:user)
+  # t.remove_belongs_to(:supplier, polymorphic: true)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def remove_references(*args, **options); end
+
+  # Removes a reference. Optionally removes a `type` column.
+  #
+  # ```ruby
+  # t.remove_references(:user)
+  # t.remove_belongs_to(:supplier, polymorphic: true)
+  # ```
+  sig { params(args: T.untyped, options: T.untyped).void }
+  def remove_belongs_to(*args, **options); end
+
+  # Adds a foreign key to the table using a supplied table name.
+  #
+  # ```ruby
+  # t.foreign_key(:authors)
+  # t.foreign_key(:authors, column: :author_id, primary_key: "id")
+  # ```
+  sig { params(args: T.untyped).void }
+  def foreign_key(*args); end
+
+  # Removes the given foreign key from the table.
+  #
+  # ```ruby
+  # t.remove_foreign_key(:authors)
+  # t.remove_foreign_key(column: :author_id)
+  # ```
+  sig { params(args: T.untyped).void }
+  def remove_foreign_key(*args); end
+
+  # Checks to see if a foreign key exists.
+  #
+  # ```ruby
+  # t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
+  # ```
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def foreign_key_exists?(*args); end
+end
+
+module ActiveRecord::Locking::Pessimistic
+  # Returns `nil` if `ActiveRecord::Rollback` is raised.
+  sig do
+    type_parameters(:U)
+      .params(
+        lock: T.any(String, TrueClass),
+        blk: T.proc.returns(T.type_parameter(:U)),
+      )
+      .returns(T.nilable(T.type_parameter(:U)))
+  end
+  def with_lock(lock = nil, &blk); end
+end
+
+class ActiveRecord::Relation
+  sig { returns(Integer) }
+  def delete_all; end
+
+  # Returns size of the records.
+  sig { returns(Integer) }
+  def size; end
+
+  # Returns true if relation is blank.
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  # Returns true if there are no records.
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  # Returns true if there are no records.
+  sig { returns(T::Boolean) }
+  def none?; end
+
+  # Returns true if there are any records.
+  sig { returns(T::Boolean) }
+  def any?; end
+
+  # Returns true if there is exactly one record.
+  sig { returns(T::Boolean) }
+  def one?; end
+
+  # Returns true if there is more than one record.
+  sig { returns(T::Boolean) }
+  def many?; end
+end
+
+module ActiveRecord::Batches; end
+
+class ActiveRecord::Batches::BatchEnumerator; end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/all/model_schema.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/all/model_schema.rbi
new file mode 100644
index 0000000..32e5a14
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/all/model_schema.rbi
@@ -0,0 +1,79 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/all/model_schema.rbi
+#
+# typed: strong
+
+# https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/model_schema.rb
+module ActiveRecord::ModelSchema::ClassMethods
+  sig { returns(String) }
+  def table_name
+  end
+
+  sig { params(value: String).void }
+  def table_name=(value)
+  end
+
+  sig { returns(String) }
+  def quoted_table_name
+  end
+
+  sig { returns(T::Array[String]) }
+  def protected_environments
+  end
+
+  sig { params(environments: T::Array[String]).void }
+  def protected_environments=(environments)
+  end
+
+  sig { returns(T.nilable(String)) }
+  def inheritance_column
+  end
+
+  sig { params(value: T.nilable(String)).void }
+  def inheritance_column=(value)
+  end
+
+  sig { returns(T::Array[String]) }
+  def ignored_columns
+  end
+
+  sig { params(columns: T::Array[String]).void }
+  def ignored_columns=(columns)
+  end
+
+  sig { returns(T.nilable(String)) }
+  def sequence_name
+  end
+
+  sig { params(value: String).void }
+  def sequence_name=(value)
+  end
+
+  sig { returns(T::Boolean) }
+  def prefetch_primary_key?
+  end
+
+  sig { returns(T::Boolean) }
+  def table_exists?
+  end
+
+  sig { returns(T::Hash[String, ActiveRecord::ConnectionAdapters::Column]) }
+  def columns_hash
+  end
+
+  sig { returns(T::Array[ActiveRecord::ConnectionAdapters::Column]) }
+  def columns
+  end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def column_defaults
+  end
+
+  sig { returns(T::Array[ActiveRecord::ConnectionAdapters::Column]) }
+  def content_columns
+  end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/all/sanitization.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/all/sanitization.rbi
new file mode 100644
index 0000000..16dea26
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/all/sanitization.rbi
@@ -0,0 +1,36 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/all/sanitization.rbi
+#
+# typed: false
+
+# https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/sanitization.rb
+module ActiveRecord::Sanitization::ClassMethods
+  sig { params(condition: T.any(T.nilable(String), T::Array[T.untyped])).returns(T.nilable(String)) }
+  def sanitize_sql_for_conditions(condition)
+  end
+  alias :sanitize_sql :sanitize_sql_for_conditions
+
+  sig { params(assignments: T.any(T::Array[T.untyped], T::Hash[T.untyped, T.untyped], String), default_table_name: String).returns(String) }
+  def sanitize_sql_for_assignment(assignments, default_table_name)
+  end
+
+  sig { params(condition: T.any(T::Array[T.untyped], String)).returns(String) }
+  def sanitize_sql_for_order(condition)
+  end
+
+  sig { params(attrs: T::Hash[T.untyped, T.untyped], table: String).returns(String) }
+  def sanitize_sql_hash_for_assignment(attrs, table)
+  end
+
+  sig { params(string: String, escape_character: String).returns(String) }
+  def sanitize_sql_like(string, escape_character = "\\")
+  end
+
+  sig { params(ary: T::Array[T.untyped]).returns(String) }
+  def sanitize_sql_array(ary)
+  end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi b/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi
new file mode 100644
index 0000000..9034ad7
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activerecord/~>6.0.0/activerecord.rbi
@@ -0,0 +1,483 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/~>6.0.0/activerecord.rbi
+#
+# typed: strong
+
+class ActiveRecord::Migration::Compatibility::V5_1 < ActiveRecord::Migration::Compatibility::V5_2; end
+
+# 5.2 has a different definition for create_table because 6.0 adds a new option.
+# This is the only difference between 5.2 and 6.0.
+class ActiveRecord::Migration::Compatibility::V5_2 < ActiveRecord::Migration::Current
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb#L151-L290
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      comment: T.untyped,
+      id: T.any(T::Boolean, Symbol),
+      primary_key: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped,
+      temporary: T::Boolean,
+      force: T.any(T::Boolean, Symbol),
+      as: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_table(
+    table_name,
+    comment: nil,
+    id: :primary_key,
+    primary_key: :_,
+    options: nil,
+    temporary: false,
+    force: false,
+    as: nil,
+    &blk
+  ); end
+end
+
+ActiveRecord::Migration::Compatibility::V6_0 = ActiveRecord::Migration::Current
+
+# Method definitions are documented here:
+# https://api.rubyonrails.org/v6.0/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
+class ActiveRecord::Migration::Current < ActiveRecord::Migration
+  # Tables
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb#L152-L292
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      comment: T.untyped,
+      id: T.any(T::Boolean, Symbol),
+      primary_key: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped,
+      temporary: T::Boolean,
+      force: T.any(T::Boolean, Symbol),
+      if_not_exists: T::Boolean,
+      as: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_table(
+    table_name,
+    comment: nil,
+    id: :primary_key,
+    primary_key: :_,
+    options: nil,
+    temporary: false,
+    force: false,
+    if_not_exists: false,
+    as: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      bulk: T::Boolean,
+      blk: T.proc.params(t: ActiveRecord::ConnectionAdapters::Table).void
+    ).void
+  end
+  def change_table(
+    table_name,
+    bulk: false,
+    &blk
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), new_name: T.any(String, Symbol)).void }
+  def rename_table(table_name, new_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      force: T.any(T::Boolean, Symbol),
+      if_exists: T::Boolean,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def drop_table(
+    table_name,
+    force: false,
+    if_exists: false,
+    &blk
+  ); end
+
+  # Join Tables
+
+  sig do
+    params(
+      table_1: T.any(String, Symbol),
+      table_2: T.any(String, Symbol),
+      column_options: T.untyped,
+      table_name: T.any(String, Symbol),
+      temporary: T.untyped,
+      force: T::Boolean,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def create_join_table(
+    table_1,
+    table_2,
+    column_options: {},
+    table_name: nil,
+    temporary: nil,
+    force: false,
+    &blk
+  ); end
+
+  sig do
+    params(
+      table_1: T.any(String, Symbol),
+      table_2: T.any(String, Symbol),
+      options: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).void
+  end
+  def drop_join_table(
+    table_1,
+    table_2,
+    options = {},
+    &blk
+  ); end
+
+  # Columns
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      limit: T.untyped,
+      default: T.untyped,
+      null: T::Boolean,
+      precision: Integer,
+      scale: Integer,
+      comment: String
+    ).void
+  end
+  def add_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      limit: T.untyped,
+      default: T.untyped,
+      null: T::Boolean,
+      precision: Integer,
+      scale: Integer,
+      comment: String
+    ).void
+  end
+  def change_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      null: T::Boolean,
+      default: T.untyped
+    ).void
+  end
+  def change_column_null(table_name, column_name, null, default = nil); end
+
+  sig { params(table_name: T.any(String, Symbol), column_name: T.any(String, Symbol), default_or_changes: T.untyped).void }
+  def change_column_default(table_name, column_name, default_or_changes); end
+
+  sig { params(table_name: T.any(String, Symbol), column_name: T.any(String, Symbol), new_column_name: T.any(String, Symbol)).void }
+  def rename_column(table_name, column_name, new_column_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.nilable(T.any(String, Symbol)),
+      options: T.untyped
+    ).void
+  end
+  def remove_column(
+    table_name,
+    column_name,
+    type = nil,
+    options = {}
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), column_names: T.any(String, Symbol)).void }
+  def remove_columns(table_name, *column_names); end
+
+  # Foreign Keys
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.any(String, Symbol),
+      column: T.any(String, Symbol),
+      primary_key: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      on_delete: Symbol,
+      on_update: Symbol,
+      validate: T::Boolean
+    ).void
+  end
+  def add_foreign_key(
+    from_table,
+    to_table,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: true
+  ); end
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.nilable(T.any(String, Symbol)),
+      column: T.any(String, Symbol),
+      primary_key: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      on_delete: Symbol,
+      on_update: Symbol,
+      validate: T::Boolean
+    ).void
+  end
+  def remove_foreign_key(
+    from_table,
+    to_table = nil,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: true
+  ); end
+
+  sig do
+    params(
+      from_table: T.any(String, Symbol),
+      to_table: T.any(String, Symbol),
+      name: T.any(String, Symbol),
+      column: T.any(String, Symbol),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def foreign_key_exists?(from_table, to_table = nil, name: nil, column: nil, **options); end
+
+  sig { params(table_name: T.any(String, Symbol)).returns(T::Array[T.untyped]) }
+  def foreign_keys(table_name); end
+
+  # Indices
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      using: T.untyped,
+      unique: T::Boolean,
+      where: T.untyped,
+      order: T.untyped,
+      name: T.any(String, Symbol),
+      length: T.untyped,
+      opclass: T.untyped,
+      type: T.untyped,
+      internal: T.untyped,
+      algorithm: T.untyped
+    ).void
+  end
+  def add_index(
+    table_name,
+    column_name,
+    using: nil,
+    unique: false,
+    where: nil,
+    order: nil,
+    name: nil,
+    length: nil,
+    opclass: nil,
+    type: nil,
+    internal: nil,
+    algorithm: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      using: T.untyped,
+      unique: T::Boolean,
+      where: T.untyped,
+      order: T.untyped,
+      name: T.any(String, Symbol),
+      length: T.untyped,
+      opclass: T.untyped,
+      type: T.untyped,
+      internal: T.untyped,
+      algorithm: T.untyped
+    ).void
+  end
+  def remove_index(
+    table_name,
+    column,
+    using: nil,
+    unique: false,
+    where: nil,
+    order: nil,
+    name: nil,
+    length: nil,
+    opclass: nil,
+    type: nil,
+    internal: nil,
+    algorithm: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      old_name: T.any(String, Symbol),
+      new_name: T.any(String, Symbol)
+    ).void
+  end
+  def rename_index(
+    table_name,
+    old_name,
+    new_name
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def index_exists?(table_name, column_name, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol), index_name: T.any(String, Symbol)).returns(T::Boolean) }
+  def index_name_exists?(table_name, index_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      column_name: T.any(String, Symbol),
+      type: T.nilable(Symbol),
+      options: T.untyped
+    ).returns(T::Boolean)
+  end
+  def column_exists?(table_name, column_name, type = nil, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol)).returns(T::Array[T.untyped]) }
+  def indexes(table_name); end
+
+  # References
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      index: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      foreign_key: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      polymorphic: T::Boolean,
+      null: T.untyped
+    ).void
+  end
+  def add_reference(
+    table_name,
+    ref_name,
+    type: :bigint,
+    index: true,
+    foreign_key: false,
+    polymorphic: false,
+    null: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.any(String, Symbol),
+      type: T.any(String, Symbol),
+      index: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      foreign_key: T.any(T::Boolean, T::Hash[Symbol, T.untyped]),
+      polymorphic: T::Boolean,
+      null: T.untyped
+    ).void
+  end
+  def remove_reference(
+    table_name,
+    ref_name,
+    type: :bigint,
+    index: true,
+    foreign_key: false,
+    polymorphic: false,
+    null: nil
+  ); end
+
+  # Timestamps
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).void }
+  def add_timestamps(table_name, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).void }
+  def remove_timestamps(table_name, options = {}); end
+
+  # Extensions
+
+  sig { params(name: T.any(String, Symbol)).void }
+  def enable_extension(name); end
+
+  sig { params(name: T.any(String, Symbol)).void }
+  def disable_extension(name); end
+
+  # Miscellaneous
+
+  sig { params(message: String, subitem: T.untyped).void }
+  def say(message, subitem = false); end
+
+  sig { params(message: String, blk: T.untyped).returns(T.untyped) }
+  def say_with_time(message, &blk); end
+
+  sig { params(blk: T.untyped).void }
+  def suppress_messages(&blk); end
+
+  sig { params(blk: T.proc.params(arg0: T.untyped).void).void }
+  def reversible(&blk); end
+
+  sig { params(migration_classes: T.untyped, blk: T.nilable(T.proc.params(arg0: T.untyped).void)).void }
+  def revert(*migration_classes, &blk); end
+
+  sig { params(sql: String, name: T.nilable(String)).returns(T.untyped) }
+  def execute(sql, name = nil); end
+end
+
+module ActiveRecord::Core
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { returns(T::Boolean) }
+  def present?; end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activesupport/>=6/activesupport.rbi b/sorbet/rbi/sorbet-typed/lib/activesupport/>=6/activesupport.rbi
new file mode 100644
index 0000000..82f99fd
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activesupport/>=6/activesupport.rbi
@@ -0,0 +1,36 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activesupport/>=6/activesupport.rbi
+#
+# typed: false
+
+class Array
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def excluding(*elements); end
+
+  sig do
+    params(
+      blk: T.nilable(T.proc.params(arg0: Elem).returns(T::Boolean))
+    ).returns(T.any(T::Array[Elem], T::Enumerable[Elem]))
+  end
+  def extract!(&blk); end
+
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def including(*elements); end
+end
+
+module Enumerable
+  # https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/core_ext/enumerable.rb#L70..L82
+  # the case where a block isn't given isn't handled - that seems like an unlikely case
+  sig do
+    type_parameters(:key).params(
+      block: T.proc.params(o: Enumerable::Elem).returns(T.type_parameter(:key))
+    ).returns(
+      T::Hash[Enumerable::Elem, T.type_parameter(:key)]
+    )
+  end
+  def index_with(&block); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi b/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi
new file mode 100644
index 0000000..1bfeb9e
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/activesupport/all/activesupport.rbi
@@ -0,0 +1,1431 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activesupport/all/activesupport.rbi
+#
+# typed: false
+
+module ActiveSupport
+  sig { params(kind: Symbol, blk: T.proc.bind(T.untyped).void).void }
+  def self.on_load(kind, &blk); end
+end
+
+class Object
+  sig { params(duck: T.any(String, Symbol)).returns(T::Boolean) }
+  def acts_like?(duck); end
+
+  sig {returns(T::Boolean)}
+  def blank?; end
+
+  sig { returns(T.self_type) }
+  def deep_dup; end
+
+  sig { returns(TrueClass) }
+  def duplicable?; end
+
+  sig { params(another_object: Object).returns(T::Boolean) }
+  def in?(another_object); end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def instance_values; end
+
+  sig { returns(T::Array[String]) }
+  def instance_variable_names; end
+
+  sig { returns(T.nilable(T.self_type)) }
+  def presence; end
+
+  sig { returns(T::Boolean) }
+  def present?; end
+
+  sig { returns(String) }
+  def to_param; end
+
+  sig { params(key: String).returns(String) }
+  def to_query(key); end
+
+  sig do
+    params(
+      method_name: T.any(Symbol, String, NilClass),
+      args: T.untyped,
+      b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def try(method_name = nil, *args, &b); end
+
+  sig do
+    params(
+      method_name: T.any(Symbol, String, NilClass),
+      args: T.untyped,
+      b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def try!(method_name = nil, *args, &b); end
+
+  sig do
+    params(
+      options: T::Hash[T.untyped, T.untyped],
+      block: T.nilable(T.proc.returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def with_options(options, &block); end
+end
+
+class FalseClass
+  sig { returns(NilClass) }
+  def presence; end
+end
+
+class Method
+  sig { returns(FalseClass) }
+  def duplicable?; end
+end
+
+class NilClass
+  sig { returns(T::Boolean) }
+  def duplicable?; end
+
+  sig do
+    params(
+      method_name: T.any(Symbol, String, NilClass),
+      args: T.untyped,
+      b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(NilClass)
+  end
+  def try(method_name = nil, *args, &b); end
+
+  sig do
+    params(
+      method_name: T.any(Symbol, String, NilClass),
+      args: T.untyped,
+      b: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(NilClass)
+  end
+  def try!(method_name = nil, *args, &b); end
+end
+
+class String
+  sig { returns(T::Boolean) }
+  def acts_like_string?; end
+
+  sig { params(position: T.any(Integer, String, Regexp, T::Range[Integer])).returns(T.nilable(String)) }
+  def at(position); end
+
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { params(first_letter: Symbol).returns(String) }
+  def camelize(first_letter = :upper); end
+
+  # camelcase is an alias of camelize
+  sig { params(first_letter: Symbol).returns(String) }
+  def camelcase(first_letter = :upper); end
+
+  sig { returns(String) }
+  def classify; end
+
+  sig { returns(Module) }
+  def constantize; end
+
+  sig { returns(String) }
+  def dasherize; end
+
+  sig { returns(String) }
+  def deconstantize; end
+
+  sig { returns(String) }
+  def demodulize; end
+
+  # ends_with? is an alias of the core method 'end_with?'
+  sig { params(arg0: String).returns(T::Boolean) }
+  def ends_with?(*arg0); end
+
+  sig { params(string: String).returns(T::Boolean) }
+  def exclude?(string); end
+
+  sig { params(limit: Integer).returns(String) }
+  def first(limit = 1); end
+
+  sig { params(separate_class_name_and_id_with_underscore: T::Boolean).returns(String) }
+  def foreign_key(separate_class_name_and_id_with_underscore = true); end
+
+  sig { params(position: Integer).returns(String) }
+  def from(position); end
+
+  sig { returns(T.untyped) }
+  def html_safe; end
+
+  sig { params(capitalize: T::Boolean, keep_id_suffix: T::Boolean).returns(String) }
+  def humanize(capitalize: true, keep_id_suffix: false); end
+
+  # returns Time in the case zone is passed nil and ActiveSupport::TimeWithZone otherwise
+  sig { params(zone: T.nilable(T.any(String, ActiveSupport::TimeZone))).returns(T.any(ActiveSupport::TimeWithZone, Time)) }
+  def in_time_zone(zone = ::Time.zone); end
+
+  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(T.nilable(String)) }
+  def indent!(amount, indent_string = nil, indent_empty_lines = false); end
+
+  sig { params(amount: Integer, indent_string: T.nilable(String), indent_empty_lines: T::Boolean).returns(T.nilable(String)) }
+  def indent(amount, indent_string = nil, indent_empty_lines = false); end
+
+  sig { returns(ActiveSupport::StringInquirer) }
+  def inquiry; end
+
+  sig { returns(T::Boolean) }
+  def is_utf8?; end
+
+  sig { params(limit: Integer).returns(String) }
+  def last(limit = 1); end
+
+  sig { returns(ActiveSupport::Multibyte::Chars) }
+  def mb_chars; end
+
+  sig { params(separator: String, preserve_case: T::Boolean).returns(String) }
+  def parameterize(separator: "-", preserve_case: false); end
+
+  sig { params(count: T.nilable(Integer), locale: Symbol).returns(String) }
+  def pluralize(count = nil, locale = :en); end
+
+  sig { params(patterns: T.untyped).returns(T.untyped) }
+  def remove!(*patterns); end
+
+  sig { params(patterns: T.untyped).returns(T.untyped) }
+  def remove(*patterns); end
+
+  sig { returns(T.untyped) }
+  def safe_constantize; end
+
+  sig { params(locale: Symbol).returns(String) }
+  def singularize(locale = :en); end
+
+  sig { returns(String) }
+  def squish!; end
+
+  sig { returns(String) }
+  def squish; end
+
+  # starts_with? is an alias of the core method 'start_with?''
+  sig { params(arg0: String).returns(T::Boolean) }
+  def starts_with?(*arg0); end
+
+  sig { returns(String) }
+  def strip_heredoc; end
+
+  sig { returns(String) }
+  def tableize; end
+
+  sig { params(keep_id_suffix: T::Boolean).returns(String) }
+  def titleize(keep_id_suffix: false); end
+
+  # titlecase is an alias of titleize
+  sig { params(keep_id_suffix: T::Boolean).returns(String) }
+  def titlecase(keep_id_suffix: false); end
+
+  sig { params(position: Integer).returns(String) }
+  def to(position); end
+
+  sig { returns(T.nilable(Date)) }
+  def to_date; end
+
+  sig { returns(T.nilable(DateTime)) }
+  def to_datetime; end
+
+  sig { params(form: Symbol).returns(T.nilable(Time)) }
+  def to_time(form = :local); end
+
+  sig { params(truncate_at: Integer, separator: T.nilable(T.any(String, Regexp)), omission: String).returns(String) }
+  def truncate(truncate_at, separator: nil, omission: "..."); end
+
+  sig { params(words_count: Integer, separator: T.nilable(T.any(String, Regexp)), omission: String).returns(String) }
+  def truncate_words(words_count, separator: nil, omission: "..."); end
+
+  sig { returns(String) }
+  def underscore; end
+
+  sig { returns(String) }
+  def upcase_first; end
+end
+
+class Array
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def deep_dup; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def extract_options!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fifth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def forty_two; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fourth; end
+
+  sig { params(position: Integer).returns(T::Array[T.untyped]) }
+  def from(position); end
+
+  sig { params(number: Integer, fill_with: T.untyped).returns(T.untyped) }
+  def in_groups(number, fill_with = nil); end
+
+  sig { params(number: Integer, fill_with: T.untyped).returns(T.untyped) }
+  def in_groups_of(number, fill_with = nil); end
+
+  sig { returns(T.untyped) }
+  def inquiry; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig do
+    params(
+      value: T.untyped,
+      blk: T.proc.params(arg0: Elem).void
+    ).returns(T::Array[Elem])
+  end
+  def split(value = nil, &blk); end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { params(position: Integer).returns(T::Array[T.untyped]) }
+  def to(position); end
+
+  # to_default_s is an alias of the core method 'to_s'
+  sig {returns(String)}
+  def to_default_s; end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_formatted_s(format = :default); end
+
+  sig { returns(String) }
+  def to_param; end
+
+  sig { params(key: String).returns(String) }
+  def to_query(key); end
+
+  sig do
+    params(
+      words_connector: String,
+      two_words_connector: String,
+      last_word_connector: String,
+      locale: T.nilable(Symbol)
+    ).returns(String)
+  end
+  def to_sentence(words_connector: ", ", two_words_connector: " and ", last_word_connector: ", and ", locale: nil); end
+
+  sig { params(options: T.untyped).returns(T.untyped) }
+  def to_xml(options = nil); end
+
+  sig { params(elements: T.untyped).returns(T.untyped) }
+  def without(*elements); end
+end
+
+module ActiveSupport::NumberHelper
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      unit: String,
+      separator: String,
+      delimiter: String,
+      format: String,
+      negative_format: String
+    ).returns(String)
+  end
+  def number_to_currency(number, locale: :en, precision: 2, unit: "$", separator: ".", delimiter: ",", format: "%u%n", negative_format: "-%u%n"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      delimiter: String,
+      separator: String,
+      delimiter_pattern: T.nilable(Regexp)
+    ).returns(String)
+  end
+  def number_to_delimited(number, locale: :en, delimiter: ",", separator: ".", delimiter_pattern: nil); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean,
+      units: T.any(T::Hash[T.untyped, T.untyped], String, Symbol),
+      format: String
+    ).returns(String)
+  end
+  def number_to_human(number, locale: :en, precision: 3, significant: true, separator: ".", delimiter: "", strip_insignificant_zeros: true, units: {}, format: "%n %u"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean
+    ).returns(String)
+  end
+  def number_to_human_size(number, locale: :en, precision: 3, significant: true, separator: ".", delimiter: "", strip_insignificant_zeros: true); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean,
+      format: String
+    ).returns(String)
+  end
+  def number_to_percentage(number, locale: :en, precision: 3, significant: false, separator: ".", delimiter: "", strip_insignificant_zeros: false, format: "%n%"); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      area_code: T::Boolean,
+      delimiter: String,
+      extension: T.nilable(Integer),
+      country_code: T.nilable(Integer),
+      pattern: T.nilable(Regexp)
+    ).returns(String)
+  end
+  def number_to_phone(number, area_code: false, delimiter: "-", extension: nil, country_code: nil, pattern: nil); end
+
+  sig do
+    params(
+      number: T.any(Integer, Float, String),
+      locale: Symbol,
+      precision: T.nilable(Integer),
+      significant: T::Boolean,
+      separator: String,
+      delimiter: String,
+      strip_insignificant_zeros: T::Boolean
+    ).returns(String)
+  end
+  def number_to_rounded(number, locale: :en, precision: 3, significant: false, separator: ".", delimiter: "", strip_insignificant_zeros: false); end
+end
+
+module ActiveSupport::Inflector
+  sig do
+    params(
+      term: String,
+      uppercase_first_letter: T::Boolean
+    ).returns(String)
+  end
+  def camelize(term, uppercase_first_letter = true); end
+
+  sig { params(table_name: String).returns(String) }
+  def classify(table_name); end
+
+  sig { params(camel_cased_word: String).returns(T.untyped) }
+  def constantize(camel_cased_word); end
+
+  sig { params(underscored_word: String).returns(String) }
+  def dasherize(underscored_word); end
+
+  sig { params(path: String).returns(String) }
+  def deconstantize(path); end
+
+  sig { params(path: String).returns(String) }
+  def demodulize(path); end
+
+  sig do
+    params(
+      class_name: String,
+      separate_class_name_and_id_with_underscore: T::Boolean
+    ).returns(String)
+  end
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true); end
+
+  sig do
+    params(
+      lower_case_and_underscored_word: String,
+      capitalize: T::Boolean,
+      keep_id_suffix: T::Boolean
+    ).returns(String)
+  end
+  def humanize(lower_case_and_underscored_word, capitalize: true, keep_id_suffix: false); end
+
+  sig { params(locale: Symbol, blk: T.untyped).returns(T.untyped) }
+  def inflections(locale = :en, &blk); end
+
+  sig { params(number: Integer).returns(String) }
+  def ordinal(number); end
+
+  sig { params(number: Integer).returns(String) }
+  def ordinalize(number); end
+
+  sig do
+    params(
+      string: String,
+      separator: String,
+      preserve_case: T::Boolean,
+      locale: Symbol
+    ).returns(String)
+  end
+  def parameterize(string, separator: '-', preserve_case: false, locale: nil); end
+
+  sig { params(word: String, locale: Symbol).returns(String) }
+  def pluralize(word, locale = :en); end
+
+  sig { params(camel_cased_word: String).returns(T.untyped) }
+  def safe_constantize(camel_cased_word); end
+
+  sig { params(word: String, locale: Symbol).returns(String) }
+  def singularize(word, locale = :en); end
+
+  sig { params(class_name: String).returns(String) }
+  def tableize(class_name); end
+
+  sig { params(word: String, keep_id_suffix: T::Boolean).returns(String) }
+  def titleize(word, keep_id_suffix: false); end
+
+  sig { params(string: String, replacement: String, locale: Symbol).returns(String) }
+  def transliterate(string, replacement = '?', locale: nil); end
+
+  sig { params(camel_cased_word: String).returns(String) }
+  def underscore(camel_cased_word); end
+
+  sig { params(string: String).returns(String) }
+  def upcase_first(string); end
+end
+
+# defines some of the methods at https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/core_ext/time/calculations.rb
+# these get added to Time, but are available on TimeWithZone thanks to https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/time_with_zone.rb#L520
+# this is not a complete definition!
+class ActiveSupport::TimeWithZone
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def midnight; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def beginning_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_midnight; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_beginning_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def middle_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def midday; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def noon; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_midday; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_noon; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_middle_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def end_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_end_of_day; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def end_of_year; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_end_of_year; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def beginning_of_year; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_beginning_of_year; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def end_of_month; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_end_of_month; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def beginning_of_month; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_beginning_of_month; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def end_of_hour; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_end_of_hour; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def beginning_of_hour; end
+
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def at_beginning_of_hour; end
+
+  # Returns a `Time` instance that represents the time in `time_zone`.
+  sig { returns(Time) }
+  def time; end
+
+  # Returns a `Time` instance of the simultaneous time in the UTC timezone.
+  sig { returns(Time) }
+  def utc; end
+
+  # Returns the underlying TZInfo::TimezonePeriod.
+  sig { returns(TZInfo::TimezonePeriod) }
+  def period; end
+
+  # Returns the simultaneous time in `Time.zone`, or the specified zone.
+  sig { params(new_zone: T.untyped).returns(ActiveSupport::TimeWithZone) }
+  def in_time_zone(new_zone = ::Time.zone); end
+
+  # Returns a `Time` instance of the simultaneous time in the system timezone.
+  sig { params(utc_offset: T.untyped).returns(Time) }
+  def localtime(utc_offset = nil); end
+
+  ### The following methods are generated dynamically and call to the corresponding Time methods.
+
+  sig { returns(Integer) }
+  def year; end
+
+  sig { returns(Integer) }
+  def mon; end
+
+  sig { returns(Integer) }
+  def month; end
+
+  sig { returns(Integer) }
+  def day; end
+
+  sig { returns(Integer) }
+  def mday; end
+
+  sig { returns(Integer) }
+  def wday; end
+
+  sig { returns(Integer) }
+  def yday; end
+
+  sig { returns(Integer) }
+  def hour; end
+
+  sig { returns(Integer) }
+  def min; end
+
+  sig { returns(Integer) }
+  def sec; end
+
+  sig { returns(Numeric) }
+  def usec; end
+
+  sig { returns(Numeric) }
+  def nsec; end
+
+  ### End dynamically-generated methods
+
+  # Returns true if the current time is within Daylight Savings Time for the
+  # specified time zone.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+  # Time.zone.parse("2012-5-30").dst?           # => true
+  # Time.zone.parse("2012-11-30").dst?          # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def dst?; end
+
+  # Returns true if the current time zone is set to UTC.
+  #
+  # ```ruby
+  # Time.zone = 'UTC'                           # => 'UTC'
+  # Time.zone.now.utc?                          # => true
+  # Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+  # Time.zone.now.utc?                          # => false
+  # ```
+  sig { returns(T::Boolean) }
+  def utc?; end
+
+  # Returns the offset from current time to UTC time in seconds.
+  sig { returns(Integer) }
+  def utc_offset; end
+
+  # Returns a formatted string of the offset from UTC, or an alternative
+  # string if the time zone is already UTC.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
+  # Time.zone.now.formatted_offset(true)       # => "-05:00"
+  # Time.zone.now.formatted_offset(false)      # => "-0500"
+  # Time.zone = 'UTC'                          # => "UTC"
+  # Time.zone.now.formatted_offset(true, "0")  # => "0"
+  # ```
+  sig { params(colon: T::Boolean, alternate_utc_string: T.untyped).returns(String) }
+  def formatted_offset(colon = true, alternate_utc_string = nil); end
+
+  # Returns the time zone abbreviation.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
+  # Time.zone.now.zone # => "EST"
+  # ```
+  sig { returns(String) }
+  def zone; end
+
+  # Returns a string of the object's date, time, zone, and offset from UTC.
+  #
+  # ```ruby
+  # Time.zone.now.inspect # => "Thu, 04 Dec 2014 11:00:25 EST -05:00"
+  # ```
+  sig { returns(String) }
+  def inspect; end
+
+  # Returns a string of the object's date and time in the ISO 8601 standard
+  # format.
+  #
+  # ```ruby
+  # Time.zone.now.xmlschema  # => "2014-12-04T11:02:37-05:00"
+  # ```
+  sig { params(fraction_digits: Integer).returns(String) }
+  def xmlschema(fraction_digits = 0); end
+
+  # Returns a string of the object's date and time in the format used by
+  # HTTP requests.
+  #
+  # ```ruby
+  # Time.zone.now.httpdate  # => "Tue, 01 Jan 2013 04:39:43 GMT"
+  # ```
+  sig { returns(String) }
+  def httpdate; end
+
+  # Returns a string of the object's date and time in the RFC 2822 standard
+  # format.
+  #
+  # ```ruby
+  # Time.zone.now.rfc2822  # => "Tue, 01 Jan 2013 04:51:39 +0000"
+  # ```
+  sig { returns(String) }
+  def rfc2822; end
+
+  # Returns a string of the object's date and time.
+  # Accepts an optional `format`:
+  # * `:default` - default value, mimics Ruby Time#to_s format.
+  # * `:db` - format outputs time in UTC :db time. See Time#to_formatted_s(:db).
+  # * Any key in `Time::DATE_FORMATS` can be used. See active_support/core_ext/time/conversions.rb.
+  sig { params(format: Symbol).returns(String) }
+  def to_s(format = :default); end
+
+  # Replaces `%Z` directive with +zone before passing to Time#strftime,
+  # so that zone information is correct.
+  sig { params(format: String).returns(String) }
+  def strftime(format); end
+
+  # Returns true if the current object's time is within the specified
+  # `min` and `max` time.
+  sig { params(min: T.untyped, max: T.untyped).returns(T::Boolean) }
+  def between?(min, max); end
+
+  # Returns true if the current object's time is in the past.
+  sig { returns(T::Boolean) }
+  def past?; end
+
+  # Returns true if the current object's time falls within
+  # the current day.
+  sig { returns(T::Boolean) }
+  def today?; end
+
+  # Returns true if the current object's time is in the future.
+  sig { returns(T::Boolean) }
+  def future?; end
+
+  # Returns `true` if `other` is equal to current object.
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def eql?(other); end
+
+  # Adds an interval of time to the current object's time and returns that
+  # value as a new TimeWithZone object.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
+  # now = Time.zone.now # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
+  # now + 1000          # => Sun, 02 Nov 2014 01:43:08 EDT -04:00
+  # ```
+  #
+  # If we're adding a Duration of variable length (i.e., years, months, days),
+  # move forward from #time, otherwise move forward from #utc, for accuracy
+  # when moving across DST boundaries.
+  #
+  # For instance, a time + 24.hours will advance exactly 24 hours, while a
+  # time + 1.day will advance 23-25 hours, depending on the day.
+  #
+  # ```ruby
+  # now + 24.hours      # => Mon, 03 Nov 2014 00:26:28 EST -05:00
+  # now + 1.day         # => Mon, 03 Nov 2014 01:26:28 EST -05:00
+  # ```
+  sig { params(other: T.untyped).returns(ActiveSupport::TimeWithZone) }
+  def +(other); end
+
+  # Subtracts an interval of time and returns a new TimeWithZone object unless
+  # the other value `acts_like?` time. Then it will return a Float of the difference
+  # between the two times that represents the difference between the current
+  # object's time and the `other` time.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
+  # now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28 EST -05:00
+  # now - 1000          # => Mon, 03 Nov 2014 00:09:48 EST -05:00
+  # ```
+  #
+  # If subtracting a Duration of variable length (i.e., years, months, days),
+  # move backward from #time, otherwise move backward from #utc, for accuracy
+  # when moving across DST boundaries.
+  #
+  # For instance, a time - 24.hours will go subtract exactly 24 hours, while a
+  # time - 1.day will subtract 23-25 hours, depending on the day.
+  #
+  # ```ruby
+  # now - 24.hours      # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
+  # now - 1.day         # => Sun, 02 Nov 2014 00:26:28 EDT -04:00
+  # ```
+  #
+  # If both the TimeWithZone object and the other value act like Time, a Float
+  # will be returned.
+  #
+  # ```ruby
+  # Time.zone.now - 1.day.ago # => 86399.999967
+  # ```
+  sig { params(other: T.untyped).returns(T.any(ActiveSupport::TimeWithZone, Float)) }
+  def -(other); end
+
+  # Subtracts an interval of time from the current object's time and returns
+  # the result as a new TimeWithZone object.
+  #
+  # ```ruby
+  # Time.zone = 'Eastern Time (US & Canada)' # => 'Eastern Time (US & Canada)'
+  # now = Time.zone.now # => Mon, 03 Nov 2014 00:26:28 EST -05:00
+  # now.ago(1000)       # => Mon, 03 Nov 2014 00:09:48 EST -05:00
+  # ```
+  #
+  # If we're subtracting a Duration of variable length (i.e., years, months,
+  # days), move backward from #time, otherwise move backward from #utc, for
+  # accuracy when moving across DST boundaries.
+  #
+  # For instance, `time.ago(24.hours)` will move back exactly 24 hours,
+  # while `time.ago(1.day)` will move back 23-25 hours, depending on
+  # the day.
+  #
+  # ```ruby
+  # now.ago(24.hours)   # => Sun, 02 Nov 2014 01:26:28 EDT -04:00
+  # now.ago(1.day)      # => Sun, 02 Nov 2014 00:26:28 EDT -04:00
+  # ```
+  sig { params(other: T.any(Numeric, ActiveSupport::Duration)).returns(ActiveSupport::TimeWithZone) }
+  def ago(other); end
+
+  # Returns Array of parts of Time in sequence of
+  # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
+  #
+  # ```ruby
+  # now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27 UTC +00:00
+  # now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
+  # ```
+  sig { returns([Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, T::Boolean, String]) }
+  def to_a; end
+
+  # Returns the object's date and time as a floating point number of seconds
+  # since the Epoch (January 1, 1970 00:00 UTC).
+  #
+  # ```ruby
+  # Time.zone.now.to_f # => 1417709320.285418
+  # ```
+  sig { returns(Float) }
+  def to_f; end
+
+  # Returns the object's date and time as an integer number of seconds
+  # since the Epoch (January 1, 1970 00:00 UTC).
+  #
+  # ```ruby
+  # Time.zone.now.to_i # => 1417709320
+  # ```
+  sig { returns(Integer) }
+  def to_i; end
+
+  # Returns the object's date and time as a rational number of seconds
+  # since the Epoch (January 1, 1970 00:00 UTC).
+  #
+  # ```ruby
+  # Time.zone.now.to_r # => (708854548642709/500000)
+  # ```
+  sig { returns(Rational) }
+  def to_r; end
+
+  sig { returns(Date) }
+  def to_date; end
+
+  # Returns an instance of DateTime with the timezone's UTC offset
+  #
+  # ```ruby
+  # Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
+  # Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
+  # ```
+  sig { returns(DateTime) }
+  def to_datetime; end
+
+  # Returns an instance of `Time`, either with the same UTC offset
+  # as `self` or in the local system timezone depending on the setting
+  # of `ActiveSupport.to_time_preserves_timezone`.
+  sig { returns(Time) }
+  def to_time; end
+
+  # Uses Date to provide precise Time calculations for years, months, and days according to the proleptic Gregorian calendar.
+  # The result is returned as a new `TimeWithZone` object.
+  # The options parameter takes a hash with any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.
+  # If advancing by a value of variable length (i.e., years, weeks, months, days), move forward from `time`, otherwise move forward
+  # from utc, for accuracy when moving across DST boundaries.
+  sig { params(options: T::Hash[Symbol, T.any(Integer, Float)]).returns(ActiveSupport::TimeWithZone) }
+  def advance(options); end
+end
+
+# defines some of the methods at https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/core_ext/date
+# this is not a complete definition!
+class Date
+  sig { params(options: T::Hash[Symbol, Integer]).returns(Date) }
+  def advance(options); end
+
+  # these are the sigs for Date- in the stdlib
+  # https://github.com/sorbet/sorbet/blob/3910f6cfd9935c9b42e2135e32e15ab8a6e5b9be/rbi/stdlib/date.rbi#L373
+  # note that if more sigs are added to sorbet you should replicate them here
+  # check sorbet master: https://github.com/sorbet/sorbet/blob/master/rbi/stdlib/date.rbi
+  sig {params(arg0: Numeric).returns(T.self_type)}
+  sig {params(arg0: Date).returns(Rational)}
+  # these sigs are added for activesupport users
+  sig {params(arg0: ActiveSupport::Duration).returns(T.self_type)}
+  def -(arg0); end
+end
+
+# defines some of the methods at https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/core_ext/time
+# this is not a complete definition!
+class Time
+  sig { returns(Time) }
+  def midnight; end
+
+  sig { returns(Time) }
+  def beginning_of_day; end
+
+  sig { params(options: T::Hash[Symbol, Integer]).returns(Time) }
+  def advance(options); end
+
+  sig { returns(Time) }
+  def at_midnight; end
+
+  sig { returns(Time) }
+  def at_beginning_of_day; end
+
+  sig { returns(Time) }
+  def middle_of_day; end
+
+  sig { returns(Time) }
+  def midday; end
+
+  sig { returns(Time) }
+  def noon; end
+
+  sig { returns(Time) }
+  def at_midday; end
+
+  sig { returns(Time) }
+  def at_noon; end
+
+  sig { returns(Time) }
+  def at_middle_of_day; end
+
+  # https://github.com/rails/rails/blob/v6.0.0/activesupport/lib/active_support/core_ext/date_and_time/zones.rb
+  # returns Time in the case zone is passed nil and ActiveSupport::TimeWithZone otherwise
+  sig { params(zone: T.nilable(T.any(String, ActiveSupport::TimeZone))).returns(T.any(ActiveSupport::TimeWithZone, Time)) }
+  def in_time_zone(zone = ::Time.zone); end
+
+  # these are the sigs for Time- in the stdlib
+  # https://github.com/sorbet/sorbet/blob/c3691753e4ce545e1eb66cbd3e55de67d8879b98/rbi/core/time.rbi#L347
+  # note that if more sigs are added to sorbet you should replicate them here
+  # check sorbet master: https://github.com/sorbet/sorbet/blob/master/rbi/core/time.rbi#L347
+  sig do
+    params(
+        arg0: Time,
+    )
+    .returns(Float)
+  end
+  sig do
+    params(
+        arg0: Numeric,
+    )
+    .returns(Time)
+  end
+  # these sigs are added for activesupport users
+  sig { params(arg0: ActiveSupport::Duration).returns(Time) }
+  def -(arg0); end
+
+  # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
+  # If `Time.zone` has not been set for the current request, returns the TimeZone specified in `config.time_zone`.
+  sig { returns(ActiveSupport::TimeZone) }
+  def self.zone; end
+
+  # Sets `Time.zone` to a TimeZone object for the current request/thread.
+  #
+  # This method accepts any of the following:
+  #
+  # * A Rails TimeZone object.
+  # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", `-5.hours`).
+  # * A TZInfo::Timezone object.
+  # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
+  #
+  # Here's an example of how you might set `Time.zone` on a per request basis and reset it when the request is done.
+  # `current_user.time_zone` just needs to return a string identifying the user's preferred time zone:
+  #
+  # ```ruby
+  # class ApplicationController < ActionController::Base
+  #   around_action :set_time_zone
+  #
+  #   def set_time_zone
+  #     if logged_in?
+  #       Time.use_zone(current_user.time_zone) { yield }
+  #     else
+  #       yield
+  #     end
+  #   end
+  # end
+  # ```
+  sig { params(time_zone: T.any(String, TZInfo::Timezone, ActiveSupport::TimeZone, ActiveSupport::Duration)).void }
+  def self.zone=(time_zone); end
+end
+
+class ActiveSupport::TimeZone
+  # Locate a specific time zone object. If the argument is a string, it
+  # is interpreted to mean the name of the timezone to locate. If it is a
+  # numeric value it is either the hour offset, or the second offset, of the
+  # timezone to find. (The first one with that offset will be returned.)
+  # Returns `nil` if no such time zone is known to the system.
+  sig { params(arg: T.any(String, Numeric, ActiveSupport::Duration)).returns(T.nilable(ActiveSupport::TimeZone)) }
+  def self.[](arg); end
+
+  # Returns an array of all TimeZone objects. There are multiple
+  # TimeZone objects per time zone, in many cases, to make it easier
+  # for users to find their own time zone.
+  sig { returns(T::Array[ActiveSupport::TimeZone]) }
+  def self.all; end
+
+  # A convenience method for returning a collection of TimeZone objects
+  # for time zones in the USA.
+  sig { returns(T::Array[ActiveSupport::TimeZone]) }
+  def self.us_zones; end
+
+  # A convenience method for returning a collection of TimeZone objects
+  # for time zones in the country specified by its ISO 3166-1 Alpha2 code.
+  sig { params(country_code: T.any(String, Symbol)).returns(T::Array[ActiveSupport::TimeZone]) }
+  def self.country_zones(country_code); end
+
+  # Returns an ActiveSupport::TimeWithZone instance representing the current
+  # time in the time zone represented by `self`.
+  #
+  # ```ruby
+  # Time.zone = 'Hawaii'  # => "Hawaii"
+  # Time.zone.now         # => Wed, 23 Jan 2008 20:24:27 HST -10:00
+  # ```
+  sig { returns(ActiveSupport::TimeWithZone) }
+  def now; end
+
+  # Returns the current date in this time zone.
+  sig { returns(Date) }
+  def today; end
+
+  # Returns the next date in this time zone.
+  sig { returns(Date) }
+  def tomorrow; end
+
+  # Returns the previous date in this time zone.
+  sig { returns(Date) }
+  def yesterday; end
+
+  # Method for creating new ActiveSupport::TimeWithZone instance in time zone
+  # of `self` from given values.
+  #
+  # ```ruby
+  # Time.zone = 'Hawaii'                    # => "Hawaii"
+  # Time.zone.local(2007, 2, 1, 15, 30, 45) # => Thu, 01 Feb 2007 15:30:45 HST -10:00
+  # ```
+  sig { params(args: T.untyped).returns(ActiveSupport::TimeWithZone) }
+  def local(*args); end
+end
+
+# defines some of the methods at https://github.com/rails/rails/tree/v6.0.0/activesupport/lib/active_support/core_ext/hash
+# this is not a complete definition!
+class Hash
+  sig { returns(T::Hash[String, T.untyped]) }
+  def stringify_keys; end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def stringify_keys!; end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def deep_stringify_keys; end
+
+  sig { returns(T::Hash[String, T.untyped]) }
+  def deep_stringify_keys!; end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def symbolize_keys; end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def symbolize_keys!; end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def deep_symbolize_keys; end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def deep_symbolize_keys!; end
+
+  # in an ideal world, `arg` would be the type of all keys, the 1st `T.untyped` would be
+  # the type of keys your block returns, and the 2nd `T.untyped` would be the type of values
+  # that the hash had.
+  sig { params(block: T.proc.params(arg: T.untyped).void).returns(T::Hash[T.untyped, T.untyped]) }
+  def deep_transform_keys(&block); end
+
+  sig { params(block: T.proc.params(arg: T.untyped).void).returns(T::Hash[T.untyped, T.untyped]) }
+  def deep_transform_keys!(&block); end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def to_options; end
+end
+
+class Integer
+  # Returns a Duration instance matching the number of months provided.
+  #
+  # ```ruby
+  # 2.months # => 2 months
+  # ```
+  sig { returns(ActiveSupport::Duration) }
+  def months; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def month; end
+
+  # Returns a Duration instance matching the number of years provided.
+  #
+  # ```ruby
+  # 2.years # => 2 years
+  # ```
+  sig { returns(ActiveSupport::Duration) }
+  def years; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def year; end
+end
+
+class Numeric
+  sig { returns(ActiveSupport::Duration) }
+  def second; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def seconds; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def minute; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def minutes; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def hour; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def hours; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def day; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def days; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def week; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def weeks; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def fortnight; end
+
+  sig { returns(ActiveSupport::Duration) }
+  def fortnights; end
+
+  sig { returns(T.self_type) }
+  def in_milliseconds; end
+
+  KILOBYTE = T.let(1024, Integer)
+  MEGABYTE = T.let(KILOBYTE * 1024, Integer)
+  GIGABYTE = T.let(MEGABYTE * 1024, Integer)
+  TERABYTE = T.let(GIGABYTE * 1024, Integer)
+  PETABYTE = T.let(TERABYTE * 1024, Integer)
+  EXABYTE  = T.let(PETABYTE * 1024, Integer)
+
+  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  #
+  # ```ruby
+  # 2.bytes # => 2
+  # ```
+  sig { returns(T.self_type) }
+  def byte; end
+
+  # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  #
+  # ```ruby
+  # 2.bytes # => 2
+  # ```
+  sig { returns(T.self_type) }
+  def bytes; end
+
+  # Returns the number of bytes equivalent to the kilobytes provided.
+  #
+  # ```ruby
+  # 2.kilobytes # => 2048
+  # ```
+  sig { returns(T.self_type) }
+  def kilobyte; end
+
+  # Returns the number of bytes equivalent to the kilobytes provided.
+  #
+  # ```ruby
+  # 2.kilobytes # => 2048
+  # ```
+  sig { returns(T.self_type) }
+  def kilobytes; end
+
+  # Returns the number of bytes equivalent to the megabytes provided.
+  #
+  # ```ruby
+  # 2.megabytes # => 2_097_152
+  # ```
+  sig { returns(T.self_type) }
+  def megabyte; end
+
+  # Returns the number of bytes equivalent to the megabytes provided.
+  #
+  # ```ruby
+  # 2.megabytes # => 2_097_152
+  # ```
+  sig { returns(T.self_type) }
+  def megabytes; end
+
+  # Returns the number of bytes equivalent to the gigabytes provided.
+  #
+  # ```ruby
+  # 2.gigabytes # => 2_147_483_648
+  # ```
+  sig { returns(T.self_type) }
+  def gigabyte; end
+
+  # Returns the number of bytes equivalent to the gigabytes provided.
+  #
+  # ```ruby
+  # 2.gigabytes # => 2_147_483_648
+  # ```
+  sig { returns(T.self_type) }
+  def gigabytes; end
+
+  # Returns the number of bytes equivalent to the terabytes provided.
+  #
+  # ```ruby
+  # 2.terabytes # => 2_199_023_255_552
+  # ```
+  sig { returns(T.self_type) }
+  def terabyte; end
+
+  # Returns the number of bytes equivalent to the terabytes provided.
+  #
+  # ```ruby
+  # 2.terabytes # => 2_199_023_255_552
+  # ```
+  sig { returns(T.self_type) }
+  def terabytes; end
+
+  # Returns the number of bytes equivalent to the petabytes provided.
+  #
+  # ```ruby
+  # 2.petabytes # => 2_251_799_813_685_248
+  # ```
+  sig { returns(T.self_type) }
+  def petabyte; end
+
+  # Returns the number of bytes equivalent to the petabytes provided.
+  #
+  # ```ruby
+  # 2.petabytes # => 2_251_799_813_685_248
+  # ```
+  sig { returns(T.self_type) }
+  def petabytes; end
+
+  # Returns the number of bytes equivalent to the exabytes provided.
+  #
+  # ```ruby
+  # 2.exabytes # => 2_305_843_009_213_693_952
+  # ```
+  sig { returns(T.self_type) }
+  def exabyte; end
+
+  # Returns the number of bytes equivalent to the exabytes provided.
+  #
+  # ```ruby
+  # 2.exabytes # => 2_305_843_009_213_693_952
+  # ```
+  sig { returns(T.self_type) }
+  def exabytes; end
+end
+
+module Enumerable
+  # https://github.com/rails/rails/blob/v5.2.3/activesupport/lib/active_support/core_ext/enumerable.rb#L64..L72
+  # the case where a block isn't given isn't handled - that seems like an unlikely case
+  sig do
+    type_parameters(:key).params(
+      block: T.proc.params(o: Enumerable::Elem).returns(T.type_parameter(:key))
+    ).returns(
+      T::Hash[T.type_parameter(:key), Enumerable::Elem]
+    )
+  end
+  def index_by(&block); end
+end
+
+class ActiveSupport::Duration
+  # Returns the number of seconds that this Duration represents.
+  #
+  # ```ruby
+  # 1.minute.to_i   # => 60
+  # 1.hour.to_i     # => 3600
+  # 1.day.to_i      # => 86400
+  # ```
+  #
+  # Note that this conversion makes some assumptions about the
+  # duration of some periods, e.g. months are always 1/12 of year
+  # and years are 365.2425 days:
+  #
+  # ```ruby
+  # # equivalent to (1.year / 12).to_i
+  # 1.month.to_i    # => 2629746
+  #
+  # # equivalent to 365.2425.days.to_i
+  # 1.year.to_i     # => 31556952
+  # ```
+  #
+  # In such cases, Ruby's core
+  # [Date](https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html) and
+  # [Time](https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html) should be used for precision
+  # date and time arithmetic.
+  sig { returns(Integer) }
+  def to_i; end
+
+  sig { returns(Float) }
+  def to_f; end
+
+  # Returns the amount of seconds a duration covers as a string.
+  # For more information check to_i method.
+  #
+  # ```ruby
+  # 1.day.to_s # => "86400"
+  # ```
+  sig { returns(String) }
+  def to_s; end
+
+  # Creates a new Duration from string formatted according to ISO 8601 Duration.
+  #
+  # See [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) for more information.
+  # This method allows negative parts to be present in pattern.
+  # If invalid string is provided, it will raise `ActiveSupport::Duration::ISO8601Parser::ParsingError`.
+  sig { params(iso8601duration: String).returns(ActiveSupport::Duration) }
+  def self.parse(iso8601duration); end
+
+  # Creates a new Duration from a seconds value that is converted
+  # to the individual parts:
+  #
+  # ```ruby
+  # ActiveSupport::Duration.build(31556952).parts # => {:years=>1}
+  # ActiveSupport::Duration.build(2716146).parts  # => {:months=>1, :days=>1}
+  # ```
+  sig { params(value: Numeric).returns(ActiveSupport::Duration) }
+  def self.build(value); end
+
+  # Returns `true` if `other` is also a Duration instance, which has the
+  # same parts as this one.
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def eql?(other); end
+
+  # Compares one Duration with another or a Numeric to this Duration.
+  # Numeric values are treated as seconds.
+  sig { params(other: T.any(ActiveSupport::Duration, Numeric)).returns(Integer) }
+  def <=>(other); end
+
+  # Adds another Duration or a Numeric to this Duration. Numeric values
+  # are treated as seconds.
+  sig { params(other: T.any(ActiveSupport::Duration, Numeric)).returns(ActiveSupport::Duration) }
+  def +(other); end
+
+  # Subtracts another Duration or a Numeric from this Duration. Numeric
+  # values are treated as seconds.
+  sig { params(other: T.any(ActiveSupport::Duration, Numeric)).returns(ActiveSupport::Duration) }
+  def -(other); end
+
+  # Multiplies this Duration by a Numeric and returns a new Duration.
+  sig { params(other: Numeric).returns(ActiveSupport::Duration) }
+  def *(other); end
+
+  # Divides this Duration by a Numeric and returns a new Duration.
+  sig { params(other: Numeric).returns(ActiveSupport::Duration) }
+  def /(other); end
+
+  # Returns the modulo of this Duration by another Duration or Numeric.
+  # Numeric values are treated as seconds.
+  sig { params(other: T.any(ActiveSupport::Duration, Numeric)).returns(ActiveSupport::Duration) }
+  def %(other); end
+
+  # Returns `true` if `other` is also a Duration instance with the
+  # same `value`, or if `other == value`.
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  # Build ISO 8601 Duration string for this duration.
+  # The `precision` parameter can be used to limit seconds' precision of duration.
+  sig { params(precision: T.nilable(Integer)).returns(String) }
+  def iso8601(precision: nil); end
+
+  sig { params(time: T.any(ActiveSupport::TimeWithZone, Date)).returns(ActiveSupport::TimeWithZone) }
+  def from_now(time = Time.current); end
+
+  sig { params(time: T.any(ActiveSupport::TimeWithZone, Date)).returns(ActiveSupport::TimeWithZone) }
+  def ago(time = Time.current); end
+end
+
+module Benchmark
+  extend T::Sig
+
+  sig { params(block: T.proc.void).returns(Float) }
+  def self.ms(&block); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi b/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi
new file mode 100644
index 0000000..4abc7fc
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi
@@ -0,0 +1,108 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/minitest/all/minitest.rbi
+#
+# typed: strong
+
+module Minitest
+  class Runnable
+  end
+
+  class Test < Runnable
+    include Minitest::Assertions
+  end
+
+  sig { void }
+  def self.autorun; end
+
+  sig { params(args: T::Array[String]).returns(T::Boolean) }
+  def self.run(args = []); end
+end
+
+module Minitest::Assertions
+  extend T::Sig
+
+  sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) }
+  def assert(test, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_empty(exp, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      act: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_equal(exp, act, msg = nil); end
+
+  sig do
+    params(
+      collection: T::Enumerable[T.untyped],
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_includes(collection, obj, msg = nil); end
+
+  sig do
+    params(
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def assert_nil(obj, msg = nil); end
+
+  sig do
+    params(
+      exp: T.untyped
+    ).returns(TrueClass)
+  end
+  def assert_raises(*exp); end
+
+  sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) }
+  def refute(test, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_empty(exp, msg = nil); end
+
+  sig do
+    params(
+      exp: BasicObject,
+      act: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_equal(exp, act, msg = nil); end
+
+  sig do
+    params(
+      collection: T::Enumerable[T.untyped],
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_includes(collection, obj, msg = nil); end
+
+  sig do
+    params(
+      obj: BasicObject,
+      msg: T.nilable(String)
+    ).returns(TrueClass)
+  end
+  def refute_nil(obj, msg = nil); end
+end
diff --git a/sorbet/rbi/todo.rbi b/sorbet/rbi/todo.rbi
new file mode 100644
index 0000000..66a909a
--- /dev/null
+++ b/sorbet/rbi/todo.rbi
@@ -0,0 +1,13 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi todo
+
+# typed: strong
+module ::Anonymous_Delegator_10; end
+module ::Anonymous_Delegator_6; end
+module ::Anonymous_Delegator_7; end
+module ::Anonymous_Delegator_8; end
+module ::Anonymous_Delegator_9; end
+module ActiveRecord::Persistence::ActionController::Parameters; end
+module T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions; end
+module T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions; end
+module TappingDevice::Output::Payload::UNDEFINED; end
diff --git a/spec/configurable_spec.rb b/spec/configurable_spec.rb
index 650ebbd..71365b0 100644
--- a/spec/configurable_spec.rb
+++ b/spec/configurable_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 
 RSpec.describe TappingDevice do
diff --git a/spec/contexts/order_creation.rb b/spec/contexts/order_creation.rb
index c30ee0c..1f7d2e7 100644
--- a/spec/contexts/order_creation.rb
+++ b/spec/contexts/order_creation.rb
@@ -1,3 +1,4 @@
+# typed: true
 RSpec.shared_context "order creation" do
   class Promotion; end
   class Order;end
diff --git a/spec/matchers/write_to_file_matcher.rb b/spec/matchers/write_to_file_matcher.rb
index d6e521a..74286ff 100644
--- a/spec/matchers/write_to_file_matcher.rb
+++ b/spec/matchers/write_to_file_matcher.rb
@@ -1,3 +1,4 @@
+# typed: false
 require 'rspec/expectations'
 
 RSpec::Matchers.define :write_to_file do |filepath, expected_content|
diff --git a/spec/methods/tap_assoc_spec.rb b/spec/methods/tap_assoc_spec.rb
index 3878a2d..53ec087 100644
--- a/spec/methods/tap_assoc_spec.rb
+++ b/spec/methods/tap_assoc_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require "shared_examples/stoppable_examples"
 require "shared_examples/optionable_examples"
diff --git a/spec/methods/tap_init_spec.rb b/spec/methods/tap_init_spec.rb
index c8a075d..7261be1 100644
--- a/spec/methods/tap_init_spec.rb
+++ b/spec/methods/tap_init_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require "shared_examples/stoppable_examples"
 require "shared_examples/optionable_examples"
diff --git a/spec/methods/tap_on_spec.rb b/spec/methods/tap_on_spec.rb
index 5a90b3f..219d6bd 100644
--- a/spec/methods/tap_on_spec.rb
+++ b/spec/methods/tap_on_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require "shared_examples/stoppable_examples"
 require "shared_examples/optionable_examples"
diff --git a/spec/methods/tap_passed_spec.rb b/spec/methods/tap_passed_spec.rb
index 9394aea..3f7fccb 100644
--- a/spec/methods/tap_passed_spec.rb
+++ b/spec/methods/tap_passed_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require "shared_examples/stoppable_examples"
 require "shared_examples/optionable_examples"
diff --git a/spec/model.rb b/spec/model.rb
index a0da171..baf2bb7 100644
--- a/spec/model.rb
+++ b/spec/model.rb
@@ -1,3 +1,4 @@
+# typed: true
 require 'active_record'
 
 # This connection will do for database-independent bug reports.
diff --git a/spec/output_payload_spec.rb b/spec/output_payload_spec.rb
index 9fcbd37..e81cfcf 100644
--- a/spec/output_payload_spec.rb
+++ b/spec/output_payload_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 
 RSpec.describe TappingDevice::Output::Payload do
diff --git a/spec/payload_spec.rb b/spec/payload_spec.rb
index 7a10b41..a3d822e 100644
--- a/spec/payload_spec.rb
+++ b/spec/payload_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 
 RSpec.describe TappingDevice::Payload do
diff --git a/spec/performance_spec.rb b/spec/performance_spec.rb
index f03c7d6..a86d9b5 100644
--- a/spec/performance_spec.rb
+++ b/spec/performance_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require 'benchmark'
 
diff --git a/spec/shared_examples/optionable_examples.rb b/spec/shared_examples/optionable_examples.rb
index 7db7f9b..819851b 100644
--- a/spec/shared_examples/optionable_examples.rb
+++ b/spec/shared_examples/optionable_examples.rb
@@ -1,3 +1,4 @@
+# typed: false
 RSpec.shared_examples "optionable" do
   context "with options - with_trace_to: 5" do
     it "stores trace until given index" do
diff --git a/spec/shared_examples/stoppable_examples.rb b/spec/shared_examples/stoppable_examples.rb
index 98b78fd..9d5a232 100644
--- a/spec/shared_examples/stoppable_examples.rb
+++ b/spec/shared_examples/stoppable_examples.rb
@@ -1,3 +1,4 @@
+# typed: false
 RSpec.shared_examples "stoppable" do
   it "stopps tapping when stop! is called" do
     device = send(subject, target)
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 241f012..eedd735 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "tapping_device"
 require "tapping_device/trackable"
 require "bundler/setup"
diff --git a/spec/tapping_device_spec.rb b/spec/tapping_device_spec.rb
index 96f2275..620e45a 100644
--- a/spec/tapping_device_spec.rb
+++ b/spec/tapping_device_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 
 RSpec.describe TappingDevice do
diff --git a/spec/trackable/output_helpers_spec.rb b/spec/trackable/output_helpers_spec.rb
index 2a9c9df..a1ae460 100644
--- a/spec/trackable/output_helpers_spec.rb
+++ b/spec/trackable/output_helpers_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 require "contexts/order_creation"
 
diff --git a/spec/trackable/tap_helpers_spec.rb b/spec/trackable/tap_helpers_spec.rb
index 8a3c9f9..eeb75fc 100644
--- a/spec/trackable/tap_helpers_spec.rb
+++ b/spec/trackable/tap_helpers_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require "spec_helper"
 
 RSpec.describe TappingDevice::Trackable do
diff --git a/tapping_device.gemspec b/tapping_device.gemspec
index 3768558..f08e70c 100644
--- a/tapping_device.gemspec
+++ b/tapping_device.gemspec
@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "pry" # for using Method#source in MutationTracker
   spec.add_dependency "activesupport"
   spec.add_dependency "pastel"
+  spec.add_dependency "sorbet-runtime"
 
   spec.add_development_dependency "sqlite3", ">= 1.3.6"
   spec.add_development_dependency "database_cleaner"