sorbet-rails 0.5.0 → 0.5.1

data/spec/support/v5.1/sorbet/rbi/gems/rails-html-sanitizer.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rails-html-sanitizer/all/rails-html-sanitizer.rbi
 #
-# rails-html-sanitizer-1.0.4
+# rails-html-sanitizer-1.2.0
 module Rails
 end
 module Rails::Html
@@ -18,6 +18,7 @@ class Rails::Html::Sanitizer
   def sanitize(html, options = nil); end
   def self.full_sanitizer; end
   def self.link_sanitizer; end
+  def self.safe_list_sanitizer; end
   def self.white_list_sanitizer; end
 end
 class Rails::Html::PermitScrubber < Loofah::Scrubber
@@ -52,7 +53,7 @@ class Rails::Html::LinkSanitizer < Rails::Html::Sanitizer
   def initialize; end
   def sanitize(html, options = nil); end
 end
-class Rails::Html::WhiteListSanitizer < Rails::Html::Sanitizer
+class Rails::Html::SafeListSanitizer < Rails::Html::Sanitizer
   def allowed_attributes(options); end
   def allowed_tags(options); end
   def initialize; end

data/spec/support/v5.1/sorbet/rbi/gems/railties.rbi

@@ -342,36 +342,6 @@ class Rails::Engine::Configuration < Rails::Railtie::Configuration
   def root; end
   def root=(value); end
 end
-module Rails::TestUnit
-end
-class Rails::TestUnit::Runner
-  def filters; end
-  def self.compose_filter(runnable, filter); end
-  def self.extract_filters(argv); end
-  def self.filters; end
-  def self.load_tests(argv); end
-  def self.options(opts); end
-  def self.parse_options(argv); end
-  def self.rake_run(argv = nil); end
-  def self.run(argv = nil); end
-end
-class Rails::TestUnit::CompositeFilter
-  def ===(method); end
-  def derive_line_filters(patterns); end
-  def derive_named_filter(filter); end
-  def initialize(runnable, filter, patterns); end
-  def named_filter; end
-end
-class Rails::TestUnit::Filter
-  def ===(method); end
-  def definition_for(method); end
-  def initialize(runnable, file, line); end
-end
-module Rails::LineFiltering
-  def run(reporter, options = nil); end
-end
-class Rails::TestUnitRailtie < Rails::Railtie
-end
 class SourceAnnotationExtractor
   def display(results, options = nil); end
   def extract_annotations_from(file, pattern); end
@@ -526,182 +496,3 @@ class Rails::Application::DefaultMiddlewareStack
 end
 class Rails::Rack::Logger < ActiveSupport::LogSubscriber
 end
