phlex-stimulus 0.1.0

data/sorbet/rbi/gems/railties@8.1.3.rbi

@@ -0,0 +1,3507 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `railties` gem.
+# Please instead update this file by running `bin/tapioca gem railties`.
+
+
+# :include: ../README.rdoc
+# :enddoc:
+# :enddoc:
+#
+# pkg:gem/railties#lib/rails/gem_version.rb:3
+module Rails
+  extend ::ActiveSupport::Autoload
+  extend ::ActiveSupport::Benchmarkable
+
+  class << self
+    # pkg:gem/railties#lib/rails.rb:43
+    def app_class; end
+
+    # pkg:gem/railties#lib/rails.rb:43
+    def app_class=(_arg0); end
+
+    # pkg:gem/railties#lib/rails.rb:44
+    def application; end
+
+    # pkg:gem/railties#lib/rails.rb:42
+    def application=(_arg0); end
+
+    # pkg:gem/railties#lib/rails.rb:133
+    def autoloaders; end
+
+    # pkg:gem/railties#lib/rails.rb:55
+    def backtrace_cleaner; end
+
+    # pkg:gem/railties#lib/rails.rb:43
+    def cache; end
+
+    # pkg:gem/railties#lib/rails.rb:43
+    def cache=(_arg0); end
+
+    # The Configuration instance used to configure the \Rails environment
+    #
+    # pkg:gem/railties#lib/rails.rb:51
+    def configuration; end
+
+    # pkg:gem/railties#lib/rails/deprecator.rb:4
+    def deprecator; end
+
+    # Returns the current \Rails environment.
+    #
+    #   Rails.env # => "development"
+    #   Rails.env.development? # => true
+    #   Rails.env.production? # => false
+    #   Rails.env.local? # => true              true for "development" and "test", false for anything else
+    #
+    # pkg:gem/railties#lib/rails.rb:74
+    def env; end
+
+    # Sets the \Rails environment.
+    #
+    #   Rails.env = "staging" # => "staging"
+    #
+    # pkg:gem/railties#lib/rails.rb:81
+    def env=(environment); end
+
+    # Returns the ActiveSupport::ErrorReporter of the current \Rails project,
+    # otherwise it returns +nil+ if there is no project.
+    #
+    #   Rails.error.handle(IOError) do
+    #     # ...
+    #   end
+    #   Rails.error.report(error)
+    #
+    # pkg:gem/railties#lib/rails.rb:92
+    def error; end
+
+    # Returns the ActiveSupport::EventReporter of the current \Rails project,
+    # otherwise it returns +nil+ if there is no project.
+    #
+    #   Rails.event.notify("my_event", { message: "Hello, world!" })
+    #
+    # pkg:gem/railties#lib/rails.rb:100
+    def event; end
+
+    # Returns the currently loaded version of \Rails as a +Gem::Version+.
+    #
+    # pkg:gem/railties#lib/rails/gem_version.rb:5
+    def gem_version; end
+
+    # Returns all \Rails groups for loading based on:
+    #
+    # * The \Rails environment;
+    # * The environment variable RAILS_GROUPS;
+    # * The optional envs given as argument and the hash with group dependencies;
+    #
+    #  Rails.groups assets: [:development, :test]
+    #  # => [:default, "development", :assets] for Rails.env == "development"
+    #  # => [:default, "production"]           for Rails.env == "production"
+    #
+    # pkg:gem/railties#lib/rails.rb:113
+    def groups(*groups); end
+
+    # pkg:gem/railties#lib/rails.rb:48
+    def initialize!(*_arg0, **_arg1, &_arg2); end
+
+    # pkg:gem/railties#lib/rails.rb:48
+    def initialized?(*_arg0, **_arg1, &_arg2); end
+
+    # pkg:gem/railties#lib/rails.rb:43
+    def logger; end
+
+    # pkg:gem/railties#lib/rails.rb:43
+    def logger=(_arg0); end
+
+    # Returns a Pathname object of the public folder of the current
+    # \Rails project, otherwise it returns +nil+ if there is no project:
+    #
+    #   Rails.public_path
+    #     # => #<Pathname:/Users/someuser/some/path/project/public>
+    #
+    # pkg:gem/railties#lib/rails.rb:129
+    def public_path; end
+
+    # Returns a Pathname object of the current \Rails project,
+    # otherwise it returns +nil+ if there is no project:
+    #
+    #   Rails.root
+    #     # => #<Pathname:/Users/someuser/some/path/project>
+    #
+    # pkg:gem/railties#lib/rails.rb:64
+    def root; end
+
+    # Returns the currently loaded version of \Rails as a string.
+    #
+    # pkg:gem/railties#lib/rails/version.rb:7
+    def version; end
+  end
+end
+
+# An Engine with the responsibility of coordinating the whole boot process.
+#
+# == Initialization
+#
+# Rails::Application is responsible for executing all railties and engines
+# initializers. It also executes some bootstrap initializers (check
+# Rails::Application::Bootstrap) and finishing initializers, after all the others
+# are executed (check Rails::Application::Finisher).
+#
+# == \Configuration
+#
+# Besides providing the same configuration as Rails::Engine and Rails::Railtie,
+# the application object has several specific configurations, for example
+# +enable_reloading+, +consider_all_requests_local+, +filter_parameters+,
+# +logger+, and so forth.
+#
+# Check Rails::Application::Configuration to see them all.
+#
+# == Routes
+#
+# The application object is also responsible for holding the routes and reloading routes
+# whenever the files change in development.
+#
+# == Middlewares
+#
+# The Application is also responsible for building the middleware stack.
+#
+# == Booting process
+#
+# The application is also responsible for setting up and executing the booting
+# process. From the moment you require <tt>config/application.rb</tt> in your app,
+# the booting process goes like this:
+#
+# 1.  <tt>require "config/boot.rb"</tt> to set up load paths.
+# 2.  +require+ railties and engines.
+# 3.  Define +Rails.application+ as <tt>class MyApp::Application < Rails::Application</tt>.
+# 4.  Run +config.before_configuration+ callbacks.
+# 5.  Load <tt>config/environments/ENV.rb</tt>.
+# 6.  Run +config.before_initialize+ callbacks.
+# 7.  Run <tt>Railtie#initializer</tt> defined by railties, engines, and application.
+#     One by one, each engine sets up its load paths and routes, and runs its <tt>config/initializers/*</tt> files.
+# 8.  Custom <tt>Railtie#initializers</tt> added by railties, engines, and applications are executed.
+# 9.  Build the middleware stack and run +to_prepare+ callbacks.
+# 10. Run +config.before_eager_load+ and +eager_load!+ if +eager_load+ is +true+.
+# 11. Run +config.after_initialize+ callbacks.
+#
+# pkg:gem/railties#lib/rails/application.rb:60
+class Rails::Application < ::Rails::Engine
+  # pkg:gem/railties#lib/rails/application.rb:107
+  def initialize(initial_variable_values = T.unsafe(nil), &block); end
+
+  # pkg:gem/railties#lib/rails/application.rb:98
+  def assets; end
+
+  # pkg:gem/railties#lib/rails/application.rb:98
+  def assets=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application.rb:100
+  def autoloaders; end
+
+  # pkg:gem/railties#lib/rails/application.rb:560
+  def build_middleware_stack; end
+
+  # pkg:gem/railties#lib/rails/application.rb:453
+  def config; end
+
+  # pkg:gem/railties#lib/rails/application.rb:457
+  def config=(_arg0); end
+
+  # Convenience for loading config/foo.yml for the current \Rails env.
+  # Example:
+  #
+  #     # config/exception_notification.yml:
+  #     production:
+  #       url: http://127.0.0.1:8080
+  #       namespace: my_app_production
+  #
+  #     development:
+  #       url: http://localhost:3001
+  #       namespace: my_app_development
+  #
+  # <code></code>
+  #
+  #     # config/environments/production.rb
+  #     Rails.application.configure do
+  #       config.middleware.use ExceptionNotifier, config_for(:exception_notification)
+  #     end
+  #
+  # You can also store configurations in a shared section which will be merged
+  # with the environment configuration
+  #
+  #     # config/example.yml
+  #     shared:
+  #       foo:
+  #         bar:
+  #           baz: 1
+  #
+  #     development:
+  #       foo:
+  #         bar:
+  #           qux: 2
+  #
+  # <code></code>
+  #
+  #     # development environment
+  #     Rails.application.config_for(:example)[:foo][:bar]
+  #     # => { baz: 1, qux: 2 }
+  #
+  # pkg:gem/railties#lib/rails/application.rb:290
+  def config_for(name, env: T.unsafe(nil)); end
+
+  # Sends any console called in the instance of a new application up
+  # to the +console+ method defined in Rails::Railtie.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:373
+  def console(&blk); end
+
+  # Returns an ActiveSupport::EncryptedConfiguration instance for the
+  # credentials file specified by +config.credentials.content_path+.
+  #
+  # By default, +config.credentials.content_path+ will point to either
+  # <tt>config/credentials/#{environment}.yml.enc</tt> for the current
+  # environment (for example, +config/credentials/production.yml.enc+ for the
+  # +production+ environment), or +config/credentials.yml.enc+ if that file
+  # does not exist.
+  #
+  # The encryption key is taken from either <tt>ENV["RAILS_MASTER_KEY"]</tt>,
+  # or from the file specified by +config.credentials.key_path+. By default,
+  # +config.credentials.key_path+ will point to either
+  # <tt>config/credentials/#{environment}.key</tt> for the current
+  # environment, or +config/master.key+ if that file does not exist.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:497
+  def credentials; end
+
+  # Returns an ActiveSupport::EncryptedConfiguration instance for the
+  # credentials file specified by +config.credentials.content_path+.
+  #
+  # By default, +config.credentials.content_path+ will point to either
+  # <tt>config/credentials/#{environment}.yml.enc</tt> for the current
+  # environment (for example, +config/credentials/production.yml.enc+ for the
+  # +production+ environment), or +config/credentials.yml.enc+ if that file
+  # does not exist.
+  #
+  # The encryption key is taken from either <tt>ENV["RAILS_MASTER_KEY"]</tt>,
+  # or from the file specified by +config.credentials.key_path+. By default,
+  # +config.credentials.key_path+ will point to either
+  # <tt>config/credentials/#{environment}.key</tt> for the current
+  # environment, or +config/master.key+ if that file does not exist.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:458
+  def credentials=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application.rb:102
+  def default_url_options(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/application.rb:102
+  def default_url_options=(arg); end
+
+  # A managed collection of deprecators (ActiveSupport::Deprecation::Deprecators).
+  # The collection's configuration methods affect all deprecators in the
+  # collection. Additionally, the collection's +silence+ method silences all
+  # deprecators in the collection for the duration of a given block.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:246
+  def deprecators; end
+
+  # Eager loads the application code.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:555
+  def eager_load!; end
+
+  # Returns an ActiveSupport::EncryptedConfiguration instance for an encrypted
+  # file. By default, the encryption key is taken from either
+  # <tt>ENV["RAILS_MASTER_KEY"]</tt>, or from the +config/master.key+ file.
+  #
+  #   my_config = Rails.application.encrypted("config/my_config.enc")
+  #
+  #   my_config.read
+  #   # => "foo:\n  bar: 123\n"
+  #
+  #   my_config.foo.bar
+  #   # => 123
+  #
+  # Encrypted files can be edited with the <tt>bin/rails encrypted:edit</tt>
+  # command. (See the output of <tt>bin/rails encrypted:edit --help</tt> for
+  # more information.)
+  #
+  # pkg:gem/railties#lib/rails/application.rb:516
+  def encrypted(path, key_path: T.unsafe(nil), env_key: T.unsafe(nil)); end
+
+  # Stores some of the \Rails initial environment parameters which
+  # will be used by middlewares and engines to configure themselves.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:319
+  def env_config; end
+
+  # pkg:gem/railties#lib/rails/application.rb:100
+  def executor; end
+
+  # Sends any generators called in the instance of a new application up
+  # to the +generators+ method defined in Rails::Railtie.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:379
+  def generators(&blk); end
+
+  # pkg:gem/railties#lib/rails/application.rb:529
+  def helpers_paths; end
+
+  # Initialize the application passing the given group. By default, the
+  # group is :default
+  #
+  # pkg:gem/railties#lib/rails/application.rb:440
+  def initialize!(group = T.unsafe(nil)); end
+
+  # Returns true if the application is initialized.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:132
+  def initialized?; end
+
+  # Sends the initializers to the +initializer+ method defined in the
+  # Rails::Initializable module. Each Rails::Application class has its own
+  # set of initializers, as defined by the Initializable module.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:361
+  def initializer(name, opts = T.unsafe(nil), &block); end
+
+  # pkg:gem/railties#lib/rails/application.rb:447
+  def initializers; end
+
+  # Sends the +isolate_namespace+ method up to the class method.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:390
+  def isolate_namespace(mod); end
+
+  # Returns a key generator (ActiveSupport::CachingKeyGenerator) for a
+  # specified +secret_key_base+. The return value is memoized, so additional
+  # calls with the same +secret_key_base+ will return the same key generator
+  # instance.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:174
+  def key_generator(secret_key_base = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/application.rb:549
+  def load_generators(app = T.unsafe(nil)); end
+
+  # Returns a message verifier object.
+  #
+  # This verifier can be used to generate and verify signed messages in the application.
+  #
+  # It is recommended not to use the same verifier for different things, so you can get different
+  # verifiers passing the +verifier_name+ argument.
+  #
+  # For instance, +ActiveStorage::Blob.signed_id_verifier+ is implemented using this feature, which assures that
+  # the IDs strings haven't been tampered with and are safe to use in a finder.
+  #
+  # See the ActiveSupport::MessageVerifier documentation for more information.
+  #
+  # ==== Parameters
+  #
+  # * +verifier_name+ - the name of the message verifier.
+  #
+  # ==== Examples
+  #
+  #     message = Rails.application.message_verifier('my_purpose').generate('data to sign against tampering')
+  #     Rails.application.message_verifier('my_purpose').verify(message)
+  #     # => 'data to sign against tampering'
+  #
+  # pkg:gem/railties#lib/rails/application.rb:238
+  def message_verifier(verifier_name); end
+
+  # Returns a message verifier factory (ActiveSupport::MessageVerifiers). This
+  # factory can be used as a central point to configure and create message
+  # verifiers (ActiveSupport::MessageVerifier) for your application.
+  #
+  # By default, message verifiers created by this factory will generate
+  # messages using the default ActiveSupport::MessageVerifier options. You can
+  # override these options with a combination of
+  # ActiveSupport::MessageVerifiers#clear_rotations and
+  # ActiveSupport::MessageVerifiers#rotate. However, this must be done prior
+  # to building any message verifier instances. For example, in a
+  # +before_initialize+ block:
+  #
+  #   # Use `url_safe: true` when generating messages
+  #   config.before_initialize do |app|
+  #     app.message_verifiers.clear_rotations
+  #     app.message_verifiers.rotate(url_safe: true)
+  #   end
+  #
+  # Message verifiers created by this factory will always use a secret derived
+  # from #secret_key_base when generating messages. +clear_rotations+ will not
+  # affect this behavior. However, older +secret_key_base+ values can be
+  # rotated for verifying messages:
+  #
+  #   # Fall back to old `secret_key_base` when verifying messages
+  #   config.before_initialize do |app|
+  #     app.message_verifiers.rotate(secret_key_base: "old secret_key_base")
+  #   end
+  #
+  # pkg:gem/railties#lib/rails/application.rb:210
+  def message_verifiers; end
+
+  # Return an array of railties respecting the order they're loaded
+  # and the order specified by the +railties_order+ config.
+  #
+  # While running initializers we need engines in reverse order here when
+  # copying migrations from railties ; we need them in the order given by
+  # +railties_order+.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:545
+  def migration_railties; end
+
+  # Returns the dasherized application name.
+  #
+  #   MyApp::Application.new.name => "my-app"
+  #
+  # pkg:gem/railties#lib/rails/application.rb:139
+  def name; end
+
+  # If you try to define a set of Rake tasks on the instance, these will get
+  # passed up to the Rake tasks defined on the application's class.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:354
+  def rake_tasks(&block); end
+
+  # Reload application routes regardless if they changed or not.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:158
+  def reload_routes!; end
+
+  # pkg:gem/railties#lib/rails/application.rb:166
+  def reload_routes_unless_loaded; end
+
+  # pkg:gem/railties#lib/rails/application.rb:100
+  def reloader; end
+
+  # pkg:gem/railties#lib/rails/application.rb:100
+  def reloaders; end
+
+  # pkg:gem/railties#lib/rails/application.rb:416
+  def require_environment!; end
+
+  # pkg:gem/railties#lib/rails/application.rb:421
+  def routes_reloader; end
+
+  # pkg:gem/railties#lib/rails/application.rb:143
+  def run_load_hooks!; end
+
+  # Sends any runner called in the instance of a new application up
+  # to the +runner+ method defined in Rails::Railtie.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:367
+  def runner(&blk); end
+
+  # pkg:gem/railties#lib/rails/application.rb:98
+  def sandbox; end
+
+  # pkg:gem/railties#lib/rails/application.rb:98
+  def sandbox=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application.rb:99
+  def sandbox?; end
+
+  # The secret_key_base is used as the input secret to the application's key generator, which in turn
+  # is used to create all ActiveSupport::MessageVerifier and ActiveSupport::MessageEncryptor instances,
+  # including the ones that sign and encrypt cookies.
+  #
+  # We look for it first in <tt>ENV["SECRET_KEY_BASE"]</tt>, then in
+  # +credentials.secret_key_base+. For most applications, the correct place
+  # to store it is in the encrypted credentials file.
+  #
+  # In development and test, if the secret_key_base is still empty, it is
+  # randomly generated and stored in a temporary file in
+  # <tt>tmp/local_secret.txt</tt>.
+  #
+  # Generating a random secret_key_base and storing it in
+  # <tt>tmp/local_secret.txt</tt> can also be triggered by setting
+  # <tt>ENV["SECRET_KEY_BASE_DUMMY"]</tt>. This is useful when precompiling
+  # assets for production as part of a build step that otherwise does not
+  # need access to the production secrets.
+  #
+  # Dockerfile example: <tt>RUN SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile</tt>.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:479
+  def secret_key_base; end
+
+  # Sends any server called in the instance of a new application up
+  # to the +server+ method defined in Rails::Railtie.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:385
+  def server(&blk); end
+
+  # pkg:gem/railties#lib/rails/application.rb:525
+  def to_app; end
+
+  # Returns an array of file paths appended with a hash of
+  # directories-extensions suitable for ActiveSupport::FileUpdateChecker
+  # API.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:428
+  def watchable_args; end
+
+  protected
+
+  # pkg:gem/railties#lib/rails/application.rb:628
+  def default_middleware_stack; end
+
+  # pkg:gem/railties#lib/rails/application.rb:633
+  def ensure_generator_templates_added; end
+
+  # Returns the ordered railties for this application considering railties_order.
+  #
+  # pkg:gem/railties#lib/rails/application.rb:594
+  def ordered_railties; end
+
+  # pkg:gem/railties#lib/rails/application.rb:616
+  def railties_initializers(current); end
+
+  # pkg:gem/railties#lib/rails/application.rb:583
+  def run_console_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/application.rb:573
+  def run_generators_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/application.rb:578
+  def run_runner_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/application.rb:588
+  def run_server_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/application.rb:562
+  def run_tasks_blocks(app); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application.rb:646
+  def build_middleware; end
+
+  # pkg:gem/railties#lib/rails/application.rb:639
+  def build_request(env); end
+
+  # pkg:gem/railties#lib/rails/application.rb:650
+  def coerce_same_site_protection(protection); end
+
+  # pkg:gem/railties#lib/rails/application.rb:654
+  def filter_parameters; end
+
+  class << self
+    # This method is called just after an application inherits from Rails::Application,
+    # allowing the developer to load classes in lib and use them during application
+    # configuration.
+    #
+    #   class MyApplication < Rails::Application
+    #     require "my_backend" # in lib/my_backend
+    #     config.i18n.backend = MyBackend
+    #   end
+    #
+    # Notice this method takes into consideration the default root path. So if you
+    # are changing config.root inside your application definition or having a custom
+    # Rails application, you will need to add lib to $LOAD_PATH on your own in case
+    # you need to load files in lib/ during the application configuration as well.
+    #
+    # pkg:gem/railties#lib/rails/application.rb:409
+    def add_lib_to_load_path!(root); end
+
+    # pkg:gem/railties#lib/rails/application.rb:82
+    def create(initial_variable_values = T.unsafe(nil), &block); end
+
+    # pkg:gem/railties#lib/rails/application.rb:86
+    def find_root(from); end
+
+    # pkg:gem/railties#lib/rails/application.rb:69
+    def inherited(base); end
+
+    # pkg:gem/railties#lib/rails/application.rb:78
+    def instance; end
+
+    # pkg:gem/railties#lib/rails/application.rb:95
+    def new(*_arg0); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/application/bootstrap.rb:10
+module Rails::Application::Bootstrap
+  include ::Rails::Initializable
+  extend ::Rails::Initializable::ClassMethods
+end
+
+# pkg:gem/railties#lib/rails/application/configuration.rb:13
+class Rails::Application::Configuration < ::Rails::Engine::Configuration
+  # pkg:gem/railties#lib/rails/application/configuration.rb:31
+  def initialize(*_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def add_autoload_paths_to_load_path; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def add_autoload_paths_to_load_path=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def allow_concurrency; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def allow_concurrency=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:582
+  def annotations; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:29
+  def api_only; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:395
+  def api_only=(value); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def asset_host; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def asset_host=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def assume_ssl; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def assume_ssl=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def autoflush_log; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def autoflush_log=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:490
+  def autoload_lib(ignore:); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:502
+  def autoload_lib_once(ignore:); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def beginning_of_week; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def beginning_of_week=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:407
+  def broadcast_log_level; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def cache_classes; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def cache_classes=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def cache_store; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def cache_store=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:514
+  def colorize_logging; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:518
+  def colorize_logging=(val); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def consider_all_requests_local; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def consider_all_requests_local=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def console; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def console=(_arg0); end
+
+  # Configures the ActionDispatch::ContentSecurityPolicy.
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:587
+  def content_security_policy(&block); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_auto; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_auto=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_directives; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_directives=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_generator; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_nonce_generator=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_report_only; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def content_security_policy_report_only=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def credentials; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def credentials=(_arg0); end
+
+  # Loads and returns the entire raw configuration of database from
+  # values stored in <tt>config/database.yml</tt>.
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:453
+  def database_configuration; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:409
+  def debug_exception_response_format; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:413
+  def debug_exception_response_format=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:604
+  def default_log_file; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def disable_sandbox; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def disable_sandbox=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def dom_testing_default_html_version; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def dom_testing_default_html_version=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def eager_load; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def eager_load=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:379
+  def enable_reloading; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:383
+  def enable_reloading=(value); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:29
+  def encoding; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:387
+  def encoding=(value); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def exceptions_app; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def exceptions_app=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def file_watcher; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def file_watcher=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def filter_parameters; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def filter_parameters=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def filter_redirect; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def filter_redirect=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def force_ssl; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def force_ssl=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def helpers_paths; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def helpers_paths=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def host_authorization; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def host_authorization=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def hosts; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def hosts=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:616
+  def inspect; end
+
+  # Load the <tt>config/database.yml</tt> to create the Rake tasks for
+  # multiple databases without loading the environment and filling in the
+  # environment specific configuration values.
+  #
+  # Do not use this method, use #database_configuration instead.
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:435
+  def load_database_yaml; end
+
+  # Loads default configuration values for a target version. This includes
+  # defaults for versions prior to the target version. See the
+  # {configuration guide}[https://guides.rubyonrails.org/configuring.html#versioned-default-values]
+  # for the default values associated with a particular version.
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:94
+  def load_defaults(target_version); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:29
+  def loaded_config_version; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_file_size; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_file_size=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_formatter; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_formatter=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:29
+  def log_level; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:402
+  def log_level=(level); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_tags; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def log_tags=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def logger; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def logger=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:415
+  def paths; end
+
+  # Configures the ActionDispatch::PermissionsPolicy.
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:596
+  def permissions_policy(&block); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def precompile_filter_parameters; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def precompile_filter_parameters=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def public_file_server; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def public_file_server=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def railties_order; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def railties_order=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def rake_eager_load; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def rake_eager_load=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def relative_url_root; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def relative_url_root=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def reload_classes_only_on_change; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def reload_classes_only_on_change=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:375
+  def reloading_enabled?; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def require_master_key; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def require_master_key=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def sandbox_by_default; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def sandbox_by_default=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:523
+  def secret_key_base; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:535
+  def secret_key_base=(new_secret_key_base); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def server_timing; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def server_timing=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def session_options; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def session_options=(_arg0); end
+
+  # Specifies what class to use to store the session. Possible values
+  # are +:cache_store+, +:cookie_store+, +:mem_cache_store+, a custom
+  # store, or +:disabled+. +:disabled+ tells \Rails not to deal with
+  # sessions.
+  #
+  # Additional options will be set as +session_options+:
+  #
+  #   config.session_store :cookie_store, key: "_your_app_session"
+  #   config.session_options # => {key: "_your_app_session"}
+  #
+  # If a custom store is specified as a symbol, it will be resolved to
+  # the +ActionDispatch::Session+ namespace:
+  #
+  #   # use ActionDispatch::Session::MyCustomStore as the session store
+  #   config.session_store :my_custom_store
+  #
+  # pkg:gem/railties#lib/rails/application/configuration.rb:562
+  def session_store(new_session_store = T.unsafe(nil), **options); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:578
+  def session_store?; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def silence_healthcheck_path; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def silence_healthcheck_path=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def ssl_options; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def ssl_options=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def time_zone; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def time_zone=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def x; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def x=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def yjit; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:14
+  def yjit=(_arg0); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:643
+  def credentials_defaults; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:653
+  def generate_local_secret; end
+end
+
+# pkg:gem/railties#lib/rails/application/configuration.rb:620
+class Rails::Application::Configuration::Custom
+  # pkg:gem/railties#lib/rails/application/configuration.rb:621
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:625
+  def method_missing(method, *args); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application/configuration.rb:637
+  def respond_to_missing?(symbol, _); end
+end
+
+# pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:5
+class Rails::Application::DefaultMiddlewareStack
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:8
+  def initialize(app, config, paths); end
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:6
+  def app; end
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:14
+  def build_stack; end
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:6
+  def config; end
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:6
+  def paths; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:113
+  def load_rack_cache; end
+
+  # pkg:gem/railties#lib/rails/application/default_middleware_stack.rb:135
+  def show_exceptions_app; end
+end
+
+# pkg:gem/railties#lib/rails/application/finisher.rb:10
+module Rails::Application::Finisher
+  include ::Rails::Initializable
+  extend ::Rails::Initializable::ClassMethods
+end
+
+# pkg:gem/railties#lib/rails/application/finisher.rb:110
+module Rails::Application::Finisher::InterlockHook
+  class << self
+    # pkg:gem/railties#lib/rails/application/finisher.rb:115
+    def complete(_state); end
+
+    # pkg:gem/railties#lib/rails/application/finisher.rb:111
+    def run; end
+  end
+end
+
+# pkg:gem/railties#lib/rails/application/finisher.rb:96
+class Rails::Application::Finisher::MonitorHook
+  # pkg:gem/railties#lib/rails/application/finisher.rb:97
+  def initialize(monitor = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/application/finisher.rb:105
+  def complete(_state); end
+
+  # pkg:gem/railties#lib/rails/application/finisher.rb:101
+  def run; end
+end
+
+# pkg:gem/railties#lib/rails/application.rb:104
+Rails::Application::INITIAL_VARIABLES = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/railties#lib/rails/application/routes_reloader.rb:6
+class Rails::Application::RoutesReloader
+  include ::ActiveSupport::Callbacks
+  extend ::ActiveSupport::Callbacks::ClassMethods
+  extend ::ActiveSupport::DescendantsTracker
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:14
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:7
+  def __callbacks; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:10
+  def eager_load; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:10
+  def eager_load=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:31
+  def execute; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:12
+  def execute_if_updated(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:36
+  def execute_unless_loaded; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:9
+  def external_routes; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:9
+  def loaded; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:11
+  def loaded=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:9
+  def paths; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:22
+  def reload!; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:9
+  def route_sets; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:11
+  def run_after_load_paths=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:12
+  def updated?(*_arg0, **_arg1, &_arg2); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:55
+  def clear!; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:71
+  def finalize!; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:62
+  def load_paths; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:75
+  def revert; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:67
+  def run_after_load_paths; end
+
+  # pkg:gem/railties#lib/rails/application/routes_reloader.rb:45
+  def updater; end
+
+  class << self
+    # pkg:gem/railties#lib/rails/application/routes_reloader.rb:7
+    def __callbacks; end
+
+    # pkg:gem/railties#lib/rails/application/routes_reloader.rb:7
+    def __callbacks=(value); end
+
+    private
+
+    # pkg:gem/railties#lib/rails/application/routes_reloader.rb:7
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/application/routes_reloader.rb:7
+    def __class_attr___callbacks=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/application_controller.rb:5
+class Rails::ApplicationController < ::ActionController::Base
+  # pkg:gem/railties#lib/rails/application_controller.rb:9
+  def _run_process_action_callbacks(&block); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/application_controller.rb:5
+  def _layout(lookup_context, formats, keys); end
+
+  # pkg:gem/railties#lib/rails/application_controller.rb:27
+  def disable_content_security_policy_nonce!; end
+
+  # pkg:gem/railties#lib/rails/application_controller.rb:23
+  def local_request?; end
+
+  # pkg:gem/railties#lib/rails/application_controller.rb:17
+  def require_local!; end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:9
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:9
+    def __class_attr___callbacks=(new_value); end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:7
+    def __class_attr__layout; end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:7
+    def __class_attr__layout=(new_value); end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:7
+    def __class_attr__layout_conditions; end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:7
+    def __class_attr__layout_conditions=(new_value); end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:5
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:5
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:5
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/application_controller.rb:5
+    def __class_attr_middleware_stack=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/autoloaders.rb:4
+class Rails::Autoloaders
+  include ::Enumerable
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:11
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:31
+  def each; end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:40
+  def log!; end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:36
+  def logger=(logger); end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:9
+  def main; end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:9
+  def once; end
+
+  # pkg:gem/railties#lib/rails/autoloaders.rb:44
+  def zeitwerk_enabled?; end
+end
+
+# pkg:gem/railties#lib/rails/autoloaders/inflector.rb:7
+module Rails::Autoloaders::Inflector
+  class << self
+    # pkg:gem/railties#lib/rails/autoloaders/inflector.rb:12
+    def camelize(basename, _abspath); end
+
+    # pkg:gem/railties#lib/rails/autoloaders/inflector.rb:16
+    def inflect(overrides); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/backtrace_cleaner.rb:7
+class Rails::BacktraceCleaner < ::ActiveSupport::BacktraceCleaner
+  # pkg:gem/railties#lib/rails/backtrace_cleaner.rb:11
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/backtrace_cleaner.rb:29
+  def clean(backtrace, kind = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/backtrace_cleaner.rb:36
+  def clean_frame(frame, kind = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/backtrace_cleaner.rb:34
+  def filter(backtrace, kind = T.unsafe(nil)); end
+end
+
+# pkg:gem/railties#lib/rails/backtrace_cleaner.rb:8
+Rails::BacktraceCleaner::APP_DIRS_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/railties#lib/rails/backtrace_cleaner.rb:9
+Rails::BacktraceCleaner::RENDER_TEMPLATE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# pkg:gem/railties#lib/rails/configuration.rb:9
+module Rails::Configuration; end
+
+# pkg:gem/railties#lib/rails/configuration.rb:104
+class Rails::Configuration::Generators
+  # pkg:gem/railties#lib/rails/configuration.rb:108
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:130
+  def after_generate(&block); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:106
+  def after_generate_callbacks; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def aliases; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def aliases=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def api_only; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def api_only=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:134
+  def apply_rubocop_autocorrect_after_generate!; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def colorize_logging; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def colorize_logging=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def fallbacks; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def fallbacks=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:106
+  def hidden_namespaces; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:126
+  def hide_namespace(namespace); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:143
+  def method_missing(method, *args); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def options; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def options=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def templates; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:105
+  def templates=(_arg0); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/configuration.rb:119
+  def initialize_copy(source); end
+end
+
+# MiddlewareStackProxy is a proxy for the \Rails middleware stack that allows
+# you to configure middlewares in your application. It works basically as a
+# command recorder, saving each command to be applied after initialization
+# over the default middleware stack, so you can add, swap, or remove any
+# middleware in \Rails.
+#
+# You can add your own middlewares by using the +config.middleware.use+ method:
+#
+#     config.middleware.use Magical::Unicorns
+#
+# This will put the +Magical::Unicorns+ middleware on the end of the stack.
+# You can use +insert_before+ if you wish to add a middleware before another:
+#
+#     config.middleware.insert_before Rack::Head, Magical::Unicorns
+#
+# There's also +insert_after+ which will insert a middleware after another:
+#
+#     config.middleware.insert_after Rack::Head, Magical::Unicorns
+#
+# Middlewares can also be completely swapped out and replaced with others:
+#
+#     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
+#
+# Middlewares can be moved from one place to another:
+#
+#     config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
+#
+# This will move the +Magical::Unicorns+ middleware before the
+# +ActionDispatch::Flash+. You can also move it after:
+#
+#     config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
+#
+# And finally they can also be removed from the stack completely:
+#
+#     config.middleware.delete ActionDispatch::Flash
+#
+# pkg:gem/railties#lib/rails/configuration.rb:46
+class Rails::Configuration::MiddlewareStackProxy
+  # pkg:gem/railties#lib/rails/configuration.rb:47
+  def initialize(operations = T.unsafe(nil), delete_operations = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:96
+  def +(other); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:70
+  def delete(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:56
+  def insert(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:58
+  def insert_after(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:52
+  def insert_before(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:88
+  def merge_into(other); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:78
+  def move(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:80
+  def move_after(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:74
+  def move_before(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:62
+  def swap(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:84
+  def unshift(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:66
+  def use(*_arg0, **_arg1, &_arg2); end
+
+  protected
+
+  # pkg:gem/railties#lib/rails/configuration.rb:101
+  def delete_operations; end
+
+  # pkg:gem/railties#lib/rails/configuration.rb:101
+  def operations; end
+end
+
+# +Rails::Engine+ allows you to wrap a specific \Rails application or subset of
+# functionality and share it with other applications or within a larger packaged application.
+# Every Rails::Application is just an engine, which allows for simple
+# feature and application sharing.
+#
+# Any +Rails::Engine+ is also a Rails::Railtie, so the same
+# methods (like {rake_tasks}[rdoc-ref:Rails::Railtie::rake_tasks] and
+# {generators}[rdoc-ref:Rails::Railtie::generators]) and configuration
+# options that are available in railties can also be used in engines.
+#
+# == Creating an Engine
+#
+# If you want a gem to behave as an engine, you have to specify an +Engine+
+# for it somewhere inside your plugin's +lib+ folder (similar to how we
+# specify a +Railtie+):
+#
+#   # lib/my_engine.rb
+#   module MyEngine
+#     class Engine < Rails::Engine
+#     end
+#   end
+#
+# Then ensure that this file is loaded at the top of your <tt>config/application.rb</tt>
+# (or in your +Gemfile+), and it will automatically load models, controllers, and helpers
+# inside +app+, load routes at <tt>config/routes.rb</tt>, load locales at
+# <tt>config/locales/**/*</tt>, and load tasks at <tt>lib/tasks/**/*</tt>.
+#
+# == Configuration
+#
+# Like railties, engines can access a config object which contains configuration shared by
+# all railties and the application.
+# Additionally, each engine can access <tt>autoload_paths</tt>, <tt>eager_load_paths</tt> and
+# <tt>autoload_once_paths</tt> settings which are scoped to that engine.
+#
+#   class MyEngine < Rails::Engine
+#     # Add a load path for this specific Engine
+#     config.autoload_paths << File.expand_path("lib/some/path", __dir__)
+#
+#     initializer "my_engine.add_middleware" do |app|
+#       app.middleware.use MyEngine::Middleware
+#     end
+#   end
+#
+# == Generators
+#
+# You can set up generators for engines with <tt>config.generators</tt> method:
+#
+#   class MyEngine < Rails::Engine
+#     config.generators do |g|
+#       g.orm             :active_record
+#       g.template_engine :erb
+#       g.test_framework  :test_unit
+#     end
+#   end
+#
+# You can also set generators for an application by using <tt>config.app_generators</tt>:
+#
+#   class MyEngine < Rails::Engine
+#     # note that you can also pass block to app_generators in the same way you
+#     # can pass it to generators method
+#     config.app_generators.orm :datamapper
+#   end
+#
+# == Paths
+#
+# Applications and engines have flexible path configuration, meaning that you
+# are not required to place your controllers at <tt>app/controllers</tt>, but
+# in any place which you find convenient.
+#
+# For example, let's suppose you want to place your controllers in <tt>lib/controllers</tt>.
+# You can set that as an option:
+#
+#   class MyEngine < Rails::Engine
+#     paths["app/controllers"] = "lib/controllers"
+#   end
+#
+# You can also have your controllers loaded from both <tt>app/controllers</tt> and
+# <tt>lib/controllers</tt>:
+#
+#   class MyEngine < Rails::Engine
+#     paths["app/controllers"] << "lib/controllers"
+#   end
+#
+# The available paths in an engine are:
+#
+#   class MyEngine < Rails::Engine
+#     paths["app"]                 # => ["app"]
+#     paths["app/controllers"]     # => ["app/controllers"]
+#     paths["app/helpers"]         # => ["app/helpers"]
+#     paths["app/models"]          # => ["app/models"]
+#     paths["app/views"]           # => ["app/views"]
+#     paths["lib"]                 # => ["lib"]
+#     paths["lib/tasks"]           # => ["lib/tasks"]
+#     paths["config"]              # => ["config"]
+#     paths["config/initializers"] # => ["config/initializers"]
+#     paths["config/locales"]      # => ["config/locales"]
+#     paths["config/routes.rb"]    # => ["config/routes.rb"]
+#   end
+#
+# The <tt>Application</tt> class adds a couple more paths to this set. And as in your
+# <tt>Application</tt>, all folders under +app+ are automatically added to the load path.
+# If you have an <tt>app/services</tt> folder for example, it will be added by default.
+#
+# == Endpoint
+#
+# An engine can also be a Rack application. It can be useful if you have a Rack application that
+# you would like to provide with some of the +Engine+'s features.
+#
+# To do that, use the ::endpoint method:
+#
+#   module MyEngine
+#     class Engine < Rails::Engine
+#       endpoint MyRackApplication
+#     end
+#   end
+#
+# Now you can mount your engine in application's routes:
+#
+#   Rails.application.routes.draw do
+#     mount MyEngine::Engine => "/engine"
+#   end
+#
+# == Middleware stack
+#
+# As an engine can now be a Rack endpoint, it can also have a middleware
+# stack. The usage is exactly the same as in <tt>Application</tt>:
+#
+#   module MyEngine
+#     class Engine < Rails::Engine
+#       middleware.use SomeMiddleware
+#     end
+#   end
+#
+# == Routes
+#
+# If you don't specify an endpoint, routes will be used as the default
+# endpoint. You can use them just like you use an application's routes:
+#
+#   # ENGINE/config/routes.rb
+#   MyEngine::Engine.routes.draw do
+#     get "/" => "posts#index"
+#   end
+#
+# == Mount priority
+#
+# Note that now there can be more than one router in your application, and it's better to avoid
+# passing requests through many routers. Consider this situation:
+#
+#   Rails.application.routes.draw do
+#     mount MyEngine::Engine => "/blog"
+#     get "/blog/omg" => "main#omg"
+#   end
+#
+# +MyEngine+ is mounted at <tt>/blog</tt>, and <tt>/blog/omg</tt> points to application's
+# controller. In such a situation, requests to <tt>/blog/omg</tt> will go through +MyEngine+,
+# and if there is no such route in +Engine+'s routes, it will be dispatched to <tt>main#omg</tt>.
+# It's much better to swap that:
+#
+#   Rails.application.routes.draw do
+#     get "/blog/omg" => "main#omg"
+#     mount MyEngine::Engine => "/blog"
+#   end
+#
+# Now, +Engine+ will get only requests that were not handled by +Application+.
+#
+# == Engine name
+#
+# There are some places where an Engine's name is used:
+#
+# * routes: when you mount an Engine with <tt>mount(MyEngine::Engine => '/my_engine')</tt>,
+#   it's used as default <tt>:as</tt> option
+# * rake task for installing migrations <tt>my_engine:install:migrations</tt>
+#
+# Engine name is set by default based on class name. For +MyEngine::Engine+ it will be
+# <tt>my_engine_engine</tt>. You can change it manually using the <tt>engine_name</tt> method:
+#
+#   module MyEngine
+#     class Engine < Rails::Engine
+#       engine_name "my_engine"
+#     end
+#   end
+#
+# == Isolated Engine
+#
+# Normally when you create controllers, helpers, and models inside an engine, they are treated
+# as if they were created inside the application itself. This means that all helpers and
+# named routes from the application will be available to your engine's controllers as well.
+#
+# However, sometimes you want to isolate your engine from the application, especially if your engine
+# has its own router. To do that, you simply need to call ::isolate_namespace. This method requires
+# you to pass a module where all your controllers, helpers, and models should be nested to:
+#
+#   module MyEngine
+#     class Engine < Rails::Engine
+#       isolate_namespace MyEngine
+#     end
+#   end
+#
+# With such an engine, everything that is inside the +MyEngine+ module will be isolated from
+# the application.
+#
+# Consider this controller:
+#
+#   module MyEngine
+#     class FooController < ActionController::Base
+#     end
+#   end
+#
+# If the +MyEngine+ engine is marked as isolated, +FooController+ only has
+# access to helpers from +MyEngine+, and <tt>url_helpers</tt> from
+# <tt>MyEngine::Engine.routes</tt>.
+#
+# The next thing that changes in isolated engines is the behavior of routes.
+# Normally, when you namespace your controllers, you also need to namespace
+# the related routes. With an isolated engine, the engine's namespace is
+# automatically applied, so you don't need to specify it explicitly in your
+# routes:
+#
+#   MyEngine::Engine.routes.draw do
+#     resources :articles
+#   end
+#
+# If +MyEngine+ is isolated, the routes above will point to
+# +MyEngine::ArticlesController+. You also don't need to use longer
+# URL helpers like +my_engine_articles_path+. Instead, you should simply use
+# +articles_path+, like you would do with your main application.
+#
+# To make this behavior consistent with other parts of the framework,
+# isolated engines also have an effect on ActiveModel::Naming. In a
+# normal \Rails app, when you use a namespaced model such as
+# +Namespace::Article+, ActiveModel::Naming will generate
+# names with the prefix "namespace". In an isolated engine, the prefix will
+# be omitted in URL helpers and form fields, for convenience.
+#
+#   polymorphic_url(MyEngine::Article.new)
+#   # => "articles_path" # not "my_engine_articles_path"
+#
+#   form_with(model: MyEngine::Article.new) do
+#     text_field :title # => <input type="text" name="article[title]" id="article_title" />
+#   end
+#
+# Additionally, an isolated engine will set its own name according to its
+# namespace, so <tt>MyEngine::Engine.engine_name</tt> will return
+# "my_engine". It will also set +MyEngine.table_name_prefix+ to "my_engine_",
+# meaning for example that +MyEngine::Article+ will use the
+# +my_engine_articles+ database table by default.
+#
+# == Using Engine's routes outside Engine
+#
+# Since you can now mount an engine inside application's routes, you do not have direct access to +Engine+'s
+# <tt>url_helpers</tt> inside +Application+. When you mount an engine in an application's routes, a special helper is
+# created to allow you to do that. Consider such a scenario:
+#
+#   # config/routes.rb
+#   Rails.application.routes.draw do
+#     mount MyEngine::Engine => "/my_engine", as: "my_engine"
+#     get "/foo" => "foo#index"
+#   end
+#
+# Now, you can use the <tt>my_engine</tt> helper inside your application:
+#
+#   class FooController < ApplicationController
+#     def index
+#       my_engine.root_url # => /my_engine/
+#     end
+#   end
+#
+# There is also a <tt>main_app</tt> helper that gives you access to application's routes inside Engine:
+#
+#   module MyEngine
+#     class BarController
+#       def index
+#         main_app.foo_path # => /foo
+#       end
+#     end
+#   end
+#
+# Note that the <tt>:as</tt> option given to mount takes the <tt>engine_name</tt> as default, so most of the time
+# you can simply omit it.
+#
+# Finally, if you want to generate a URL to an engine's route using
+# <tt>polymorphic_url</tt>, you also need to pass the engine helper. Let's
+# say that you want to create a form pointing to one of the engine's routes.
+# All you need to do is pass the helper as the first element in array with
+# attributes for URL:
+#
+#   form_with(model: [my_engine, @user])
+#
+# This code will use <tt>my_engine.user_path(@user)</tt> to generate the proper route.
+#
+# == Isolated engine's helpers
+#
+# Sometimes you may want to isolate an engine, but use helpers that are defined for it.
+# If you want to share just a few specific helpers you can add them to application's
+# helpers in ApplicationController:
+#
+#   class ApplicationController < ActionController::Base
+#     helper MyEngine::SharedEngineHelper
+#   end
+#
+# If you want to include all of the engine's helpers, you can use the #helper method on an engine's
+# instance:
+#
+#   class ApplicationController < ActionController::Base
+#     helper MyEngine::Engine.helpers
+#   end
+#
+# It will include all of the helpers from engine's directory. Take into account this does
+# not include helpers defined in controllers with helper_method or other similar solutions,
+# only helpers defined in the helpers directory will be included.
+#
+# == Migrations & seed data
+#
+# Engines can have their own migrations. The default path for migrations is exactly the same
+# as in application: <tt>db/migrate</tt>
+#
+# To use engine's migrations in application you can use the rake task below, which copies them to
+# application's dir:
+#
+#   $ rake ENGINE_NAME:install:migrations
+#
+# Note that some of the migrations may be skipped if a migration with the same name already exists
+# in application. In such a situation you must decide whether to leave that migration or rename the
+# migration in the application and rerun copying migrations.
+#
+# If your engine has migrations, you may also want to prepare data for the database in
+# the <tt>db/seeds.rb</tt> file. You can load that data using the <tt>load_seed</tt> method, e.g.
+#
+#   MyEngine::Engine.load_seed
+#
+# == Loading priority
+#
+# In order to change engine's priority you can use +config.railties_order+ in the main application.
+# It will affect the priority of loading views, helpers, assets, and all the other files
+# related to engine or application.
+#
+#   # load Blog::Engine with highest priority, followed by application and other railties
+#   config.railties_order = [Blog::Engine, :main_app, :all]
+#
+# pkg:gem/railties#lib/rails/engine/railties.rb:4
+class Rails::Engine < ::Rails::Railtie
+  include ::ActiveSupport::Callbacks
+  extend ::ActiveSupport::Callbacks::ClassMethods
+
+  # pkg:gem/railties#lib/rails/engine.rb:439
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:433
+  def __callbacks; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:434
+  def _load_seed_callbacks; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:434
+  def _run_load_seed_callbacks; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:434
+  def _run_load_seed_callbacks!(&block); end
+
+  # Returns the underlying Rack application for this engine.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:515
+  def app; end
+
+  # Define the Rack API for this engine.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:532
+  def call(env); end
+
+  # Define the configuration object for the engine.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:551
+  def config; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:489
+  def eager_load!; end
+
+  # Returns the endpoint for this engine. If none is registered,
+  # defaults to an ActionDispatch::Routing::RouteSet.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:527
+  def endpoint; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:437
+  def engine_name(*_arg0, **_arg1, &_arg2); end
+
+  # Defines additional Rack env configuration that is added on each call.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:538
+  def env_config; end
+
+  # Returns a module with all the helpers defined for the engine.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:499
+  def helpers; end
+
+  # Returns all registered helpers paths.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:510
+  def helpers_paths; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:437
+  def isolated?(&_arg0); end
+
+  # Load console and invoke the registered hooks.
+  # Check Rails::Railtie.console for more info.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:453
+  def load_console(app = T.unsafe(nil)); end
+
+  # Load \Rails generators and invoke the registered hooks.
+  # Check Rails::Railtie.generators for more info.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:475
+  def load_generators(app = T.unsafe(nil)); end
+
+  # Load \Rails runner and invoke the registered hooks.
+  # Check Rails::Railtie.runner for more info.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:460
+  def load_runner(app = T.unsafe(nil)); end
+
+  # Load data from db/seeds.rb file. It can be used in to load engines'
+  # seeds, e.g.:
+  #
+  # Blog::Engine.load_seed
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:559
+  def load_seed; end
+
+  # Invoke the server registered hooks.
+  # Check Rails::Railtie.server for more info.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:484
+  def load_server(app = T.unsafe(nil)); end
+
+  # Load Rake and railties tasks, and invoke the registered hooks.
+  # Check Rails::Railtie.rake_tasks for more info.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:467
+  def load_tasks(app = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:436
+  def middleware(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:436
+  def paths(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:494
+  def railties; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:436
+  def root(*_arg0, **_arg1, &_arg2); end
+
+  # Defines the routes for this engine. If a block is given to
+  # routes, it is appended to the engine.
+  #
+  # pkg:gem/railties#lib/rails/engine.rb:544
+  def routes(&block); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:679
+  def routes?; end
+
+  protected
+
+  # pkg:gem/railties#lib/rails/engine.rb:684
+  def run_tasks_blocks(*_arg0); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/engine.rb:716
+  def _all_autoload_once_paths; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:720
+  def _all_autoload_paths; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:729
+  def _all_load_paths(add_autoload_paths_to_load_path); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:754
+  def build_middleware; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:746
+  def build_request(env); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:712
+  def default_middleware_stack; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:740
+  def fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures); end
+
+  # pkg:gem/railties#lib/rails/engine.rb:696
+  def has_migrations?; end
+
+  # pkg:gem/railties#lib/rails/engine.rb:690
+  def load_config_initializer(initializer); end
+
+  class << self
+    # pkg:gem/railties#lib/rails/engine.rb:433
+    def __callbacks; end
+
+    # pkg:gem/railties#lib/rails/engine.rb:433
+    def __callbacks=(value); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:434
+    def _load_seed_callbacks; end
+
+    # pkg:gem/railties#lib/rails/engine.rb:434
+    def _load_seed_callbacks=(value); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:353
+    def called_from; end
+
+    # pkg:gem/railties#lib/rails/engine.rb:353
+    def called_from=(_arg0); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:358
+    def eager_load!(*_arg0, **_arg1, &_arg2); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:378
+    def endpoint(endpoint = T.unsafe(nil)); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:356
+    def engine_name(name = T.unsafe(nil)); end
+
+    # Finds engine with given path.
+    #
+    # pkg:gem/railties#lib/rails/engine.rb:423
+    def find(path); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:374
+    def find_root(from); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:700
+    def find_root_with_flag(flag, root_path, default = T.unsafe(nil)); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:360
+    def inherited(base); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:384
+    def isolate_namespace(mod); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:353
+    def isolated; end
+
+    # pkg:gem/railties#lib/rails/engine.rb:353
+    def isolated=(_arg0); end
+
+    # pkg:gem/railties#lib/rails/engine.rb:355
+    def isolated?; end
+
+    private
+
+    # pkg:gem/railties#lib/rails/engine.rb:433
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/engine.rb:433
+    def __class_attr___callbacks=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/engine/configuration.rb:7
+class Rails::Engine::Configuration < ::Rails::Railtie::Configuration
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:41
+  def initialize(root = T.unsafe(nil)); end
+
+  # Private method that adds custom autoload once paths to the ones defined
+  # by +paths+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:127
+  def all_autoload_once_paths; end
+
+  # Private method that adds custom autoload paths to the ones defined by
+  # +paths+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:121
+  def all_autoload_paths; end
+
+  # Private method that adds custom eager load paths to the ones defined by
+  # +paths+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:133
+  def all_eager_load_paths; end
+
+  # An array of custom autoload once paths. These won't be eager loaded
+  # unless you push them to +eager_load_paths+ too, which is recommended.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib_once+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:29
+  def autoload_once_paths; end
+
+  # An array of custom autoload once paths. These won't be eager loaded
+  # unless you push them to +eager_load_paths+ too, which is recommended.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib_once+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:10
+  def autoload_once_paths=(_arg0); end
+
+  # An array of custom autoload paths to be added to the ones defined
+  # automatically by Rails. These won't be eager loaded, unless you push
+  # them to +eager_load_paths+ too, which is recommended.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:20
+  def autoload_paths; end
+
+  # An array of custom autoload paths to be added to the ones defined
+  # automatically by Rails. These won't be eager loaded, unless you push
+  # them to +eager_load_paths+ too, which is recommended.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:10
+  def autoload_paths=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def default_scope; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def default_scope=(_arg0); end
+
+  # An array of custom eager load paths to be added to the ones defined
+  # automatically by Rails. Anything in this collection is considered to be
+  # an autoload path regardless of whether it was added to +autoload_paths+.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:39
+  def eager_load_paths; end
+
+  # An array of custom eager load paths to be added to the ones defined
+  # automatically by Rails. Anything in this collection is considered to be
+  # an autoload path regardless of whether it was added to +autoload_paths+.
+  #
+  # This collection is empty by default, it accepts strings and +Pathname+
+  # objects.
+  #
+  # If you'd like to add +lib+ to it, please see +autoload_lib+.
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:10
+  def eager_load_paths=(_arg0); end
+
+  # Holds generators configuration:
+  #
+  #   config.generators do |g|
+  #     g.orm             :data_mapper, migration: true
+  #     g.template_engine :haml
+  #     g.test_framework  :rspec
+  #   end
+  #
+  # If you want to disable color in console, do:
+  #
+  #   config.generators.colorize_logging = false
+  #
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:67
+  def generators; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def javascript_path; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def javascript_path=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def middleware; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def middleware=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:73
+  def paths; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:8
+  def root; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:115
+  def root=(value); end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def route_set_class; end
+
+  # pkg:gem/railties#lib/rails/engine/configuration.rb:9
+  def route_set_class=(_arg0); end
+end
+
+# pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:11
+class Rails::Engine::LazyRouteSet < ::ActionDispatch::Routing::RouteSet
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:41
+  def initialize(config = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:58
+  def call(req); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:68
+  def draw(&block); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:48
+  def generate_extras(options, recall = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:54
+  def generate_url_helpers(supports_path); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:63
+  def polymorphic_mappings; end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:73
+  def recognize_path(path, environment = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:78
+  def recognize_path_with_request(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:83
+  def routes; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:89
+  def method_missing_module; end
+end
+
+# pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:12
+class Rails::Engine::LazyRouteSet::NamedRouteCollection < ::ActionDispatch::Routing::RouteSet::NamedRouteCollection
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:13
+  def route_defined?(name); end
+end
+
+# pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:19
+module Rails::Engine::LazyRouteSet::ProxyUrlHelpers
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:25
+  def full_url_for(options); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:35
+  def optimize_routes_generation?; end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:30
+  def route_for(name, *args); end
+
+  # pkg:gem/railties#lib/rails/engine/lazy_route_set.rb:20
+  def url_for(options); end
+end
+
+# pkg:gem/railties#lib/rails/engine/railties.rb:5
+class Rails::Engine::Railties
+  include ::Enumerable
+
+  # pkg:gem/railties#lib/rails/engine/railties.rb:9
+  def initialize; end
+
+  # pkg:gem/railties#lib/rails/engine/railties.rb:18
+  def -(others); end
+
+  # pkg:gem/railties#lib/rails/engine/railties.rb:7
+  def _all; end
+
+  # pkg:gem/railties#lib/rails/engine/railties.rb:14
+  def each(*args, &block); end
+end
+
+# Built-in Health Check Endpoint
+#
+# \Rails also comes with a built-in health check endpoint that is reachable at
+# the +/up+ path. This endpoint will return a 200 status code if the app has
+# booted with no exceptions, and a 500 status code otherwise.
+#
+# In production, many applications are required to report their status upstream,
+# whether it's to an uptime monitor that will page an engineer when things go
+# wrong, or a load balancer or Kubernetes controller used to determine a pod's
+# health. This health check is designed to be a one-size fits all that will work
+# in many situations.
+#
+# While any newly generated \Rails applications will have the health check at
+# +/up+, you can configure the path to be anything you'd like in your
+# <tt>"config/routes.rb"</tt>:
+#
+#   Rails.application.routes.draw do
+#     get "healthz" => "rails/health#show", as: :rails_health_check
+#   end
+#
+# The health check will now be accessible via the +/healthz+ path.
+#
+# NOTE: This endpoint does not reflect the status of all of your application's
+# dependencies, such as the database or Redis cluster. Replace
+# <tt>"rails/health#show"</tt> with your own controller action if you have
+# application specific needs.
+#
+# Think carefully about what you want to check as it can lead to situations
+# where your application is being restarted due to a third-party service going
+# bad. Ideally, you should design your application to handle those outages
+# gracefully.
+#
+# pkg:gem/railties#lib/rails/health_controller.rb:37
+class Rails::HealthController < ::ActionController::Base
+  # pkg:gem/railties#lib/rails/health_controller.rb:40
+  def show; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/health_controller.rb:37
+  def _layout(lookup_context, formats, keys); end
+
+  # pkg:gem/railties#lib/rails/health_controller.rb:59
+  def html_status(color:); end
+
+  # pkg:gem/railties#lib/rails/health_controller.rb:52
+  def render_down; end
+
+  # pkg:gem/railties#lib/rails/health_controller.rb:45
+  def render_up; end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:37
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:37
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:37
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:37
+    def __class_attr_middleware_stack=(new_value); end
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:38
+    def __class_attr_rescue_handlers; end
+
+    # pkg:gem/railties#lib/rails/health_controller.rb:38
+    def __class_attr_rescue_handlers=(new_value); end
+  end
+end
+
+# This module helps build the runtime properties that are displayed in
+# Rails::InfoController responses. These include the active \Rails version,
+# Ruby version, Rack version, and so on.
+#
+# pkg:gem/railties#lib/rails/info.rb:9
+module Rails::Info
+  # pkg:gem/railties#lib/rails/info.rb:10
+  def properties; end
+
+  # pkg:gem/railties#lib/rails/info.rb:10
+  def properties=(val); end
+
+  class << self
+    # pkg:gem/railties#lib/rails/info.rb:41
+    def inspect; end
+
+    # pkg:gem/railties#lib/rails/info.rb:10
+    def properties; end
+
+    # pkg:gem/railties#lib/rails/info.rb:10
+    def properties=(val); end
+
+    # pkg:gem/railties#lib/rails/info.rb:25
+    def property(name, value = T.unsafe(nil)); end
+
+    # pkg:gem/railties#lib/rails/info.rb:43
+    def to_html; end
+
+    # pkg:gem/railties#lib/rails/info.rb:31
+    def to_s; end
+  end
+end
+
+# pkg:gem/railties#lib/rails/info_controller.rb:6
+class Rails::InfoController < ::Rails::ApplicationController
+  # pkg:gem/railties#lib/rails/info_controller.rb:12
+  def index; end
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:35
+  def notes; end
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:16
+  def properties; end
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:21
+  def routes; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:6
+  def _layout(lookup_context, formats, keys); end
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:8
+  def _layout_from_proc; end
+
+  # pkg:gem/railties#lib/rails/info_controller.rb:43
+  def matching_routes(query:, exact_match:); end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:10
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:10
+    def __class_attr___callbacks=(new_value); end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:8
+    def __class_attr__layout; end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:8
+    def __class_attr__layout=(new_value); end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:8
+    def __class_attr__layout_conditions; end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:8
+    def __class_attr__layout_conditions=(new_value); end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:6
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:6
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:6
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/info_controller.rb:6
+    def __class_attr_middleware_stack=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/initializable.rb:6
+module Rails::Initializable
+  mixes_in_class_methods ::Rails::Initializable::ClassMethods
+
+  # pkg:gem/railties#lib/rails/initializable.rb:108
+  def initializers; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:100
+  def run_initializers(group = T.unsafe(nil), *args); end
+
+  class << self
+    # pkg:gem/railties#lib/rails/initializable.rb:7
+    def included(base); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/initializable.rb:112
+module Rails::Initializable::ClassMethods
+  # pkg:gem/railties#lib/rails/initializable.rb:130
+  def initializer(name, opts = T.unsafe(nil), &blk); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:113
+  def initializers; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:117
+  def initializers_chain; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:126
+  def initializers_for(binding); end
+end
+
+# pkg:gem/railties#lib/rails/initializable.rb:37
+class Rails::Initializable::Collection
+  include ::Enumerable
+  include ::TSort
+
+  # pkg:gem/railties#lib/rails/initializable.rb:43
+  def initialize(initializers = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:69
+  def +(other); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:73
+  def <<(initializer); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:86
+  def append(*initializers); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:88
+  def concat(*initializer_collections); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:58
+  def each(&block); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:95
+  def has?(name); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:54
+  def last; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:41
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:81
+  def push(*initializers); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:50
+  def to_a; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:63
+  def tsort_each_child(initializer, &block); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:62
+  def tsort_each_node(&block); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/initializable.rb:41
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+end
+
+# pkg:gem/railties#lib/rails/initializable.rb:11
+class Rails::Initializable::Initializer
+  # pkg:gem/railties#lib/rails/initializable.rb:14
+  def initialize(name, context, before:, after:, group: T.unsafe(nil), &block); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:12
+  def after; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:12
+  def before; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:19
+  def belongs_to?(group); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:27
+  def bind(context); end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:12
+  def block; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:32
+  def context_class; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:12
+  def name; end
+
+  # pkg:gem/railties#lib/rails/initializable.rb:23
+  def run(*args); end
+end
+
+# pkg:gem/railties#lib/rails/mailers_controller.rb:6
+class Rails::MailersController < ::Rails::ApplicationController
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:22
+  def download; end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:17
+  def index; end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:32
+  def preview; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:6
+  def _layout(lookup_context, formats, keys); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:107
+  def attachment_url(attachment); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:101
+  def attachments_for(email); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:93
+  def find_part(format); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:81
+  def find_preferred_part(*formats); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:69
+  def find_preview; end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:115
+  def locale_query(locale); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:111
+  def part_query(mime_type); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:119
+  def set_locale(&block); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:65
+  def show_previews?; end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:9
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:9
+    def __class_attr___callbacks=(new_value); end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:13
+    def __class_attr__helper_methods; end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:13
+    def __class_attr__helper_methods=(new_value); end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:6
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:6
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:6
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/mailers_controller.rb:6
+    def __class_attr_middleware_stack=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/mailers_controller.rb:13
+module Rails::MailersController::HelperMethods
+  include ::ActionController::Base::HelperMethods
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:13
+  def attachment_url(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:13
+  def locale_query(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/mailers_controller.rb:13
+  def part_query(*_arg0, **_arg1, &_arg2); end
+end
+
+# pkg:gem/railties#lib/rails/paths.rb:6
+module Rails::Paths; end
+
+# pkg:gem/railties#lib/rails/paths.rb:114
+class Rails::Paths::Path
+  include ::Enumerable
+
+  # pkg:gem/railties#lib/rails/paths.rb:119
+  def initialize(root, current, paths, options = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:171
+  def <<(path); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:132
+  def absolute_current; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def autoload!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def autoload?; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def autoload_once!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def autoload_once?; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:136
+  def children; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:176
+  def concat(paths); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:167
+  def each(&block); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def eager_load!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def eager_load?; end
+
+  # Returns all expanded paths but only if they exist in the filesystem.
+  #
+  # pkg:gem/railties#lib/rails/paths.rb:220
+  def existent; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:231
+  def existent_directories; end
+
+  # Expands all paths against the root and return all unique values.
+  #
+  # pkg:gem/railties#lib/rails/paths.rb:201
+  def expanded; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:196
+  def extensions; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:143
+  def first; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:117
+  def glob; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:117
+  def glob=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:147
+  def last; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def load_path!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def load_path?; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:188
+  def paths; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:174
+  def push(path); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def skip_autoload!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def skip_autoload_once!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def skip_eager_load!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:152
+  def skip_load_path!; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:235
+  def to_a; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:184
+  def to_ary; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:180
+  def unshift(*paths); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/paths.rb:238
+  def files_in(path); end
+end
+
+# This object is an extended hash that behaves as root of the Rails::Paths system.
+# It allows you to collect information about how you want to structure your application
+# paths through a Hash-like \API. It requires you to give a physical path on initialization.
+#
+#   root = Root.new "/rails"
+#   root.add "app/controllers", eager_load: true
+#
+# The above command creates a new root object and adds "app/controllers" as a path.
+# This means we can get a Rails::Paths::Path object back like below:
+#
+#   path = root["app/controllers"]
+#   path.eager_load?               # => true
+#   path.is_a?(Rails::Paths::Path) # => true
+#
+# The Path[rdoc-ref:Rails::Paths::Path] object is simply an enumerable and
+# allows you to easily add extra paths:
+#
+#   path.is_a?(Enumerable) # => true
+#   path.to_ary.inspect    # => ["app/controllers"]
+#
+#   path << "lib/controllers"
+#   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
+#
+# Notice that when you add a path using #add, the
+# Path[rdoc-ref:Rails::Paths::Path] object created already contains the path
+# with the same path value given to #add. In some situations, you may not
+# want this behavior, so you can give <tt>:with</tt> as option.
+#
+#   root.add "config/routes", with: "config/routes.rb"
+#   root["config/routes"].inspect # => ["config/routes.rb"]
+#
+# The #add method accepts the following options as arguments:
+# +eager_load+, +autoload+, +autoload_once+, and +glob+.
+#
+# Finally, the Path[rdoc-ref:Rails::Paths::Path] object also provides a few
+# helpers:
+#
+#   root = Root.new "/rails"
+#   root.add "app/controllers"
+#
+#   root["app/controllers"].expanded # => ["/rails/app/controllers"]
+#   root["app/controllers"].existent # => ["/rails/app/controllers"]
+#
+# Check the Rails::Paths::Path documentation for more information.
+#
+# pkg:gem/railties#lib/rails/paths.rb:51
+class Rails::Paths::Root
+  # pkg:gem/railties#lib/rails/paths.rb:54
+  def initialize(path); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:69
+  def [](path); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:59
+  def []=(path, value); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:64
+  def add(path, options = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:85
+  def all_paths; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:89
+  def autoload_once; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:97
+  def autoload_paths; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:93
+  def eager_load; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:77
+  def keys; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:101
+  def load_paths; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:52
+  def path; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:52
+  def path=(_arg0); end
+
+  # pkg:gem/railties#lib/rails/paths.rb:73
+  def values; end
+
+  # pkg:gem/railties#lib/rails/paths.rb:81
+  def values_at(*list); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/paths.rb:106
+  def filter_by(&block); end
+end
+
+# pkg:gem/railties#lib/rails/pwa_controller.rb:5
+class Rails::PwaController < ::Rails::ApplicationController
+  # pkg:gem/railties#lib/rails/pwa_controller.rb:12
+  def manifest; end
+
+  # pkg:gem/railties#lib/rails/pwa_controller.rb:8
+  def service_worker; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/pwa_controller.rb:5
+  def _layout(lookup_context, formats, keys); end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:6
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:6
+    def __class_attr___callbacks=(new_value); end
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:5
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:5
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:5
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/pwa_controller.rb:5
+    def __class_attr_middleware_stack=(new_value); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/rack.rb:4
+module Rails::Rack; end
+
+# Sets log tags, logs the request, calls the app, and flushes the logs.
+#
+# Log tags (+taggers+) can be an Array containing: methods that the +request+
+# object responds to, objects that respond to +to_s+ or Proc objects that accept
+# an instance of the +request+ object.
+#
+# pkg:gem/railties#lib/rails/rack/logger.rb:14
+class Rails::Rack::Logger < ::ActiveSupport::LogSubscriber
+  # pkg:gem/railties#lib/rails/rack/logger.rb:15
+  def initialize(app, taggers = T.unsafe(nil)); end
+
+  # pkg:gem/railties#lib/rails/rack/logger.rb:20
+  def call(env); end
+
+  private
+
+  # pkg:gem/railties#lib/rails/rack/logger.rb:33
+  def call_app(request, env); end
+
+  # pkg:gem/railties#lib/rails/rack/logger.rb:64
+  def compute_tags(request); end
+
+  # pkg:gem/railties#lib/rails/rack/logger.rb:81
+  def finish_request_instrumentation(handle, logger_tag_pop_count); end
+
+  # pkg:gem/railties#lib/rails/rack/logger.rb:77
+  def logger; end
+
+  # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
+  #
+  # pkg:gem/railties#lib/rails/rack/logger.rb:56
+  def started_request_message(request); end
+end
+
+# Allows you to silence requests made to a specific path.
+# This is useful for preventing recurring requests like health checks from clogging the logging.
+# This middleware is used to do just that against the path /up in production by default.
+#
+# Examples:
+#
+#   config.middleware.insert_before \
+#     Rails::Rack::Logger, Rails::Rack::SilenceRequest, path: "/up"
+#
+#   config.middleware.insert_before \
+#     Rails::Rack::Logger, Rails::Rack::SilenceRequest, path: /test$/
+#
+# This middleware can also be configured using `config.silence_healthcheck_path = "/up"` in Rails.
+#
+# pkg:gem/railties#lib/rails/rack/silence_request.rb:22
+class Rails::Rack::SilenceRequest
+  # pkg:gem/railties#lib/rails/rack/silence_request.rb:23
+  def initialize(app, path:); end
+
+  # pkg:gem/railties#lib/rails/rack/silence_request.rb:27
+  def call(env); end
+end
+
+# +Rails::Railtie+ is the core of the \Rails framework and provides
+# several hooks to extend \Rails and/or modify the initialization process.
+#
+# Every major component of \Rails (Action Mailer, Action Controller, Active
+# Record, etc.) implements a railtie. Each of them is responsible for their
+# own initialization. This makes \Rails itself absent of any component hooks,
+# allowing other components to be used in place of any of the \Rails defaults.
+#
+# Developing a \Rails extension does _not_ require implementing a railtie, but
+# if you need to interact with the \Rails framework during or after boot, then
+# a railtie is needed.
+#
+# For example, an extension doing any of the following would need a railtie:
+#
+# * creating initializers
+# * configuring a \Rails framework for the application, like setting a generator
+# * adding <tt>config.*</tt> keys to the environment
+# * setting up a subscriber with ActiveSupport::Notifications
+# * adding Rake tasks
+#
+# == Creating a Railtie
+#
+# To extend \Rails using a railtie, create a subclass of +Rails::Railtie+.
+# This class must be loaded during the \Rails boot process, and is conventionally
+# called +MyNamespace::Railtie+.
+#
+# The following example demonstrates an extension which can be used with or
+# without \Rails.
+#
+#   # lib/my_gem/railtie.rb
+#   module MyGem
+#     class Railtie < Rails::Railtie
+#     end
+#   end
+#
+#   # lib/my_gem.rb
+#   require "my_gem/railtie" if defined?(Rails::Railtie)
+#
+# == Initializers
+#
+# To add an initialization step to the \Rails boot process from your railtie, just
+# define the initialization code with the +initializer+ macro:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     initializer "my_gem.configure_rails_initialization" do
+#       # some initialization behavior
+#     end
+#   end
+#
+# If specified, the block can also receive the application object, in case you
+# need to access some application-specific configuration, like middleware:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     initializer "my_gem.configure_rails_initialization" do |app|
+#       app.middleware.use MyGem::Middleware
+#     end
+#   end
+#
+# Finally, you can also pass <tt>:before</tt> and <tt>:after</tt> as options to
+# +initializer+, in case you want to couple it with a specific step in the
+# initialization process.
+#
+# == Configuration
+#
+# Railties can access a config object which contains configuration shared by all
+# railties and the application:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     # Customize the ORM
+#     config.app_generators.orm :my_gem_orm
+#
+#     # Add a to_prepare block which is executed once in production
+#     # and before each request in development.
+#     config.to_prepare do
+#       MyGem.setup!
+#     end
+#   end
+#
+# == Loading Rake Tasks and Generators
+#
+# If your railtie has Rake tasks, you can tell \Rails to load them through the method
+# +rake_tasks+:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     rake_tasks do
+#       load "path/to/my_gem.tasks"
+#     end
+#   end
+#
+# By default, \Rails loads generators from your load path. However, if you want to place
+# your generators at a different location, you can specify in your railtie a block which
+# will load them during normal generators lookup:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     generators do
+#       require "path/to/my_gem_generator"
+#     end
+#   end
+#
+# Since filenames on the load path are shared across gems, be sure that files you load
+# through a railtie have unique names.
+#
+# == Run another program when the \Rails server starts
+#
+# In development, it's very usual to have to run another process next to the \Rails Server. In example
+# you might want to start the Webpack or React server. Or maybe you need to run your job scheduler process
+# like Sidekiq. This is usually done by opening a new shell and running the program from here.
+#
+# \Rails allow you to specify a +server+ block which will get called when a \Rails server starts.
+# This way, your users don't need to remember to have to open a new shell and run another program, making
+# this less confusing for everyone.
+# It can be used like this:
+#
+#   class MyGem::Railtie < Rails::Railtie
+#     server do
+#       WebpackServer.start
+#     end
+#   end
+#
+# == Application and Engine
+#
+# An engine is nothing more than a railtie with some initializers already set. And since
+# Rails::Application is an engine, the same configuration described here can be
+# used in both.
+#
+# Be sure to look at the documentation of those specific classes for more information.
+#
+# pkg:gem/railties#lib/rails/railtie.rb:135
+class Rails::Railtie
+  include ::Rails::Initializable
+  extend ::ActiveSupport::DescendantsTracker
+  extend ::Rails::Initializable::ClassMethods
+
+  # pkg:gem/railties#lib/rails/railtie.rb:244
+  def initialize; end
+
+  # This is used to create the <tt>config</tt> object on Railties, an instance of
+  # Railtie::Configuration, that is used by Railties and Application to store
+  # related configuration.
+  #
+  # pkg:gem/railties#lib/rails/railtie.rb:261
+  def config; end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:254
+  def configure(&block); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:250
+  def inspect; end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:242
+  def railtie_name(*_arg0, **_arg1, &_arg2); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:265
+  def railtie_namespace; end
+
+  protected
+
+  # pkg:gem/railties#lib/rails/railtie.rb:270
+  def run_console_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:274
+  def run_generators_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:278
+  def run_runner_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:287
+  def run_server_blocks(app); end
+
+  # pkg:gem/railties#lib/rails/railtie.rb:282
+  def run_tasks_blocks(app); end
+
+  private
+
+  # run `&block` in every registered block in `#register_block_for`
+  #
+  # pkg:gem/railties#lib/rails/railtie.rb:293
+  def each_registered_block(type, &block); end
+
+  class << self
+    # pkg:gem/railties#lib/rails/railtie.rb:193
+    def <=>(other); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:171
+    def abstract_railtie?; end
+
+    # This is used to create the <tt>config</tt> object on Railties, an instance of
+    # Railtie::Configuration, that is used by Railties and Application to store
+    # related configuration.
+    #
+    # pkg:gem/railties#lib/rails/railtie.rb:145
+    def config(*_arg0, **_arg1, &_arg2); end
+
+    # Allows you to configure the railtie. This is the same method seen in
+    # Railtie::Configurable, but this module is no longer required for all
+    # subclasses of Railtie so we provide the class method here.
+    #
+    # pkg:gem/railties#lib/rails/railtie.rb:189
+    def configure(&block); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:155
+    def console(&blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:163
+    def generators(&blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:197
+    def inherited(subclass); end
+
+    # Since Rails::Railtie cannot be instantiated, any methods that call
+    # +instance+ are intended to be called only on subclasses of a Railtie.
+    #
+    # pkg:gem/railties#lib/rails/railtie.rb:182
+    def instance; end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:175
+    def railtie_name(name = T.unsafe(nil)); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:151
+    def rake_tasks(&blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:159
+    def runner(&blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:167
+    def server(&blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:147
+    def subclasses; end
+
+    protected
+
+    # pkg:gem/railties#lib/rails/railtie.rb:205
+    def increment_load_index; end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:203
+    def load_index; end
+
+    private
+
+    # pkg:gem/railties#lib/rails/railtie.rb:211
+    def generate_railtie_name(string); end
+
+    # If the class method does not have a method, then send the method call
+    # to the Railtie instance.
+    #
+    # pkg:gem/railties#lib/rails/railtie.rb:223
+    def method_missing(name, *_arg1, **_arg2, &_arg3); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:144
+    def new(*_arg0); end
+
+    # receives an instance variable identifier, set the variable value if is
+    # blank and append given block to value, which will be used later in
+    # `#each_registered_block(type, &block)`
+    #
+    # pkg:gem/railties#lib/rails/railtie.rb:234
+    def register_block_for(type, &blk); end
+
+    # pkg:gem/railties#lib/rails/railtie.rb:215
+    def respond_to_missing?(name, _); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/railtie.rb:141
+Rails::Railtie::ABSTRACT_RAILTIES = T.let(T.unsafe(nil), Array)
+
+# pkg:gem/railties#lib/rails/railtie/configuration.rb:7
+class Rails::Railtie::Configuration
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:8
+  def initialize; end
+
+  # Last configurable block to run. Called after frameworks initialize.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:70
+  def after_initialize(&block); end
+
+  # Called after application routes have been loaded.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:75
+  def after_routes_loaded(&block); end
+
+  # This allows you to modify application's generators from Railties.
+  #
+  # Values set on app_generators will become defaults for application, unless
+  # application overwrites them.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:47
+  def app_generators; end
+
+  # This allows you to modify the application's middlewares from Engines.
+  #
+  # All operations you run on the app_middleware will be replayed on the
+  # application once it is defined and the default_middlewares are
+  # created
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:39
+  def app_middleware; end
+
+  # First configurable block to run. Called before any initializers are run.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:54
+  def before_configuration(&block); end
+
+  # Third configurable block to run. Does not run if +config.eager_load+
+  # set to false.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:60
+  def before_eager_load(&block); end
+
+  # Second configurable block to run. Called before frameworks initialize.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:65
+  def before_initialize(&block); end
+
+  # All namespaces that are eager loaded
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:18
+  def eager_load_namespaces; end
+
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:90
+  def respond_to?(name, include_private = T.unsafe(nil)); end
+
+  # Defines generic callbacks to run before #after_initialize. Useful for
+  # Rails::Railtie subclasses.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:86
+  def to_prepare(&blk); end
+
+  # Array of callbacks defined by #to_prepare.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:80
+  def to_prepare_blocks; end
+
+  # Add directories that should be watched for change.
+  # The key of the hashes should be directories and the values should
+  # be an array of extensions to match in each directory.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:30
+  def watchable_dirs; end
+
+  # Add files that should be watched for change.
+  #
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:23
+  def watchable_files; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:95
+  def actual_method?(key); end
+
+  # pkg:gem/railties#lib/rails/railtie/configuration.rb:99
+  def method_missing(name, *args, &blk); end
+
+  class << self
+    # Expose the eager_load_namespaces at "module" level for convenience.
+    #
+    # pkg:gem/railties#lib/rails/railtie/configuration.rb:13
+    def eager_load_namespaces; end
+  end
+end
+
+# Implements the logic behind +Rails::Command::NotesCommand+. See <tt>rails notes --help</tt> for usage information.
+#
+# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+# represent the line where the annotation lives, its tag, and its text. Note
+# the filename is not stored.
+#
+# Annotations are looked for in comments and modulus whitespace they have to
+# start with the tag optionally followed by a colon. Everything up to the end
+# of the line (or closing ERB comment tag) is considered to be their text.
+#
+# pkg:gem/railties#lib/rails/source_annotation_extractor.rb:21
+class Rails::SourceAnnotationExtractor
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:158
+  def initialize(tag); end
+
+  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+  # The +options+ hash is passed to each annotation's +to_s+.
+  #
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:207
+  def display(results, options = T.unsafe(nil)); end
+
+  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+  # with their annotations.
+  #
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:164
+  def find(dirs); end
+
+  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+  # with their annotations. Files with extensions registered in
+  # <tt>Rails::SourceAnnotationExtractor::Annotation.extensions</tt> are
+  # taken into account. Only files with annotations are included.
+  #
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:172
+  def find_in(dir); end
+
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:156
+  def tag; end
+
+  class << self
+    # Prints all annotations with tag +tag+ under the root directories +app+,
+    # +config+, +db+, +lib+, and +test+ (recursively).
+    #
+    # If +tag+ is <tt>nil</tt>, annotations with either default or registered tags are printed.
+    #
+    # Specific directories can be explicitly set using the <tt>:dirs</tt> key in +options+.
+    #
+    #   Rails::SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true
+    #
+    # If +options+ has a <tt>:tag</tt> flag, it will be passed to each annotation's +to_s+.
+    #
+    # See SourceAnnotationExtractor#find_in for a list of file extensions that will be taken into account.
+    #
+    # This class method is the single entry point for the <tt>rails notes</tt> command.
+    #
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:149
+    def enumerate(tag = T.unsafe(nil), options = T.unsafe(nil)); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/source_annotation_extractor.rb:71
+class Rails::SourceAnnotationExtractor::Annotation < ::Struct
+  # Returns a representation of the annotation that looks like this:
+  #
+  #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+  #
+  # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+  # Otherwise the string contains just line and text.
+  #
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:128
+  def to_s(options = T.unsafe(nil)); end
+
+  class << self
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:72
+    def directories; end
+
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:92
+    def extensions; end
+
+    # Registers additional directories to be included
+    #   Rails::SourceAnnotationExtractor::Annotation.register_directories("spec", "another")
+    #
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:78
+    def register_directories(*dirs); end
+
+    # Registers new Annotations File Extensions
+    #   Rails::SourceAnnotationExtractor::Annotation.register_extensions("css", "scss", "sass", "less", "js") { |tag| /\/\/\s*(#{tag}):?\s*(.*)$/ }
+    #
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:98
+    def register_extensions(*exts, &block); end
+
+    # Registers additional tags
+    #   Rails::SourceAnnotationExtractor::Annotation.register_tags("TESTME", "DEPRECATEME")
+    #
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:88
+    def register_tags(*additional_tags); end
+
+    # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:82
+    def tags; end
+  end
+end
+
+# Wraps a regular expression that will be tested against each of the source
+# file's comments.
+#
+# pkg:gem/railties#lib/rails/source_annotation_extractor.rb:24
+class Rails::SourceAnnotationExtractor::ParserExtractor < ::Struct
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:26
+  def annotations(file); end
+end
+
+# Wraps a regular expression that will iterate through a file's lines and
+# test each one for the given pattern.
+#
+# pkg:gem/railties#lib/rails/source_annotation_extractor.rb:59
+class Rails::SourceAnnotationExtractor::PatternExtractor < ::Struct
+  # pkg:gem/railties#lib/rails/source_annotation_extractor.rb:60
+  def annotations(file); end
+end
+
+# pkg:gem/railties#lib/rails/test_unit/reporter.rb:6
+class Rails::TestUnitReporter < ::Minitest::StatisticsReporter
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:51
+  def aggregated_results; end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:55
+  def filtered_results; end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:84
+  def format_rerun_snippet(result); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:13
+  def prerecord(test_class, test_name); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:20
+  def record(result); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:63
+  def relative_path_for(file); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:43
+  def report; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:94
+  def app_root; end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:119
+  def color_output(string, by:); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:107
+  def colored_output?; end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:76
+  def fail_fast?; end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:80
+  def format_line(result); end
+
+  # pkg:gem/railties#lib/rails/test_unit/reporter.rb:72
+  def output_inline?; end
+
+  class << self
+    # pkg:gem/railties#lib/rails/test_unit/reporter.rb:8
+    def app_root; end
+
+    # pkg:gem/railties#lib/rails/test_unit/reporter.rb:8
+    def app_root=(_arg0); end
+
+    # pkg:gem/railties#lib/rails/test_unit/reporter.rb:11
+    def executable; end
+
+    # pkg:gem/railties#lib/rails/test_unit/reporter.rb:11
+    def executable=(_arg0); end
+  end
+end
+
+# pkg:gem/railties#lib/rails/test_unit/reporter.rb:112
+Rails::TestUnitReporter::COLOR_BY_RESULT_CODE = T.let(T.unsafe(nil), Hash)
+
+# pkg:gem/railties#lib/rails/gem_version.rb:9
+module Rails::VERSION; end
+
+# pkg:gem/railties#lib/rails/gem_version.rb:10
+Rails::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/railties#lib/rails/gem_version.rb:11
+Rails::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/railties#lib/rails/gem_version.rb:13
+Rails::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
+
+# pkg:gem/railties#lib/rails/gem_version.rb:15
+Rails::VERSION::STRING = T.let(T.unsafe(nil), String)
+
+# pkg:gem/railties#lib/rails/gem_version.rb:12
+Rails::VERSION::TINY = T.let(T.unsafe(nil), Integer)
+
+# pkg:gem/railties#lib/rails/welcome_controller.rb:5
+class Rails::WelcomeController < ::Rails::ApplicationController
+  # pkg:gem/railties#lib/rails/welcome_controller.rb:9
+  def index; end
+
+  private
+
+  # pkg:gem/railties#lib/rails/welcome_controller.rb:5
+  def _layout(lookup_context, formats, keys); end
+
+  class << self
+    private
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:6
+    def __class_attr___callbacks; end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:6
+    def __class_attr___callbacks=(new_value); end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:7
+    def __class_attr__layout; end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:7
+    def __class_attr__layout=(new_value); end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:7
+    def __class_attr__layout_conditions; end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:7
+    def __class_attr__layout_conditions=(new_value); end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:5
+    def __class_attr_config; end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:5
+    def __class_attr_config=(new_value); end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:5
+    def __class_attr_middleware_stack; end
+
+    # pkg:gem/railties#lib/rails/welcome_controller.rb:5
+    def __class_attr_middleware_stack=(new_value); end
+  end
+end