-module Rails::Command
-  def self.command_type; end
-  def self.environment; end
-  def self.file_lookup_paths; end
-  def self.find_by_namespace(namespace, command_name = nil); end
-  def self.hidden_commands; end
-  def self.invoke(full_namespace, args = nil, **config); end
-  def self.lookup_paths; end
-  def self.print_commands; end
-  def self.root; end
-  def self.sorted_groups; end
-  extend ActiveSupport::Autoload
-  extend Rails::Command::Behavior::ClassMethods
-  include Rails::Command::Behavior
-end
-module Rails::Command::Behavior
-  extend ActiveSupport::Concern
-end
-module Rails::Command::Behavior::ClassMethods
-  def levenshtein_distance(str1, str2); end
-  def lookup!; end
-  def lookup(namespaces); end
-  def namespaces_to_paths(namespaces); end
-  def no_color!; end
-  def print_list(base, namespaces); end
-  def subclasses; end
-end
-module Rails::Generators
-  def namespace; end
-  def namespace=(obj); end
-  def self.aliases; end
-  def self.api_only!; end
-  def self.command_type; end
-  def self.configure!(config); end
-  def self.fallbacks; end
-  def self.file_lookup_paths; end
-  def self.find_by_namespace(name, base = nil, context = nil); end
-  def self.help(command = nil); end
-  def self.hidden_namespaces; end
-  def self.hide_namespace(*namespaces); end
-  def self.hide_namespaces(*namespaces); end
-  def self.invoke(namespace, args = nil, config = nil); end
-  def self.invoke_fallbacks_for(name, base); end
-  def self.lookup_paths; end
-  def self.namespace; end
-  def self.namespace=(obj); end
-  def self.no_color!; end
-  def self.options; end
-  def self.print_generators; end
-  def self.print_list(base, namespaces); end
-  def self.public_namespaces; end
-  def self.sorted_groups; end
-  def self.templates_path; end
-  extend Rails::Command::Behavior::ClassMethods
-  include Rails::Command::Behavior
-end
-module Rails::Generators::Testing
-end
-module Rails::Generators::Testing::Behaviour
-  def create_generated_attribute(attribute_type, name = nil, index = nil); end
-  def destination_root_is_set?; end
-  def ensure_current_path; end
-  def generator(args = nil, options = nil, config = nil); end
-  def migration_file_name(relative); end
-  def prepare_destination; end
-  def run_generator(args = nil, config = nil); end
-  extend ActiveSupport::Concern
-  include ActiveSupport::Testing::Stream
-end
-module Rails::Generators::Testing::Behaviour::ClassMethods
-  def arguments(array); end
-  def destination(path); end
-  def tests(klass); end
-end
-module Rails::Generators::Testing::SetupAndTeardown
-  def setup; end
-  def teardown; end
-end
-module Rails::Generators::Testing::Assertions
-  def assert_class_method(method, content, &block); end
-  def assert_directory(relative, *contents); end
-  def assert_field_default_value(attribute_type, value); end
-  def assert_field_type(attribute_type, field_type); end
-  def assert_file(relative, *contents); end
-  def assert_instance_method(method, content); end
-  def assert_method(method, content); end
-  def assert_migration(relative, *contents, &block); end
-  def assert_no_directory(relative); end
-  def assert_no_file(relative); end
-  def assert_no_migration(relative); end
-end
-class Rails::Generators::TestCase < ActiveSupport::TestCase
-  def current_path; end
-  def current_path=(arg0); end
-  def current_path?; end
-  def default_arguments; end
-  def default_arguments=(arg0); end
-  def default_arguments?; end
-  def destination_root; end
-  def destination_root=(arg0); end
-  def destination_root?; end
-  def generator_class; end
-  def generator_class=(arg0); end
-  def generator_class?; end
-  def self.current_path; end
-  def self.current_path=(val); end
-  def self.current_path?; end
-  def self.default_arguments; end
-  def self.default_arguments=(val); end
-  def self.default_arguments?; end
-  def self.destination_root; end
-  def self.destination_root=(val); end
-  def self.destination_root?; end
-  def self.generator_class; end
-  def self.generator_class=(val); end
-  def self.generator_class?; end
-  extend Rails::Generators::Testing::Behaviour::ClassMethods
-  include FileUtils
-  include Rails::Generators::Testing::Assertions
-  include Rails::Generators::Testing::Behaviour
-  include Rails::Generators::Testing::SetupAndTeardown
-end
-module ActiveSupport
-end
-class ActiveSupport::TestCase < Minitest::Test
-  def config; end
-  def config=(arg0); end
-  def config?; end
-  def fixture_class_names; end
-  def fixture_class_names=(arg0); end
-  def fixture_class_names?; end
-  def fixture_path; end
-  def fixture_path?; end
-  def fixture_table_names; end
-  def fixture_table_names=(arg0); end
-  def fixture_table_names?; end
-  def pre_loaded_fixtures; end
-  def pre_loaded_fixtures=(arg0); end
-  def pre_loaded_fixtures?; end
-  def self.config; end
-  def self.config=(val); end
-  def self.config?; end
-  def self.fixture_class_names; end
-  def self.fixture_class_names=(val); end
-  def self.fixture_class_names?; end
-  def self.fixture_path; end
-  def self.fixture_path=(val); end
-  def self.fixture_path?; end
-  def self.fixture_table_names; end
-  def self.fixture_table_names=(val); end
-  def self.fixture_table_names?; end
-  def self.pre_loaded_fixtures; end
-  def self.pre_loaded_fixtures=(val); end
-  def self.pre_loaded_fixtures?; end
-  def self.use_instantiated_fixtures; end
-  def self.use_instantiated_fixtures=(val); end
-  def self.use_instantiated_fixtures?; end
-  def self.use_transactional_tests; end
-  def self.use_transactional_tests=(val); end
-  def self.use_transactional_tests?; end
-  def use_instantiated_fixtures; end
-  def use_instantiated_fixtures=(arg0); end
-  def use_instantiated_fixtures?; end
-  def use_transactional_tests; end
-  def use_transactional_tests=(arg0); end
-  def use_transactional_tests?; end
-  extend ActiveRecord::TestFixtures::ClassMethods
-  include ActiveRecord::TestFixtures
-end
-class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
-  def before_setup; end
-  def self.fixture_path; end
-end
-class Object < BasicObject
-  def create_fixtures(*fixture_set_names, &block); end
-end
-class ActionController::TestCase < ActiveSupport::TestCase
-  def before_setup; end
-end

data/spec/support/v5.1/sorbet/rbi/gems/sqlite3.rbi

@@ -7,7 +7,7 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/sqlite3/all/sqlite3.rbi
 #
-# sqlite3-1.3.13
+# sqlite3-1.4.1
 class SQLite3::Database
   def authorizer(&block); end
   def authorizer=(arg0); end
@@ -25,23 +25,30 @@ class SQLite3::Database
   def create_aggregate_handler(handler); end
   def create_function(name, arity, text_rep = nil, &block); end
   def db_filename(arg0); end
-  def define_aggregator(arg0, arg1); end
+  def define_aggregator(name, aggregator); end
+  def define_aggregator2(arg0, arg1); end
   def define_function(arg0); end
+  def define_function_with_flags(arg0, arg1); end
   def enable_load_extension(arg0); end
   def encoding; end
   def errcode; end
   def errmsg; end
+  def exec_batch(arg0, arg1); end
   def execute(sql, bind_vars = nil, *args, &block); end
   def execute2(sql, *bind_vars); end
   def execute_batch(sql, bind_vars = nil, *args); end
+  def execute_batch2(sql, &block); end
+  def extended_result_codes=(arg0); end
   def filename(db_name = nil); end
   def get_first_row(sql, *bind_vars); end
   def get_first_value(sql, *bind_vars); end
-  def initialize(*arg0); end
+  def initialize(file, options = nil, zvfs = nil); end
   def interrupt; end
   def last_insert_row_id; end
   def load_extension(arg0); end
-  def ordered_map_for(columns, row); end
+  def make_type_translator(should_translate); end
+  def open16(arg0); end
+  def open_v2(arg0, arg1, arg2); end
   def prepare(sql); end
   def query(sql, bind_vars = nil, *args); end
   def readonly?; end
@@ -54,6 +61,7 @@ class SQLite3::Database
   def trace(*arg0); end
   def transaction(mode = nil); end
   def transaction_active?; end
+  def translate_from_db(types, row); end
   def translator; end
   def type_translation; end
   def type_translation=(value); end
@@ -95,6 +103,7 @@ end
 module SQLite3
   def self.const_missing(name); end
   def self.libversion; end
+  def self.sqlcipher?; end
   def self.threadsafe; end
   def self.threadsafe?; end
 end
@@ -108,7 +117,6 @@ module SQLite3::Constants::ErrorCode
 end
 class SQLite3::Exception < StandardError
   def code; end
-  def self.code; end
 end
 class SQLite3::SQLException < SQLite3::Exception
 end

data/spec/support/{v4.2 → v5.1}/sorbet/rbi/gems/web-console.rbi

@@ -1,59 +1,28 @@
 # This file is autogenerated. Do not edit it by hand. Regenerate it with:
 #   srb rbi gems
 
-# typed: true
+# typed: strong
 #
 # If you would like to make changes to this file, great! Please create the gem's shim here:
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/web-console/all/web-console.rbi
 #
-# web-console-2.3.0
-class Exception
-  def bindings; end
-  def set_backtrace_with_binding_of_caller(*args); end
-  def set_backtrace_without_binding_of_caller(arg0); end
-end
+# web-console-3.7.0
 module WebConsole
-  def logger; end
-  def logger=(obj); end
   def self.logger; end
-  def self.logger=(obj); end
+  extend ActiveSupport::Autoload
 end
 class WebConsole::Railtie < Rails::Railtie
 end
-class WebConsole::Error < StandardError
-end
-class WebConsole::DoubleRenderError < WebConsole::Error
-end
-module WebConsole::Helper
+module Kernel
   def console(binding = nil); end
+  def self.console(binding = nil); end
 end
-class WebConsole::Evaluator
-  def cleaner; end
-  def eval(input); end
-  def format_exception(exc); end
-  def initialize(binding = nil); end
-  def self.cleaner; end
-end
-class WebConsole::Session
-  def eval(input); end
-  def id; end
-  def initialize(bindings); end
-  def inmemory_storage; end
-  def self.find(id); end
-  def self.from_binding(binding); end
-  def self.from_exception(exc); end
-  def self.inmemory_storage; end
-  def store_into_memory; end
-  def switch_binding_to(index); end
+module ActionDispatch
 end
-class WebConsole::Template
-  def initialize(env, session); end
-  def render(template); end
-  def self.template_paths; end
-  def self.template_paths=(obj); end
-  def template_paths; end
-  def template_paths=(obj); end
+class ActionDispatch::DebugExceptions
+  def render_exception_with_web_console(request, exception); end
+  def render_exception_without_web_console(request, exception); end
 end
 class WebConsole::Middleware
   def acceptable_content_type?(headers); end
@@ -91,7 +60,7 @@ class WebConsole::Whitelist
 end
 class WebConsole::Request < ActionDispatch::Request
   def acceptable?; end
-  def from_whitelited_ip?; end
+  def from_whitelisted_ip?; end
   def self.whitelisted_ips; end
   def self.whitelisted_ips=(obj); end
   def strict_remote_ip; end
@@ -102,35 +71,3 @@ class WebConsole::Request::GetSecureIp < ActionDispatch::RemoteIp::GetIp
   def filter_proxies(ips); end
   def initialize(req, proxies); end
 end
-class Anonymous_Struct_21 < Struct
-  def body; end
-  def body=(_); end
-  def headers; end
-  def headers=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
-  def status; end
-  def status=(_); end
-end
-class WebConsole::Response < Anonymous_Struct_21
-  def finish; end
-  def write(content); end
-end
-class WebConsole::View < ActionView::Base
-  def only_on_error_page(*args); end
-  def render_inlined_string(template); end
-  def render_javascript(template); end
-  def t(key, options = nil); end
-end
-class WebConsole::WhinyRequest < SimpleDelegator
-  def from_whitelited_ip?; end
-  def logger; end
-  def request; end
-  def whine_unless(condition); end
-end
-class ActionDispatch::DebugExceptions
-  def render_exception_with_web_console(request, exception); end
-  def render_exception_without_web_console(env, exception); end
-end

data/spec/support/v5.1/sorbet/rbi/sorbet-typed/lib/actionpack/all/actionpack.rbi

@@ -5,9 +5,464 @@
 #
 #   https://github.com/sorbet/sorbet-typed/edit/master/lib/actionpack/all/actionpack.rbi
 #
-# typed: strong
+# typed: false
+
+class ActionController::Base < ActionController::Metal
+end
+
+class AbstractController::Base < Object
+end
+
+class ActionController::Metal < AbstractController::Base
+  sig { returns(ActionDispatch::Request) }
+  def request(); end
+
+  sig { returns(ActionDispatch::Response) }
+  def response(); end
+
+  sig { returns(ActionController::Parameters) }
+  def params(); end
+end
+
+module ActionDispatch::Http::Parameters
+  sig { returns(ActionController::Parameters) }
+  def parameters(); end
+
+  # params is an alias of parameters
+  sig { returns(ActionController::Parameters) }
+  def params(); end
+end
+
+class ActionDispatch::Request
+end
+
+class ActionDispatch::Response
+end
+
+class ActionController::Parameters
+  sig { returns(T.self_type) }
+  def permit!; end
+
+  # You can pass _a lot_ of stuff to permit, so filters is left untyped for now.
+  sig { params(filters: T.untyped).returns(ActionController::Parameters) }
+  def permit(*filters); end
+
+  sig { returns(T::Boolean) }
+  def permitted?; end
+
+  sig { params(key: T.any(Symbol, T::Array[Symbol])).returns(ActionController::Parameters) }
+  def require(key); end
+
+  # required is an alias of require
+  sig { params(key: T.any(Symbol, T::Array[Symbol])).returns(ActionController::Parameters) }
+  def required(key); end
+
+  sig { returns(ActiveSupport::HashWithIndifferentAccess) }
+  def to_h; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def to_hash; end
+
+  sig { params(args: String).returns(T.nilable(String)) }
+  def to_query(*args); end
+
+  # to_param is an alias of to_query
+  sig { params(args: String).returns(T.nilable(String)) }
+  def to_param(*args); end
+end
+
+module ActionController::StrongParameters
+  sig { returns(ActionController::Parameters) }
+  def params; end
+end
 
 class ActionDispatch::Routing::RouteSet
-  sig {params(blk: T.proc.bind(ActionDispatch::Routing::Mapper).void).void}
+  sig { params(blk: T.proc.bind(ActionDispatch::Routing::Mapper).void).void }
   def draw(&blk); end
 end
+
+module ActionController::Flash::ClassMethods
+  sig { params(types: Symbol).void }
+  def add_flash_types(*types); end
+end
+
+module ActionController::RequestForgeryProtection::ClassMethods
+  sig do
+    params(
+      only: T.any(T::Array[Symbol], Symbol),
+      except: T.nilable(T.any(T::Array[Symbol], Symbol)),
+      if: T.untyped,
+      unless: T.untyped,
+      prepend: T.untyped,
+      with: T.nilable(Symbol),
+      exception: T.untyped,
+      reset_session: T.untyped,
+      null_session: T.untyped
+    ).void
+  end
+  def protect_from_forgery(
+    only: nil,
+    except: nil,
+    if: nil,
+    unless: nil,
+    prepend: false,
+    with: nil,
+    exception: nil,
+    reset_session: nil,
+    null_session: nil
+  ); end
+end
+
+module ActionDispatch::Routing::Mapper::HttpHelpers
+  # get, put, patch, post, and delete all have the same arguments as
+  # ActionDispatch::Routing::Mapper::Resources#match
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def delete(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def get(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def patch(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def post(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def put(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+end
+
+module ActionDispatch::Routing::Mapper::Resources
+  sig { params(name: T.untyped).returns(T.untyped) }
+  def action_path(name); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def collection(&block); end
+
+  sig do
+    params(
+      name: T.any(String, Symbol, T::Hash[String, String]),
+      controller: T.nilable(T.any(String, Symbol)),
+      action: T.nilable(T.any(String, Symbol)),
+      param: T.nilable(Symbol),
+      module: T.nilable(T.any(String, Symbol)),
+      as: T.nilable(T.any(String, Symbol)),
+      via: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      to: T.nilable(T.any(String, T.proc.returns(T.untyped))),
+      on: T.nilable(Symbol),
+      constraints: T.untyped,
+      defaults: T.nilable(T::Hash[T.untyped, T.untyped]),
+      anchor: T::Boolean,
+      format: T.nilable(T.any(String, T::Boolean)),
+      path: T.nilable(T.any(String, Symbol)),
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def match(
+    name,
+    controller: nil,
+    action: nil,
+    param: :id,
+    module: nil,
+    as: nil,
+    via: nil,
+    to: nil,
+    on: nil,
+    constraints: nil,
+    defaults: nil,
+    anchor: true,
+    format: nil,
+    path: nil,
+    &block
+  ); end
+
+  sig { params(block: T.untyped).returns(T.untyped) }
+  def member(&block); end
+
+  # These are set to T.unsafe(nil) because they do actually have values, but they
+  # can't be determined statically. They take the value of path when no explicit
+  # values are provided.
+  sig do
+    params(
+      path: T.untyped,
+      as: T.untyped,
+      module: T.untyped,
+      shallow_path: T.untyped,
+      shallow_prefix: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def namespace(
+    path,
+    as: T.unsafe(nil),
+    module: T.unsafe(nil),
+    shallow_path: T.unsafe(nil),
+    shallow_prefix: T.unsafe(nil),
+    &block
+  ); end
+
+  sig do
+    params(
+      resources: T.any(String, Symbol),
+      as: T.nilable(T.any(String, Symbol)),
+      controller: T.nilable(T.any(String, Symbol)),
+      concerns: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      param: T.nilable(Symbol),
+      path_names: T.untyped,
+      path: T.untyped,
+      only: T.nilable(T.any(
+        T::Array[T.any(String, Symbol)],
+        String,
+        Symbol
+      )),
+      except: T.nilable(T.any(
+        T::Array[T.any(String, Symbol)],
+        String,
+        Symbol
+      )),
+      shallow: T::Boolean,
+      shallow_path: T.nilable(String),
+      shallow_prefix: T.nilable(String),
+      format: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def resource(
+    *resources,
+    as: nil,
+    controller: nil,
+    concerns: nil,
+    param: nil,
+    path_names: nil,
+    path: nil,
+    only: nil,
+    except: nil,
+    shallow: false,
+    shallow_path: nil,
+    shallow_prefix: nil,
+    format: nil,
+    &block
+  ); end
+
+  sig do
+    params(
+      resources: T.any(String, Symbol),
+      as: T.nilable(T.any(String, Symbol)),
+      controller: T.nilable(T.any(String, Symbol)),
+      concerns: T.nilable(T.any(Symbol, T::Array[Symbol])),
+      param: T.nilable(Symbol),
+      path_names: T.untyped,
+      path: T.untyped,
+      only: T.nilable(T.any(
+        T::Array[T.any(String, Symbol)],
+        String,
+        Symbol
+      )),
+      except: T.nilable(T.any(
+        T::Array[T.any(String, Symbol)],
+        String,
+        Symbol
+      )),
+      shallow: T::Boolean,
+      shallow_path: T.nilable(String),
+      shallow_prefix: T.nilable(String),
+      format: T.untyped,
+      block: T.untyped
+    ).returns(T.untyped)
+  end
+  def resources(
+    *resources,
+    as: nil,
+    controller: nil,
+    concerns: nil,
+    param: nil,
+    path_names: nil,
+    path: nil,
+    only: nil,
+    except: nil,
+    shallow: false,
+    shallow_path: nil,
+    shallow_prefix: nil,
+    format: nil,
+    &block
+  ); end
+
+  sig { params(path: String, to: T.untyped).returns(T.untyped) }
+  def root(path, to: nil); end
+
+  sig { returns(T.untyped) }
+  def shallow; end
+
+  sig { returns(T::Boolean) }
+  def shallow?; end
+end