# This file is autogenerated. Do not edit it by hand. Regenerate it with:
#   srb rbi gems

# typed: true
#
# If you would like to make changes to this file, great! Please create the gem's shim here:
#
#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/actionpack/all/actionpack.rbi
#
# actionpack-5.2.4.3

module ActionPack
  def self.gem_version; end
  def self.version; end
end
module ActionPack::VERSION
end
module Rack
end
module ActionDispatch
  def self.test_app; end
  def self.test_app=(obj); end
  def test_app; end
  def test_app=(obj); end
  extend ActiveSupport::Autoload
end
class ActionDispatch::IllegalStateError < StandardError
end
module ActionDispatch::Http
  extend ActiveSupport::Autoload
end
module ActionDispatch::Session
end
class ActionDispatch::Railtie < Rails::Railtie
end
module AbstractController
  def self.eager_load!; end
  extend ActiveSupport::Autoload
end
module AbstractController::Railties
end
module AbstractController::Railties::RoutesHelpers
  def self.with(routes, include_path_helpers = nil); end
end
module Mime
  def self.[](type); end
  def self.fetch(type); end
end
class Mime::Mimes
  def <<(type); end
  def delete_if; end
  def each; end
  def initialize; end
  def symbols; end
  include Enumerable
end
class Mime::Type
  def ==(mime_type); end
  def ===(list); end
  def =~(mime_type); end
  def all?; end
  def eql?(other); end
  def hash; end
  def html?; end
  def initialize(string, symbol = nil, synonyms = nil); end
  def method_missing(method, *args); end
  def ref; end
  def respond_to_missing?(method, include_private = nil); end
  def self.lookup(string); end
  def self.lookup_by_extension(extension); end
  def self.parse(accept_header); end
  def self.parse_data_with_trailing_star(type); end
  def self.parse_trailing_star(accept_header); end
  def self.register(string, symbol, mime_type_synonyms = nil, extension_synonyms = nil, skip_lookup = nil); end
  def self.register_alias(string, symbol, extension_synonyms = nil); end
  def self.register_callback(&block); end
  def self.unregister(symbol); end
  def string; end
  def symbol; end
  def synonyms; end
  def to_a; end
  def to_ary; end
  def to_s; end
  def to_str; end
  def to_sym; end
end
class Mime::Type::AcceptItem
  def <=>(item); end
  def index; end
  def index=(arg0); end
  def initialize(index, name, q = nil); end
  def name; end
  def name=(arg0); end
  def q; end
  def q=(arg0); end
  def to_s; end
end
class Mime::Type::AcceptList
  def self.find_item_by_name(array, name); end
  def self.sort!(list); end
end
class Mime::AllType < Mime::Type
  def all?; end
  def html?; end
  def initialize; end
  def self.allocate; end
  def self.instance; end
  def self.new(*arg0); end
  extend Singleton::SingletonClassMethods
  include Singleton
end
class Mime::NullType
  def method_missing(method, *args); end
  def nil?; end
  def ref; end
  def respond_to_missing?(method, _); end
  def self.allocate; end
  def self.instance; end
  def self.new(*arg0); end
  extend Singleton::SingletonClassMethods
  include Singleton
end
module AbstractController::Collector
  def atom(*args, &block); end
  def bmp(*args, &block); end
  def css(*args, &block); end
  def csv(*args, &block); end
  def gif(*args, &block); end
  def gzip(*args, &block); end
  def html(*args, &block); end
  def ics(*args, &block); end
  def jpeg(*args, &block); end
  def js(*args, &block); end
  def json(*args, &block); end
  def m4a(*args, &block); end
  def method_missing(symbol, &block); end
  def mp3(*args, &block); end
  def mp4(*args, &block); end
  def mpeg(*args, &block); end
  def multipart_form(*args, &block); end
  def ogg(*args, &block); end
  def otf(*args, &block); end
  def pdf(*args, &block); end
  def png(*args, &block); end
  def rss(*args, &block); end
  def self.generate_method_for_mime(mime); end
  def svg(*args, &block); end
  def text(*args, &block); end
  def tiff(*args, &block); end
  def ttf(*args, &block); end
  def url_encoded_form(*args, &block); end
  def vcf(*args, &block); end
  def vtt(*args, &block); end
  def webm(*args, &block); end
  def woff(*args, &block); end
  def woff2(*args, &block); end
  def xml(*args, &block); end
  def yaml(*args, &block); end
  def zip(*args, &block); end
end
class AbstractController::Error < StandardError
end
class AbstractController::ActionNotFound < StandardError
end
class AbstractController::Base
  def _find_action_name(action_name); end
  def _handle_action_missing(*args); end
  def _valid_action_name?(action_name); end
  def action_method?(name); end
  def action_methods; end
  def action_name; end
  def action_name=(arg0); end
  def available_action?(action_name); end
  def controller_path; end
  def formats; end
  def formats=(arg0); end
  def method_for_action(action_name); end
  def performed?; end
  def process(action, *args); end
  def process_action(method_name, *args); end
  def response_body; end
  def response_body=(arg0); end
  def self.abstract!; end
  def self.abstract; end
  def self.abstract?; end
  def self.action_methods; end
  def self.clear_action_methods!; end
  def self.controller_path; end
  def self.inherited(klass); end
  def self.internal_methods; end
  def self.method_added(name); end
  def self.supports_path?; end
  def send_action(*arg0); end
  extend ActiveSupport::Configurable::ClassMethods
  extend ActiveSupport::DescendantsTracker
  include ActiveSupport::Configurable
end
class AbstractController::DoubleRenderError < AbstractController::Error
  def initialize(message = nil); end
end
module AbstractController::Rendering
  def _normalize_args(action = nil, options = nil); end
  def _normalize_options(options); end
  def _normalize_render(*args, &block); end
  def _process_format(format); end
  def _process_options(options); end
  def _process_variant(options); end
  def _protected_ivars; end
  def _set_html_content_type; end
  def _set_rendered_content_type(format); end
  def render(*args, &block); end
  def render_to_body(options = nil); end
  def render_to_string(*args, &block); end
  def rendered_format; end
  def view_assigns; end
  extend ActiveSupport::Concern
  include ActionView::ViewPaths
end
module AbstractController::Logger
  extend ActiveSupport::Concern
end
module AbstractController::Helpers
  extend ActiveSupport::Concern
end
class AbstractController::Helpers::MissingHelperError < LoadError
  def initialize(error, path); end
end
module AbstractController::Helpers::ClassMethods
  def add_template_helper(mod); end
  def clear_helpers; end
  def default_helper_module!; end
  def helper(*args, &block); end
  def helper_method(*meths); end
  def inherited(klass); end
  def modules_for_helpers(args); end
end
module AbstractController::Translation
  def l(*args); end
  def localize(*args); end
  def t(key, options = nil); end
  def translate(key, options = nil); end
end
module AbstractController::AssetPaths
  extend ActiveSupport::Concern
end
module AbstractController::Callbacks
  def process_action(*args); end
  extend ActiveSupport::Concern
  include ActiveSupport::Callbacks
end
module AbstractController::Callbacks::ClassMethods
  def _insert_callbacks(callbacks, block = nil); end
  def _normalize_callback_option(options, from, to); end
  def _normalize_callback_options(options); end
  def after_action(*names, &blk); end
  def append_after_action(*names, &blk); end
  def append_around_action(*names, &blk); end
  def append_before_action(*names, &blk); end
  def around_action(*names, &blk); end
  def before_action(*names, &blk); end
  def prepend_after_action(*names, &blk); end
  def prepend_around_action(*names, &blk); end
  def prepend_before_action(*names, &blk); end
  def skip_after_action(*names); end
  def skip_around_action(*names); end
  def skip_before_action(*names); end
end
module AbstractController::Caching
  def cache(key, options = nil, &block); end
  def view_cache_dependencies; end
  extend ActiveSupport::Autoload
  extend ActiveSupport::Concern
  include AbstractController::Caching::ConfigMethods
  include AbstractController::Caching::Fragments
end
module AbstractController::Caching::Fragments
  def combined_fragment_cache_key(key); end
  def expire_fragment(key, options = nil); end
  def fragment_cache_key(key); end
  def fragment_exist?(key, options = nil); end
  def instrument_fragment_cache(name, key); end
  def read_fragment(key, options = nil); end
  def write_fragment(key, content, options = nil); end
  extend ActiveSupport::Concern
end
module AbstractController::Caching::Fragments::ClassMethods
  def fragment_cache_key(value = nil, &key); end
end
module AbstractController::Caching::ConfigMethods
  def cache_configured?; end
  def cache_store; end
  def cache_store=(store); end
end
module AbstractController::Caching::ClassMethods
  def view_cache_dependency(&dependency); end
end
module ActionDispatch::Http::FilterRedirect
  def filtered_location; end
  def location_filter_match?; end
  def location_filters; end
end
module ActionDispatch::Http::Cache
end
module ActionDispatch::Http::Cache::Request
  def etag_matches?(etag); end
  def fresh?(response); end
  def if_modified_since; end
  def if_none_match; end
  def if_none_match_etags; end
  def not_modified?(modified_at); end
end
module ActionDispatch::Http::Cache::Response
  def cache_control; end
  def cache_control_headers; end
  def cache_control_segments; end
  def date; end
  def date=(utc_time); end
  def date?; end
  def etag=(weak_validators); end
  def etag?; end
  def generate_strong_etag(validators); end
  def generate_weak_etag(validators); end
  def handle_conditional_get!; end
  def last_modified; end
  def last_modified=(utc_time); end
  def last_modified?; end
  def merge_and_normalize_cache_control!(cache_control); end
  def prepare_cache_control!; end
  def strong_etag=(strong_validators); end
  def strong_etag?; end
  def weak_etag=(weak_validators); end
  def weak_etag?; end
end
class ActionDispatch::Response
  def [](*args, &block); end
  def []=(*args, &block); end
  def _cache_control; end
  def _cache_control=(v); end
  def abort; end
  def assign_default_content_type_and_charset!; end
  def await_commit; end
  def await_sent; end
  def before_committed; end
  def before_sending; end
  def body; end
  def body=(body); end
  def body_parts; end
  def build_buffer(response, body); end
  def charset; end
  def charset=(charset); end
  def close; end
  def code; end
  def commit!; end
  def committed?; end
  def content_type; end
  def content_type=(content_type); end
  def cookies; end
  def default_charset; end
  def default_charset=(obj); end
  def default_headers; end
  def default_headers=(obj); end
  def delete_header(key); end
  def each(&block); end
  def get_header(key); end
  def handle_no_content!; end
  def has_header?(key); end
  def header; end
  def headers; end
  def initialize(status = nil, header = nil, body = nil); end
  def message; end
  def munge_body_object(body); end
  def parse_content_type(content_type); end
  def parsed_content_type_header; end
  def prepare!; end
  def rack_response(status, header); end
  def redirect_url; end
  def request; end
  def request=(arg0); end
  def reset_body!; end
  def response_code; end
  def self.create(status = nil, header = nil, body = nil, default_headers: nil); end
  def self.default_charset; end
  def self.default_charset=(obj); end
  def self.default_headers; end
  def self.default_headers=(obj); end
  def self.merge_default_headers(original, default); end
  def send_file(path); end
  def sending!; end
  def sending?; end
  def sending_file=(v); end
  def sent!; end
  def sent?; end
  def set_content_type(content_type, charset); end
  def set_header(key, v); end
  def status; end
  def status=(status); end
  def status_message; end
  def stream; end
  def to_a; end
  def write(string); end
  include ActionDispatch::Http::Cache::Response
  include ActionDispatch::Http::FilterRedirect
  include MonitorMixin
  include Rack::Response::Helpers
end
class ActionDispatch::Response::Header < Anonymous_Delegator_1
  def []=(k, v); end
  def initialize(response, header); end
  def merge(other); end
  def to_hash; end
end
class ActionDispatch::Response::Buffer
  def abort; end
  def body; end
  def close; end
  def closed?; end
  def each(&block); end
  def each_chunk(&block); end
  def initialize(response, buf); end
  def write(string); end
end
class ActionDispatch::Response::FileBody
  def body; end
  def each; end
  def initialize(path); end
  def to_path; end
end
class ActionDispatch::Response::ContentTypeHeader < Struct
  def charset; end
  def charset=(_); end
  def mime_type; end
  def mime_type=(_); end
  def self.[](*arg0); end
  def self.inspect; end
  def self.members; end
  def self.new(*arg0); end
end
class ActionDispatch::Response::RackBody
  def body; end
  def close; end
  def each(*args, &block); end
  def initialize(response); end
  def respond_to?(method, include_private = nil); end
  def to_ary; end
  def to_path; end
end
module ActionController
  def self.add_renderer(key, &block); end
  def self.remove_renderer(key); end
  extend ActiveSupport::Autoload
end
module ActionController::Live
  def log_error(exception); end
  def new_controller_thread; end
  def process(name); end
  def response_body=(body); end
  extend ActiveSupport::Concern
end
module ActionController::Live::ClassMethods
  def make_response!(request); end
end
class ActionController::Live::SSE
  def close; end
  def initialize(stream, options = nil); end
  def perform_write(json, options); end
  def write(object, options = nil); end
end
class ActionController::Live::ClientDisconnected < RuntimeError
end
class ActionController::Live::Buffer < ActionDispatch::Response::Buffer
  def abort; end
  def call_on_error; end
  def close; end
  def connected?; end
  def each_chunk(&block); end
  def ignore_disconnect; end
  def ignore_disconnect=(arg0); end
  def initialize(response); end
  def on_error(&block); end
  def write(string); end
  include MonitorMixin
end
class ActionController::Live::Response < ActionDispatch::Response
  def before_committed; end
  def build_buffer(response, body); end
end
class ActionDispatch::Http::UploadedFile
  def close(unlink_now = nil); end
  def content_type; end
  def content_type=(arg0); end
  def eof?; end
  def headers; end
  def headers=(arg0); end
  def initialize(hash); end
  def open; end
  def original_filename; end
  def original_filename=(arg0); end
  def path; end
  def read(length = nil, buffer = nil); end
  def rewind; end
  def size; end
  def tempfile; end
  def tempfile=(arg0); end
  def to_io; end
end
class ActionController::ParameterMissing < KeyError
  def initialize(param); end
  def param; end
end
class ActionController::UnpermittedParameters < IndexError
  def initialize(params); end
  def params; end
end
class ActionController::UnfilteredParameters < ArgumentError
  def initialize; end
end
class ActionController::Parameters
  def ==(other); end
  def [](key); end
  def []=(key, value); end
  def always_permitted_parameters; end
  def always_permitted_parameters=(obj); end
  def array_of_permitted_scalars?(value); end
  def as_json(*args, &block); end
  def convert_hashes_to_parameters(key, value); end
  def convert_parameters_to_hashes(value, using); end
  def convert_value_to_parameters(value); end
  def converted_arrays; end
  def deep_dup; end
  def delete(key, &block); end
  def delete_if(&block); end
  def dig(*keys); end
  def each(&block); end
  def each_element(object); end
  def each_pair(&block); end
  def empty?(*args, &block); end
  def except(*keys); end
  def extract!(*keys); end
  def fetch(key, *args); end
  def fields_for_style?; end
  def has_key?(*args, &block); end
  def has_value?(*args, &block); end
  def hash_filter(params, filter); end
  def include?(*args, &block); end
  def init_with(coder); end
  def initialize(parameters = nil); end
  def initialize_copy(source); end
  def inspect; end
  def keep_if(&block); end
  def key?(*args, &block); end
  def keys(*args, &block); end
  def merge!(other_hash); end
  def merge(other_hash); end
  def new_instance_with_inherited_permitted_status(hash); end
  def non_scalar?(value); end
  def parameters; end
  def permit!; end
  def permit(*filters); end
  def permit_any_in_array(array); end
  def permit_any_in_parameters(params); end
  def permitted=(new_permitted); end
  def permitted?; end
  def permitted_scalar?(value); end
  def permitted_scalar_filter(params, key); end
  def reject!(&block); end
  def reject(&block); end
  def require(key); end
  def required(key); end
  def reverse_merge!(other_hash); end
  def reverse_merge(other_hash); end
  def select!(&block); end
  def select(&block); end
  def self.action_on_unpermitted_parameters; end
  def self.action_on_unpermitted_parameters=(obj); end
  def self.always_permitted_parameters; end
  def self.always_permitted_parameters=(obj); end
  def self.hook_into_yaml_loading; end
  def self.permit_all_parameters; end
  def self.permit_all_parameters=(obj); end
  def slice!(*keys); end
  def slice(*keys); end
  def stringify_keys; end
  def to_h; end
  def to_hash; end
  def to_param(*args); end
  def to_query(*args); end
  def to_s(*args, &block); end
  def to_unsafe_h; end
  def to_unsafe_hash; end
  def transform_keys!(&block); end
  def transform_keys(&block); end
  def transform_values!; end
  def transform_values; end
  def unpermitted_keys(params); end
  def unpermitted_parameters!(params); end
  def value?(*args, &block); end
  def values(*args, &block); end
  def values_at(*keys); end
  def with_defaults!(other_hash); end
  def with_defaults(other_hash); end
end
module ActionController::StrongParameters
  def params; end
  def params=(value); end
  extend ActiveSupport::Concern
  include ActiveSupport::Rescuable
end
module ActionController::Railties
end
module ActionController::Railties::Helpers
  def inherited(klass); end
end
class ActionController::Railtie < Rails::Railtie
end
class ActionController::LogSubscriber < ActiveSupport::LogSubscriber
end
module ActionController::ParamsWrapper
  def _extract_parameters(parameters); end
  def _wrap_parameters(parameters); end
  def _wrapper_enabled?; end
  def _wrapper_formats; end
  def _wrapper_key; end
  def process_action(*args); end
  extend ActiveSupport::Concern
end
class Anonymous_Struct_2 < Struct
  def exclude; end
  def exclude=(_); end
  def format; end
  def format=(_); end
  def include; end
  def include=(_); end
  def klass; end
  def klass=(_); end
  def model; end
  def model=(_); end
  def name; end
  def name=(_); end
  def self.[](*arg0); end
  def self.inspect; end
  def self.members; end
  def self.new(*arg0); end
end
class ActionController::ParamsWrapper::Options < Anonymous_Struct_2
  def _default_wrap_model; end
  def include; end
  def initialize(name, format, include, exclude, klass, model); end
  def lock; end
  def locked?; end
  def model; end
  def name; end
  def self.from_hash(hash); end
  def synchronize(&block); end
  def try_lock; end
  def unlock; end
  include Mutex_m
end
module ActionController::ParamsWrapper::ClassMethods
  def _set_wrapper_options(options); end
  def inherited(klass); end
  def wrap_parameters(name_or_model_or_options, options = nil); end
end
class ActionDispatch::MiddlewareStack
  def [](i); end
  def assert_index(index, where); end
  def build(app = nil, &block); end
  def build_middleware(klass, args, block); end
  def delete(target); end
  def each; end
  def initialize(*args); end
  def initialize_copy(other); end
  def insert(index, klass, *args, &block); end
  def insert_after(index, *args, &block); end
  def insert_before(index, klass, *args, &block); end
  def last; end
  def middlewares; end
  def middlewares=(arg0); end
  def size; end
  def swap(target, *args, &block); end
  def unshift(klass, *args, &block); end
  def use(klass, *args, &block); end
  include Enumerable
end
class ActionDispatch::MiddlewareStack::Middleware
  def ==(middleware); end
  def args; end
  def block; end
  def build(app); end
  def initialize(klass, args, block); end
  def inspect; end
  def klass; end
  def name; end
end
class ActionDispatch::Http::Headers
  def [](key); end
  def []=(key, value); end
  def add(key, value); end
  def each(&block); end
  def env; end
  def env_name(key); end
  def fetch(key, default = nil); end
  def include?(key); end
  def initialize(request); end
  def key?(key); end
  def merge!(headers_or_env); end
  def merge(headers_or_env); end
  def self.from_hash(hash); end
  include Enumerable
end
class ActionController::ActionControllerError < StandardError
end
class ActionController::BadRequest < ActionController::ActionControllerError
  def initialize(msg = nil); end
end
class ActionController::RenderError < ActionController::ActionControllerError
end
class ActionController::RoutingError < ActionController::ActionControllerError
  def failures; end
  def initialize(message, failures = nil); end
end
class ActionController::UrlGenerationError < ActionController::ActionControllerError
end
class ActionController::MethodNotAllowed < ActionController::ActionControllerError
  def initialize(*allowed_methods); end
end
class ActionController::NotImplemented < ActionController::MethodNotAllowed
end
class ActionController::MissingFile < ActionController::ActionControllerError
end
class ActionController::SessionOverflowError < ActionController::ActionControllerError
  def initialize(message = nil); end
end
class ActionController::UnknownHttpMethod < ActionController::ActionControllerError
end
class ActionController::UnknownFormat < ActionController::ActionControllerError
end
module ActionDispatch::Http::MimeNegotiation
  def accepts; end
  def content_mime_type; end
  def content_type; end
  def format(view_path = nil); end
  def format=(extension); end
  def format_from_path_extension; end
  def formats; end
  def formats=(extensions); end
  def has_content_type?; end
  def negotiate_mime(order); end
  def use_accept_header; end
  def valid_accept_header; end
  def variant; end
  def variant=(variant); end
  extend ActiveSupport::Concern
end
module ActionDispatch::Http::Parameters
  def binary_params_for?(controller, action); end
  def parameters; end
  def params; end
  def params_parsers; end
  def parse_formatted_parameters(parsers); end
  def path_parameters; end
  def path_parameters=(parameters); end
  def set_binary_encoding(params, controller, action); end
  extend ActiveSupport::Concern
end
class ActionDispatch::Http::Parameters::ParseError < StandardError
  def initialize; end
end
module ActionDispatch::Http::Parameters::ClassMethods
  def parameter_parsers=(parsers); end
end
class ActionDispatch::Http::ParameterFilter
  def compiled_filter; end
  def filter(params); end
  def initialize(filters = nil); end
end
class ActionDispatch::Http::ParameterFilter::CompiledFilter
  def blocks; end
  def call(original_params, parents = nil); end
  def deep_regexps; end
  def initialize(regexps, deep_regexps, blocks); end
  def regexps; end
  def self.compile(filters); end
end
module ActionDispatch::Http::FilterParameters
  def env_filter; end
  def filtered_env; end
  def filtered_parameters; end
  def filtered_path; end
  def filtered_query_string; end
  def initialize; end
  def parameter_filter; end
  def parameter_filter_for(filters); end
end
module ActionDispatch::Http::URL
  def domain(tld_length = nil); end
  def host; end
  def host_with_port; end
  def initialize; end
  def optional_port; end
  def port; end
  def port_string; end
  def protocol; end
  def raw_host_with_port; end
  def self.add_anchor(path, anchor); end
  def self.add_params(path, params); end
  def self.add_trailing_slash(path); end
  def self.build_host_url(host, port, protocol, options, path); end
  def self.extract_domain(host, tld_length); end
  def self.extract_domain_from(host, tld_length); end
  def self.extract_subdomain(host, tld_length); end
  def self.extract_subdomains(host, tld_length); end
  def self.extract_subdomains_from(host, tld_length); end
  def self.full_url_for(options); end
  def self.named_host?(host); end
  def self.normalize_host(_host, options); end
  def self.normalize_port(port, protocol); end
  def self.normalize_protocol(protocol); end
  def self.path_for(options); end
  def self.tld_length; end
  def self.tld_length=(obj); end
  def self.url_for(options); end
  def server_port; end
  def standard_port; end
  def standard_port?; end
  def subdomain(tld_length = nil); end
  def subdomains(tld_length = nil); end
  def tld_length; end
  def tld_length=(obj); end
  def url; end
end
class ActionDispatch::ContentSecurityPolicy
  def apply_mapping(source); end
  def apply_mappings(sources); end
  def base_uri(*sources); end
  def block_all_mixed_content(enabled = nil); end
  def build(context = nil, nonce = nil); end
  def build_directive(sources, context); end
  def build_directives(context, nonce); end
  def child_src(*sources); end
  def connect_src(*sources); end
  def default_src(*sources); end
  def directives; end
  def font_src(*sources); end
  def form_action(*sources); end
  def frame_ancestors(*sources); end
  def frame_src(*sources); end
  def img_src(*sources); end
  def initialize; end
  def initialize_copy(other); end
  def manifest_src(*sources); end
  def media_src(*sources); end
  def nonce_directive?(directive); end
  def object_src(*sources); end
  def plugin_types(*types); end
  def report_uri(uri); end
  def require_sri_for(*types); end
  def resolve_source(source, context); end
  def sandbox(*values); end
  def script_src(*sources); end
  def style_src(*sources); end
  def upgrade_insecure_requests(enabled = nil); end
  def worker_src(*sources); end
end
class ActionDispatch::ContentSecurityPolicy::Middleware
  def call(env); end
  def header_name(request); end
  def html_response?(headers); end
  def initialize(app); end
  def policy_present?(headers); end
end
module ActionDispatch::ContentSecurityPolicy::Request
  def content_security_policy; end
  def content_security_policy=(policy); end
  def content_security_policy_nonce; end
  def content_security_policy_nonce_generator; end
  def content_security_policy_nonce_generator=(generator); end
  def content_security_policy_report_only; end
  def content_security_policy_report_only=(value); end
  def generate_content_security_policy_nonce; end
end
class ActionDispatch::Request
  def GET; end
  def POST; end
  def accept; end
  def accept_charset; end
  def accept_encoding; end
  def accept_language; end
  def auth_type; end
  def authenticated_encrypted_cookie_salt; end
  def authorization; end
  def body; end
  def body_stream; end
  def cache_control; end
  def check_method(name); end
  def client_ip; end
  def commit_cookie_jar!; end
  def commit_flash; end
  def content_length; end
  def controller_class; end
  def controller_class_for(name); end
  def controller_instance; end
  def controller_instance=(controller); end
  def cookie_jar; end
  def cookie_jar=(jar); end
  def cookies_digest; end
  def cookies_rotations; end
  def cookies_serializer; end
  def encrypted_cookie_cipher; end
  def encrypted_cookie_salt; end
  def encrypted_signed_cookie_salt; end
  def engine_script_name(_routes); end
  def engine_script_name=(name); end
  def form_data?; end
  def from; end
  def fullpath; end
  def gateway_interface; end
  def have_cookie_jar?; end
  def headers; end
  def http_auth_salt; end
  def ignore_accept_header; end
  def ignore_accept_header=(obj); end
  def initialize(env); end
  def ip; end
  def key?(key); end
  def key_generator; end
  def local?; end
  def logger; end
  def media_type; end
  def method; end
  def method_symbol; end
  def negotiate; end
  def origin; end
  def original_fullpath; end
  def original_script_name; end
  def original_url; end
  def path_translated; end
  def pragma; end
  def query_parameters; end
  def raw_post; end
  def remote_addr; end
  def remote_host; end
  def remote_ident; end
  def remote_ip; end
  def remote_ip=(remote_ip); end
  def remote_user; end
  def request_id; end
  def request_id=(id); end
  def request_method; end
  def request_method=(request_method); end
  def request_method_symbol; end
  def request_parameters; end
  def request_parameters=(params); end
  def reset_session; end
  def routes; end
  def routes=(routes); end
  def secret_key_base; end
  def secret_token; end
  def self.empty; end
  def self.ignore_accept_header; end
  def self.ignore_accept_header=(obj); end
  def self.parameter_parsers; end
  def send_early_hints(links); end
  def server_addr; end
  def server_name; end
  def server_protocol; end
  def server_software; end
  def session=(session); end
  def session_options=(options); end
  def show_exceptions?; end
  def signed_cookie_digest; end
  def signed_cookie_salt; end
  def ssl?; end
  def use_authenticated_cookie_encryption; end
  def uuid; end
  def version; end
  def x_csrf_token; end
  def x_forwarded_for; end
  def x_forwarded_host; end
  def x_request_id; end
  def xhr?; end
  def xml_http_request?; end
  extend ActionDispatch::Http::Parameters::ClassMethods
  include ActionDispatch::ContentSecurityPolicy::Request
  include ActionDispatch::Http::Cache::Request
  include ActionDispatch::Http::FilterParameters
  include ActionDispatch::Http::MimeNegotiation
  include ActionDispatch::Http::Parameters
  include ActionDispatch::Http::URL
  include Rack::Request::Env
  include Rack::Request::Helpers
end
class ActionDispatch::Request::PASS_NOT_FOUND
  def self.action(_); end
  def self.binary_params_for?(action); end
  def self.call(_); end
end
class ActionController::MiddlewareStack < ActionDispatch::MiddlewareStack
  def build(action, app = nil, &block); end
  def build_middleware(klass, args, block); end
end
class ActionController::MiddlewareStack::Middleware < ActionDispatch::MiddlewareStack::Middleware
  def initialize(klass, args, actions, strategy, block); end
  def valid?(action); end
end
class ActionController::Metal < AbstractController::Base
  def content_type(*args, &block); end
  def content_type=(arg); end
  def controller_name; end
  def dispatch(name, request, response); end
  def headers(*args, &block); end
  def initialize; end
  def location(*args, &block); end
  def location=(arg); end
  def middleware_stack; end
  def middleware_stack=(val); end
  def middleware_stack?; end
  def params; end
  def params=(val); end
  def performed?; end
  def request; end
  def request=(arg0); end
  def reset_session; end
  def response; end
  def response=(arg0); end
  def response_body=(body); end
  def response_code(*args, &block); end
  def self.action(name); end
  def self.binary_params_for?(action); end
  def self.controller_name; end
  def self.dispatch(name, req, res); end
  def self.inherited(base); end
  def self.make_response!(request); end
  def self.middleware; end
  def self.middleware_stack; end
  def self.middleware_stack=(val); end
  def self.middleware_stack?; end
  def self.use(*args, &block); end
  def session(*args, &block); end
  def set_request!(request); end
  def set_response!(response); end
  def status(*args, &block); end
  def status=(arg); end
  def to_a; end
  def url_for(string); end
  include ActionController::Testing::Functional
end
module ActionController::Helpers
  def helpers; end
  def self.helpers_path; end
  def self.helpers_path=(arg0); end
  extend ActiveSupport::Concern
  include AbstractController::Helpers
end
module ActionController::Helpers::ClassMethods
  def all_application_helpers; end
  def all_helpers_from_path(path); end
  def helper_attr(*attrs); end
  def helpers; end
  def modules_for_helpers(args); end
end
module ActionDispatch::Routing
  extend ActiveSupport::Autoload
end
module ActionDispatch::Routing::PolymorphicRoutes
  def edit_polymorphic_path(record_or_hash, options = nil); end
  def edit_polymorphic_url(record_or_hash, options = nil); end
  def new_polymorphic_path(record_or_hash, options = nil); end
  def new_polymorphic_url(record_or_hash, options = nil); end
  def polymorphic_mapping(record); end
  def polymorphic_path(record_or_hash_or_array, options = nil); end
  def polymorphic_path_for_action(action, record_or_hash, options); end
  def polymorphic_url(record_or_hash_or_array, options = nil); end
  def polymorphic_url_for_action(action, record_or_hash, options); end
end
class ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder
  def get_method_for_class(klass); end
  def get_method_for_string(str); end
  def handle_class(klass); end
  def handle_class_call(target, klass); end
  def handle_list(list); end
  def handle_model(record); end
  def handle_model_call(target, record); end
  def handle_string(record); end
  def handle_string_call(target, str); end
  def initialize(key_strategy, prefix, suffix); end
  def polymorphic_mapping(target, record); end
  def prefix; end
  def self.build(action, type); end
  def self.get(action, type); end
  def self.path; end
  def self.plural(prefix, suffix); end
  def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options); end
  def self.singular(prefix, suffix); end
  def self.url; end
  def suffix; end
end
module ActionDispatch::Routing::UrlFor
  def _routes_context; end
  def _with_routes(routes); end
  def full_url_for(options = nil); end
  def initialize(*arg0); end
  def optimize_routes_generation?; end
  def route_for(name, *args); end
  def url_for(options = nil); end
  def url_options; end
  extend ActiveSupport::Concern
  include ActionDispatch::Routing::PolymorphicRoutes
end
module AbstractController::UrlFor
  def _routes; end
  extend ActiveSupport::Concern
  include ActionDispatch::Routing::UrlFor
end
module AbstractController::UrlFor::ClassMethods
  def _routes; end
  def action_methods; end
end
module ActionController::UrlFor
  def url_options; end
  extend ActiveSupport::Concern
  include AbstractController::UrlFor
end
module ActionController::Redirecting
  def _compute_redirect_to_location(request, options); end
  def _extract_redirect_to_status(options, response_status); end
  def _url_host_allowed?(url); end
  def redirect_back(fallback_location:, allow_other_host: nil, **args); end
  def redirect_to(options = nil, response_status = nil); end
  def self._compute_redirect_to_location(request, options); end
  extend ActiveSupport::Concern
  include AbstractController::Logger
  include ActionController::UrlFor
end
module ActionController::Rendering
  def _normalize_args(action = nil, options = nil, &blk); end
  def _normalize_options(options); end
  def _normalize_text(options); end
  def _process_options(options); end
  def _process_variant(options); end
  def _render_in_priorities(options); end
  def _set_html_content_type; end
  def _set_rendered_content_type(format); end
  def process_action(*arg0); end
  def render(*args); end
  def render_to_body(options = nil); end
  def render_to_string(*arg0); end
  extend ActiveSupport::Concern
end
module ActionController::Rendering::ClassMethods
  def inherited(klass); end
  def render(*args, &block); end
  def renderer; end
  def setup_renderer!; end
end
class ActionController::MissingRenderer < LoadError
  def initialize(format); end
end
module ActionController::Renderers
  def _render_to_body_with_renderer(options); end
  def _render_with_renderer_js(js, options); end
  def _render_with_renderer_json(json, options); end
  def _render_with_renderer_xml(xml, options); end
  def render_to_body(options); end
  def self._render_with_renderer_method_name(key); end
  def self.add(key, &block); end
  def self.remove(key); end
  extend ActiveSupport::Concern
end
module ActionController::Renderers::All
  extend ActiveSupport::Concern
  include ActionController::Renderers
end
module ActionController::Renderers::ClassMethods
  def use_renderer(*args); end
  def use_renderers(*args); end
end
module ActionController::Head
  def head(status, options = nil); end
  def include_content?(status); end
end
module ActionController::ConditionalGet
  def combine_etags(validator, options); end
  def expires_in(seconds, options = nil); end
  def expires_now; end
  def fresh_when(object = nil, etag: nil, weak_etag: nil, strong_etag: nil, last_modified: nil, public: nil, template: nil); end
  def http_cache_forever(public: nil); end
  def stale?(object = nil, **freshness_kwargs); end
  extend ActiveSupport::Concern
  include ActionController::Head
end
module ActionController::ConditionalGet::ClassMethods
  def etag(&etagger); end
end
module ActionController::EtagWithTemplateDigest
  def determine_template_etag(options); end
  def lookup_and_digest_template(template); end
  def pick_template_for_etag(options); end
  extend ActiveSupport::Concern
  include ActionController::ConditionalGet
end
module ActionController::EtagWithFlash
  extend ActiveSupport::Concern
  include ActionController::ConditionalGet
end
module ActionController::Caching
  def instrument_name; end
  def instrument_payload(key); end
  extend ActiveSupport::Autoload
  extend ActiveSupport::Concern
end
module ActionController::MimeResponds
  def respond_to(*mimes); end
end
class ActionController::MimeResponds::Collector
  def all(*args, &block); end
  def any(*args, &block); end
  def custom(mime_type, &block); end
  def format; end
  def format=(arg0); end
  def initialize(mimes, variant = nil); end
  def negotiate_format(request); end
  def response; end
  include AbstractController::Collector
end
class ActionController::MimeResponds::Collector::VariantCollector
  def all(*args, &block); end
  def any(*args, &block); end
  def initialize(variant = nil); end
  def method_missing(name, *args, &block); end
  def variant; end
  def variant_key; end
end
module ActionController::BasicImplicitRender
  def default_render(*args); end
  def send_action(method, *args); end
end
module ActionController::ImplicitRender
  def default_render(*args); end
  def interactive_browser_request?; end
  def method_for_action(action_name); end
  include ActionController::BasicImplicitRender
end
module ActionController::ParameterEncoding
  extend ActiveSupport::Concern
end
module ActionController::ParameterEncoding::ClassMethods
  def binary_params_for?(action); end
  def inherited(klass); end
  def setup_param_encode; end
  def skip_parameter_encoding(action); end
end
module ActionController::Cookies
  def cookies; end
  extend ActiveSupport::Concern
end
module ActionController::Flash
  def redirect_to(options = nil, response_status_and_flash = nil); end
  extend ActiveSupport::Concern
end
module ActionController::Flash::ClassMethods
  def add_flash_types(*types); end
end
module ActionController::FormBuilder
  def default_form_builder; end
  extend ActiveSupport::Concern
end
module ActionController::FormBuilder::ClassMethods
  def default_form_builder(builder); end
end
class ActionDispatch::Cookies
  def call(env); end
  def initialize(app); end
end
class ActionDispatch::Cookies::CookieOverflow < StandardError
end
module ActionDispatch::Cookies::ChainedCookieJars
  def encrypted; end
  def encrypted_cookie_cipher; end
  def permanent; end
  def signed; end
  def signed_cookie_digest; end
  def signed_or_encrypted; end
  def upgrade_legacy_hmac_aes_cbc_cookies?; end
  def upgrade_legacy_signed_cookies?; end
end
class ActionDispatch::Cookies::CookieJar
  def [](name); end
  def []=(name, options); end
  def always_write_cookie; end
  def always_write_cookie=(obj); end
  def clear(options = nil); end
  def commit!; end
  def committed?; end
  def delete(name, options = nil); end
  def deleted?(name, options = nil); end
  def each(&block); end
  def escape(string); end
  def fetch(name, *args, &block); end
  def handle_options(options); end
  def has_key?(name); end
  def initialize(request); end
  def key?(name); end
  def make_set_cookie_header(header); end
  def request; end
  def self.always_write_cookie; end
  def self.always_write_cookie=(obj); end
  def self.build(req, cookies); end
  def to_hash(*arg0); end
  def to_header; end
  def update(other_hash); end
  def update_cookies_from_jar; end
  def write(headers); end
  def write_cookie?(cookie); end
  include Enumerable
end
class ActionDispatch::Cookies::AbstractCookieJar
  def [](name); end
  def []=(name, options); end
  def commit(options); end
  def expiry_options(options); end
  def initialize(parent_jar); end
  def parse(name, data); end
  def request; end
  include ActionDispatch::Cookies::ChainedCookieJars
end
class ActionDispatch::Cookies::PermanentCookieJar < ActionDispatch::Cookies::AbstractCookieJar
  def commit(options); end
end
class ActionDispatch::Cookies::JsonSerializer
  def self.dump(value); end
  def self.load(value); end
end
module ActionDispatch::Cookies::SerializedCookieJars
  def deserialize(name); end
  def digest; end
  def needs_migration?(value); end
  def serialize(value); end
  def serializer; end
end
class ActionDispatch::Cookies::SignedKeyRotatingCookieJar < ActionDispatch::Cookies::AbstractCookieJar
  def commit(options); end
  def initialize(parent_jar); end
  def parse(name, signed_message); end
  include ActionDispatch::Cookies::SerializedCookieJars
end
class ActionDispatch::Cookies::EncryptedKeyRotatingCookieJar < ActionDispatch::Cookies::AbstractCookieJar
  def commit(options); end
  def initialize(parent_jar); end
  def parse(name, encrypted_message); end
  def parse_legacy_signed_message(name, legacy_signed_message); end
  include ActionDispatch::Cookies::SerializedCookieJars
end
class ActionController::InvalidAuthenticityToken < ActionController::ActionControllerError
end
class ActionController::InvalidCrossOriginRequest < ActionController::ActionControllerError
end
module ActionController::RequestForgeryProtection
  def any_authenticity_token_valid?; end
  def compare_with_global_token(token, session); end
  def compare_with_real_token(token, session); end
  def csrf_token_hmac(session, identifier); end
  def form_authenticity_param; end
  def form_authenticity_token(form_options: nil); end
  def global_csrf_token(session); end
  def handle_unverified_request; end
  def mark_for_same_origin_verification!; end
  def marked_for_same_origin_verification?; end
  def mask_token(raw_token); end
  def masked_authenticity_token(session, form_options: nil); end
  def non_xhr_javascript_response?; end
  def normalize_action_path(action_path); end
  def per_form_csrf_token(session, action_path, method); end
  def protect_against_forgery?; end
  def real_csrf_token(session); end
  def request_authenticity_tokens; end
  def unmask_token(masked_token); end
  def valid_authenticity_token?(session, encoded_masked_token); end
  def valid_per_form_csrf_token?(token, session); end
  def valid_request_origin?; end
  def verified_request?; end
  def verify_authenticity_token; end
  def verify_same_origin_request; end
  def xor_byte_strings(s1, s2); end
  extend ActiveSupport::Concern
  include AbstractController::Callbacks
  include AbstractController::Helpers
end
module ActionController::RequestForgeryProtection::ClassMethods
  def protect_from_forgery(options = nil); end
  def protection_method_class(name); end
  def skip_forgery_protection(options = nil); end
end
module ActionController::RequestForgeryProtection::ProtectionMethods
end
class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession
  def handle_unverified_request; end
  def initialize(controller); end
end
class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession::NullSessionHash < Rack::Session::Abstract::SessionHash
  def destroy; end
  def exists?; end
  def initialize(req); end
end
class ActionController::RequestForgeryProtection::ProtectionMethods::NullSession::NullCookieJar < ActionDispatch::Cookies::CookieJar
  def write(*arg0); end
end
class ActionController::RequestForgeryProtection::ProtectionMethods::ResetSession
  def handle_unverified_request; end
  def initialize(controller); end
end
class ActionController::RequestForgeryProtection::ProtectionMethods::Exception
  def handle_unverified_request; end
  def initialize(controller); end
end
module ActionController::ContentSecurityPolicy
  def content_security_policy?; end
  def content_security_policy_nonce; end
  def current_content_security_policy; end
  extend ActiveSupport::Concern
  include AbstractController::Callbacks
  include AbstractController::Helpers
end
module ActionController::ContentSecurityPolicy::ClassMethods
  def content_security_policy(enabled = nil, **options, &block); end
  def content_security_policy_report_only(report_only = nil, **options); end
end
module ActionController::ForceSSL
  def force_ssl_redirect(host_or_options = nil); end
  extend ActiveSupport::Concern
  include AbstractController::Callbacks
end
module ActionController::ForceSSL::ClassMethods
  def force_ssl(options = nil); end
end
module ActionController::Streaming
  def _process_options(options); end
  def _render_template(options); end
  extend ActiveSupport::Concern
end
module ActionController::DataStreaming
  def send_data(data, options = nil); end
  def send_file(path, options = nil); end
  def send_file_headers!(options); end
  extend ActiveSupport::Concern
  include ActionController::Rendering
end
module ActionController::HttpAuthentication
end
module ActionController::HttpAuthentication::Basic
  def auth_param(request); end
  def auth_scheme(request); end
  def authenticate(request, &login_procedure); end
  def authentication_request(controller, realm, message); end
  def decode_credentials(request); end
  def encode_credentials(user_name, password); end
  def has_basic_credentials?(request); end
  def user_name_and_password(request); end
  extend ActionController::HttpAuthentication::Basic
end
module ActionController::HttpAuthentication::Basic::ControllerMethods
  def authenticate_or_request_with_http_basic(realm = nil, message = nil, &login_procedure); end
  def authenticate_with_http_basic(&login_procedure); end
  def request_http_basic_authentication(realm = nil, message = nil); end
  extend ActiveSupport::Concern
end
module ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
  def http_basic_authenticate_with(options = nil); end
end
module ActionController::HttpAuthentication::Digest
  def authenticate(request, realm, &password_procedure); end
  def authentication_header(controller, realm); end
  def authentication_request(controller, realm, message = nil); end
  def decode_credentials(header); end
  def decode_credentials_header(request); end
  def encode_credentials(http_method, credentials, password, password_is_ha1); end
  def expected_response(http_method, uri, credentials, password, password_is_ha1 = nil); end
  def ha1(credentials, password); end
  def nonce(secret_key, time = nil); end
  def opaque(secret_key); end
  def secret_token(request); end
  def validate_digest_response(request, realm, &password_procedure); end
  def validate_nonce(secret_key, request, value, seconds_to_timeout = nil); end
  extend ActionController::HttpAuthentication::Digest
end
module ActionController::HttpAuthentication::Digest::ControllerMethods
  def authenticate_or_request_with_http_digest(realm = nil, message = nil, &password_procedure); end
  def authenticate_with_http_digest(realm = nil, &password_procedure); end
  def request_http_digest_authentication(realm = nil, message = nil); end
end
module ActionController::HttpAuthentication::Token
  def authenticate(controller, &login_procedure); end
  def authentication_request(controller, realm, message = nil); end
  def encode_credentials(token, options = nil); end
  def params_array_from(raw_params); end
  def raw_params(auth); end
  def rewrite_param_values(array_params); end
  def token_and_options(request); end
  def token_params_from(auth); end
  extend ActionController::HttpAuthentication::Token
end
module ActionController::HttpAuthentication::Token::ControllerMethods
  def authenticate_or_request_with_http_token(realm = nil, message = nil, &login_procedure); end
  def authenticate_with_http_token(&login_procedure); end
  def request_http_token_authentication(realm = nil, message = nil); end
end
module ActionController::Rescue
  def process_action(*args); end
  def show_detailed_exceptions?; end
  extend ActiveSupport::Concern
  include ActiveSupport::Rescuable
end
module ActionController::Instrumentation
  def append_info_to_payload(payload); end
  def cleanup_view_runtime; end
  def halted_callback_hook(filter); end
  def process_action(*args); end
  def redirect_to(*args); end
  def render(*args); end
  def send_data(data, options = nil); end
  def send_file(path, options = nil); end
  def view_runtime; end
  def view_runtime=(arg0); end
  extend ActiveSupport::Concern
  include AbstractController::Logger
end
module ActionController::Instrumentation::ClassMethods
  def log_process_action(payload); end
end
class ActionController::Renderer
  def controller; end
  def defaults; end
  def initialize(controller, env, defaults); end
  def new(env = nil); end
  def normalize_keys(env); end
  def rack_key_for(key); end
  def rack_value_for(key, value); end
  def render(*args); end
  def self.for(controller, env = nil, defaults = nil); end
  def with_defaults(defaults); end
end
class ActionController::Base < ActionController::Metal
  def __callbacks; end
  def __callbacks?; end
  def _helper_methods; end
  def _helper_methods=(val); end
  def _helper_methods?; end
  def _helpers; end
  def _helpers=(val); end
  def _helpers?; end
  def _layout(formats); end
  def _process_action_callbacks; end
  def _protected_ivars; end
  def _renderers; end
  def _renderers=(val); end
  def _renderers?; end
  def _run_process_action_callbacks(&block); end
  def _view_cache_dependencies; end
  def _view_cache_dependencies=(val); end
  def _view_cache_dependencies?; end
  def _view_paths; end
  def _view_paths=(val); end
  def _view_paths?; end
  def _wrapper_options; end
  def _wrapper_options=(val); end
  def _wrapper_options?; end
  def alert; end
  def allow_forgery_protection; end
  def allow_forgery_protection=(value); end
  def asset_host; end
  def asset_host=(value); end
  def assets_dir; end
  def assets_dir=(value); end
  def default_asset_host_protocol; end
  def default_asset_host_protocol=(value); end
  def default_protect_from_forgery; end
  def default_protect_from_forgery=(value); end
  def default_static_extension; end
  def default_static_extension=(value); end
  def default_url_options; end
  def default_url_options=(val); end
  def default_url_options?; end
  def enable_fragment_cache_logging; end
  def enable_fragment_cache_logging=(value); end
  def etag_with_template_digest; end
  def etag_with_template_digest=(val); end
  def etag_with_template_digest?; end
  def etaggers; end
  def etaggers=(val); end
  def etaggers?; end
  def flash(*args, &block); end
  def forgery_protection_origin_check; end
  def forgery_protection_origin_check=(value); end
  def forgery_protection_strategy; end
  def forgery_protection_strategy=(value); end
  def fragment_cache_keys; end
  def fragment_cache_keys=(val); end
  def fragment_cache_keys?; end
  def helpers_path; end
  def helpers_path=(val); end
  def helpers_path?; end
  def include_all_helpers; end
  def include_all_helpers=(val); end
  def include_all_helpers?; end
  def javascripts_dir; end
  def javascripts_dir=(value); end
  def log_warning_on_csrf_failure; end
  def log_warning_on_csrf_failure=(value); end
  def logger; end
  def logger=(value); end
  def notice; end
  def per_form_csrf_tokens; end
  def per_form_csrf_tokens=(value); end
  def perform_caching; end
  def perform_caching=(value); end
  def relative_url_root; end
  def relative_url_root=(value); end
  def request_forgery_protection_token; end
  def request_forgery_protection_token=(value); end
  def rescue_handlers; end
  def rescue_handlers=(val); end
  def rescue_handlers?; end
  def self.__callbacks; end
  def self.__callbacks=(val); end
  def self.__callbacks?; end
  def self._default_form_builder; end
  def self._default_form_builder=(val); end
  def self._default_form_builder?; end
  def self._flash_types; end
  def self._flash_types=(val); end
  def self._flash_types?; end
  def self._helper_methods; end
  def self._helper_methods=(val); end
  def self._helper_methods?; end
  def self._helpers; end
  def self._helpers=(val); end
  def self._helpers?; end
  def self._layout; end
  def self._layout=(val); end
  def self._layout?; end
  def self._layout_conditions; end
  def self._layout_conditions=(val); end
  def self._layout_conditions?; end
  def self._process_action_callbacks; end
  def self._process_action_callbacks=(value); end
  def self._renderers; end
  def self._renderers=(val); end
  def self._renderers?; end
  def self._view_cache_dependencies; end
  def self._view_cache_dependencies=(val); end
  def self._view_cache_dependencies?; end
  def self._view_paths; end
  def self._view_paths=(val); end
  def self._view_paths?; end
  def self._wrapper_options; end
  def self._wrapper_options=(val); end
  def self._wrapper_options?; end
  def self.allow_forgery_protection; end
  def self.allow_forgery_protection=(value); end
  def self.asset_host; end
  def self.asset_host=(value); end
  def self.assets_dir; end
  def self.assets_dir=(value); end
  def self.default_asset_host_protocol; end
  def self.default_asset_host_protocol=(value); end
  def self.default_protect_from_forgery; end
  def self.default_protect_from_forgery=(value); end
  def self.default_static_extension; end
  def self.default_static_extension=(value); end
  def self.default_url_options; end
  def self.default_url_options=(val); end
  def self.default_url_options?; end
  def self.enable_fragment_cache_logging; end
  def self.enable_fragment_cache_logging=(value); end
  def self.etag_with_template_digest; end
  def self.etag_with_template_digest=(val); end
  def self.etag_with_template_digest?; end
  def self.etaggers; end
  def self.etaggers=(val); end
  def self.etaggers?; end
  def self.forgery_protection_origin_check; end
  def self.forgery_protection_origin_check=(value); end
  def self.forgery_protection_strategy; end
  def self.forgery_protection_strategy=(value); end
  def self.fragment_cache_keys; end
  def self.fragment_cache_keys=(val); end
  def self.fragment_cache_keys?; end
  def self.helpers_path; end
  def self.helpers_path=(val); end
  def self.helpers_path?; end
  def self.include_all_helpers; end
  def self.include_all_helpers=(val); end
  def self.include_all_helpers?; end
  def self.javascripts_dir; end
  def self.javascripts_dir=(value); end
  def self.log_warning_on_csrf_failure; end
  def self.log_warning_on_csrf_failure=(value); end
  def self.logger; end
  def self.logger=(value); end
  def self.make_response!(request); end
  def self.middleware_stack; end
  def self.per_form_csrf_tokens; end
  def self.per_form_csrf_tokens=(value); end
  def self.perform_caching; end
  def self.perform_caching=(value); end
  def self.relative_url_root; end
  def self.relative_url_root=(value); end
  def self.request_forgery_protection_token; end
  def self.request_forgery_protection_token=(value); end
  def self.rescue_handlers; end
  def self.rescue_handlers=(val); end
  def self.rescue_handlers?; end
  def self.stylesheets_dir; end
  def self.stylesheets_dir=(value); end
  def self.without_modules(*modules); end
  def stylesheets_dir; end
  def stylesheets_dir=(value); end
  extend AbstractController::Caching::ClassMethods
  extend AbstractController::Caching::ConfigMethods
  extend AbstractController::Caching::Fragments::ClassMethods
  extend AbstractController::Callbacks::ClassMethods
  extend AbstractController::Helpers::ClassMethods
  extend AbstractController::UrlFor::ClassMethods
  extend ActionController::ConditionalGet::ClassMethods
  extend ActionController::ContentSecurityPolicy::ClassMethods
  extend ActionController::Flash::ClassMethods
  extend ActionController::ForceSSL::ClassMethods
  extend ActionController::FormBuilder::ClassMethods
  extend ActionController::Helpers::ClassMethods
  extend ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
  extend ActionController::Instrumentation::ClassMethods
  extend ActionController::ParameterEncoding::ClassMethods
  extend ActionController::ParamsWrapper::ClassMethods
  extend ActionController::Renderers::ClassMethods
  extend ActionController::Rendering::ClassMethods
  extend ActionController::RequestForgeryProtection::ClassMethods
  extend ActionView::Layouts::ClassMethods
  extend ActionView::Rendering::ClassMethods
  extend ActionView::ViewPaths::ClassMethods
  extend ActiveSupport::Callbacks::ClassMethods
  extend ActiveSupport::DescendantsTracker
  extend ActiveSupport::Rescuable::ClassMethods
  include AbstractController::AssetPaths
  include AbstractController::Caching
  include AbstractController::Caching::Fragments
  include AbstractController::Callbacks
  include AbstractController::Callbacks
  include AbstractController::Callbacks
  include AbstractController::Callbacks
  include AbstractController::Helpers
  include AbstractController::Helpers
  include AbstractController::Helpers
  include AbstractController::Logger
  include AbstractController::Logger
  include AbstractController::Rendering
  include AbstractController::Translation
  include AbstractController::UrlFor
  include ActionController::Caching
  include ActionController::ConditionalGet
  include ActionController::ConditionalGet
  include ActionController::ConditionalGet
  include ActionController::ContentSecurityPolicy
  include ActionController::Cookies
  include ActionController::DataStreaming
  include ActionController::EtagWithFlash
  include ActionController::EtagWithTemplateDigest
  include ActionController::Flash
  include ActionController::ForceSSL
  include ActionController::FormBuilder
  include ActionController::Helpers
  include ActionController::HttpAuthentication::Basic::ControllerMethods
  include ActionController::HttpAuthentication::Digest::ControllerMethods
  include ActionController::HttpAuthentication::Token::ControllerMethods
  include ActionController::ImplicitRender
  include ActionController::Instrumentation
  include ActionController::MimeResponds
  include ActionController::ParameterEncoding
  include ActionController::ParamsWrapper
  include ActionController::Redirecting
  include ActionController::Renderers
  include ActionController::Renderers::All
  include ActionController::Rendering
  include ActionController::Rendering
  include ActionController::RequestForgeryProtection
  include ActionController::Rescue
  include ActionController::Streaming
  include ActionController::StrongParameters
  include ActionController::UrlFor
  include ActionController::UrlFor
  include ActionDispatch::Routing::UrlFor
  include ActionView::Layouts
  include ActionView::Rendering
  include ActionView::ViewPaths
  include ActionView::ViewPaths
  include ActiveSupport::Benchmarkable
  include ActiveSupport::Callbacks
  include ActiveSupport::Rescuable
  include ActiveSupport::Rescuable
end
module ActionController::ApiRendering
  def render_to_body(options = nil); end
  extend ActiveSupport::Concern
end
class ActionController::API < ActionController::Metal
  def __callbacks; end
  def __callbacks?; end
  def _process_action_callbacks; end
  def _renderers; end
  def _renderers=(val); end
  def _renderers?; end
  def _run_process_action_callbacks(&block); end
  def _view_paths; end
  def _view_paths=(val); end
  def _view_paths?; end
  def _wrapper_options; end
  def _wrapper_options=(val); end
  def _wrapper_options?; end
  def default_url_options; end
  def default_url_options=(val); end
  def default_url_options?; end
  def etaggers; end
  def etaggers=(val); end
  def etaggers?; end
  def logger; end
  def logger=(value); end
  def rescue_handlers; end
  def rescue_handlers=(val); end
  def rescue_handlers?; end
  def self.__callbacks; end
  def self.__callbacks=(val); end
  def self.__callbacks?; end
  def self._process_action_callbacks; end
  def self._process_action_callbacks=(value); end
  def self._renderers; end
  def self._renderers=(val); end
  def self._renderers?; end
  def self._view_paths; end
  def self._view_paths=(val); end
  def self._view_paths?; end
  def self._wrapper_options; end
  def self._wrapper_options=(val); end
  def self._wrapper_options?; end
  def self.default_url_options; end
  def self.default_url_options=(val); end
  def self.default_url_options?; end
  def self.etaggers; end
  def self.etaggers=(val); end
  def self.etaggers?; end
  def self.logger; end
  def self.logger=(value); end
  def self.middleware_stack; end
  def self.rescue_handlers; end
  def self.rescue_handlers=(val); end
  def self.rescue_handlers?; end
  def self.without_modules(*modules); end
  extend AbstractController::Callbacks::ClassMethods
  extend AbstractController::UrlFor::ClassMethods
  extend ActionController::ConditionalGet::ClassMethods
  extend ActionController::ForceSSL::ClassMethods
  extend ActionController::Instrumentation::ClassMethods
  extend ActionController::ParamsWrapper::ClassMethods
  extend ActionController::Renderers::ClassMethods
  extend ActionController::Rendering::ClassMethods
  extend ActionView::ViewPaths::ClassMethods
  extend ActiveSupport::Callbacks::ClassMethods
  extend ActiveSupport::DescendantsTracker
  extend ActiveSupport::Rescuable::ClassMethods
  include AbstractController::Callbacks
  include AbstractController::Callbacks
  include AbstractController::Logger
  include AbstractController::Logger
  include AbstractController::Rendering
  include AbstractController::UrlFor
  include ActionController::ApiRendering
  include ActionController::BasicImplicitRender
  include ActionController::ConditionalGet
  include ActionController::DataStreaming
  include ActionController::ForceSSL
  include ActionController::Instrumentation
  include ActionController::ParamsWrapper
  include ActionController::Redirecting
  include ActionController::Renderers
  include ActionController::Renderers::All
  include ActionController::Rendering
  include ActionController::Rendering
  include ActionController::Rescue
  include ActionController::StrongParameters
  include ActionController::UrlFor
  include ActionController::UrlFor
  include ActionDispatch::Routing::UrlFor
  include ActionView::ViewPaths
  include ActiveSupport::Benchmarkable
  include ActiveSupport::Callbacks
  include ActiveSupport::Rescuable
  include ActiveSupport::Rescuable
end
module ActionDispatch::Journey
end
class ActionDispatch::Journey::Router
  def ast; end
  def custom_routes; end
  def eager_load!; end
  def filter_routes(path); end
  def find_routes(req); end
  def initialize(routes); end
  def match_head_routes(routes, req); end
  def match_routes(routes, req); end
  def partitioned_routes; end
  def recognize(rails_req); end
  def routes; end
  def routes=(arg0); end
  def serve(req); end
  def simulator; end
  def visualizer; end
end
class ActionDispatch::Journey::Router::Utils
  def self.escape_fragment(fragment); end
  def self.escape_path(path); end
  def self.escape_segment(segment); end
  def self.normalize_path(path); end
  def self.unescape_uri(uri); end
end
class ActionDispatch::Journey::Router::Utils::UriEncoder
  def escape(component, pattern); end
  def escape_fragment(fragment); end
  def escape_path(path); end
  def escape_segment(segment); end
  def percent_encode(unsafe); end
  def unescape_uri(uri); end
end
class ActionDispatch::Journey::Routes
  def add_route(name, mapping); end
  def anchored_routes; end
  def ast; end
  def clear; end
  def clear_cache!; end
  def custom_routes; end
  def each(&block); end
  def empty?; end
  def initialize; end
  def last; end
  def length; end
  def partition_route(route); end
  def routes; end
  def simulator; end
  def size; end
  include Enumerable
end
class ActionDispatch::Journey::Formatter
  def build_cache; end
  def cache; end
  def clear; end
  def extract_parameterized_parts(route, options, recall, parameterize = nil); end
  def generate(name, options, path_parameters, parameterize = nil); end
  def initialize(routes); end
  def match_route(name, options); end
  def missing_keys(route, parts); end
  def named_routes; end
  def non_recursive(cache, options); end
  def possibles(cache, options, depth = nil); end
  def routes; end
end
module ActionDispatch::Journey::Formatter::RegexCaseComparator
  def self.===(regex); end
end
class ActionDispatch::Journey::Scanner
  def eos?; end
  def initialize; end
  def next_token; end
  def pos; end
  def pre_match; end
  def scan; end
  def scan_setup(str); end
end
class ActionDispatch::Journey::Format
  def evaluate(hash); end
  def initialize(parts); end
  def self.required_path(symbol); end
  def self.required_segment(symbol); end
end
class ActionDispatch::Journey::Format::Parameter < Struct
  def escape(value); end
  def escaper; end
  def escaper=(_); end
  def name; end
  def name=(_); end
  def self.[](*arg0); end
  def self.inspect; end
  def self.members; end
  def self.new(*arg0); end
end
module ActionDispatch::Journey::Visitors
end
class ActionDispatch::Journey::Visitors::Visitor
  def accept(node); end
  def binary(node); end
  def nary(node); end
  def terminal(node); end
  def unary(node); end
  def visit(node); end
  def visit_CAT(n); end
  def visit_DOT(n); end
  def visit_GROUP(n); end
  def visit_LITERAL(n); end
  def visit_OR(n); end
  def visit_SLASH(n); end
  def visit_STAR(n); end
  def visit_SYMBOL(n); end
end
class ActionDispatch::Journey::Visitors::FunctionalVisitor
  def accept(node, seed); end
  def binary(node, seed); end
  def nary(node, seed); end
  def terminal(node, seed); end
  def unary(node, seed); end
  def visit(node, seed); end
  def visit_CAT(n, seed); end
  def visit_DOT(n, seed); end
  def visit_GROUP(n, seed); end
  def visit_LITERAL(n, seed); end
  def visit_OR(n, seed); end
  def visit_SLASH(n, seed); end
  def visit_STAR(n, seed); end
  def visit_SYMBOL(n, seed); end
end
class ActionDispatch::Journey::Visitors::FormatBuilder < ActionDispatch::Journey::Visitors::Visitor
  def accept(node); end
  def binary(node); end
  def terminal(node); end
  def visit_GROUP(n); end
  def visit_STAR(n); end
  def visit_SYMBOL(n); end
end
class ActionDispatch::Journey::Visitors::Each < ActionDispatch::Journey::Visitors::FunctionalVisitor
  def visit(node, block); end
end
class ActionDispatch::Journey::Visitors::String < ActionDispatch::Journey::Visitors::FunctionalVisitor
  def binary(node, seed); end
  def nary(node, seed); end
  def terminal(node, seed); end
  def visit_GROUP(node, seed); end
end
class ActionDispatch::Journey::Visitors::Dot < ActionDispatch::Journey::Visitors::FunctionalVisitor
  def accept(node, seed = nil); end
  def binary(node, seed); end
  def initialize; end
  def nary(node, seed); end
  def terminal(node, seed); end
  def unary(node, seed); end
  def visit_CAT(node, seed); end
  def visit_GROUP(node, seed); end
  def visit_OR(node, seed); end
  def visit_STAR(node, seed); end
end
module ActionDispatch::Journey::Nodes
end
class ActionDispatch::Journey::Nodes::Node
  def cat?; end
  def each(&block); end
  def group?; end
  def initialize(left); end
  def left; end
  def left=(arg0); end
  def literal?; end
  def memo; end
  def memo=(arg0); end
  def name; end
  def star?; end
  def symbol?; end
  def terminal?; end
  def to_dot; end
  def to_s; end
  def to_sym; end
  def type; end
  include Enumerable
end
class ActionDispatch::Journey::Nodes::Terminal < ActionDispatch::Journey::Nodes::Node
  def symbol; end
  def terminal?; end
end
class ActionDispatch::Journey::Nodes::Literal < ActionDispatch::Journey::Nodes::Terminal
  def literal?; end
  def type; end
end
class ActionDispatch::Journey::Nodes::Dummy < ActionDispatch::Journey::Nodes::Literal
  def initialize(x = nil); end
  def literal?; end
end
class ActionDispatch::Journey::Nodes::Symbol < ActionDispatch::Journey::Nodes::Terminal
  def default_regexp?; end
  def initialize(left); end
  def name; end
  def regexp; end
  def regexp=(arg0); end
  def symbol; end
  def symbol?; end
  def type; end
end
class ActionDispatch::Journey::Nodes::Slash < ActionDispatch::Journey::Nodes::Terminal
  def type; end
end
class ActionDispatch::Journey::Nodes::Dot < ActionDispatch::Journey::Nodes::Terminal
  def type; end
end
class ActionDispatch::Journey::Nodes::Unary < ActionDispatch::Journey::Nodes::Node
  def children; end
end
class ActionDispatch::Journey::Nodes::Group < ActionDispatch::Journey::Nodes::Unary
  def group?; end
  def type; end
end
class ActionDispatch::Journey::Nodes::Star < ActionDispatch::Journey::Nodes::Unary
  def name; end
  def star?; end
  def type; end
end
class ActionDispatch::Journey::Nodes::Binary < ActionDispatch::Journey::Nodes::Node
  def children; end
  def initialize(left, right); end
  def right; end
  def right=(arg0); end
end
class ActionDispatch::Journey::Nodes::Cat < ActionDispatch::Journey::Nodes::Binary
  def cat?; end
  def type; end
end
class ActionDispatch::Journey::Nodes::Or < ActionDispatch::Journey::Nodes::Node
  def children; end
  def initialize(children); end
  def type; end
end
class ActionDispatch::Journey::Parser < Racc::Parser
  def _reduce_1(val, _values); end
  def _reduce_10(val, _values); end
  def _reduce_15(val, _values); end
  def _reduce_16(val, _values); end
  def _reduce_17(val, _values); end
  def _reduce_18(val, _values); end
  def _reduce_2(val, _values); end
  def _reduce_7(val, _values); end
  def _reduce_8(val, _values); end
  def _reduce_9(val, _values); end
  def _reduce_none(val, _values); end
  def initialize; end
  def next_token; end
  def parse(string); end
  def self.parse(string); end
  include ActionDispatch::Journey::Nodes
end
class ActionDispatch::Journey::Route
  def app; end
  def ast; end
  def conditions; end
  def constraints; end
  def defaults; end
  def dispatcher?; end
  def eager_load!; end
  def format(path_options); end
  def glob?; end
  def initialize(name, app, path, constraints, required_defaults, defaults, request_method_match, precedence, internal = nil); end
  def internal; end
  def ip; end
  def match_verb(request); end
  def matches?(request); end
  def name; end
  def parts; end
  def path; end
  def precedence; end
  def required_default?(key); end
  def required_defaults; end
  def required_keys; end
  def required_parts; end
  def requirements; end
  def requires_matching_verb?; end
  def score(supplied_keys); end
  def segment_keys; end
  def segments; end
  def self.build(name, app, path, constraints, required_defaults, defaults); end
  def self.verb_matcher(verb); end
  def verb; end
  def verbs; end
end
module ActionDispatch::Journey::Route::VerbMatchers
end
class ActionDispatch::Journey::Route::VerbMatchers::DELETE
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::GET
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::HEAD
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::OPTIONS
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::LINK
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::PATCH
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::POST
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::PUT
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::TRACE
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::UNLINK
  def self.call(req); end
  def self.verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::Unknown
  def call(request); end
  def initialize(verb); end
  def verb; end
end
class ActionDispatch::Journey::Route::VerbMatchers::All
  def self.call(_); end
  def self.verb; end
end
module ActionDispatch::Journey::Path
end
class ActionDispatch::Journey::Path::Pattern
  def =~(other); end
  def anchored; end
  def ast; end
  def build_formatter; end
  def eager_load!; end
  def initialize(ast, requirements, separators, anchored); end
  def match(other); end
  def names; end
  def offsets; end
  def optional_names; end
  def regexp_visitor; end
  def required_names; end
  def requirements; end
  def self.build(path, requirements, separators, anchored); end
  def self.from_string(string); end
  def source; end
  def spec; end
  def to_regexp; end
end
class ActionDispatch::Journey::Path::Pattern::AnchoredRegexp < ActionDispatch::Journey::Visitors::Visitor
  def accept(node); end
  def initialize(separator, matchers); end
  def visit_CAT(node); end
  def visit_DOT(node); end
  def visit_GROUP(node); end
  def visit_LITERAL(node); end
  def visit_OR(node); end
  def visit_SLASH(node); end
  def visit_STAR(node); end
  def visit_SYMBOL(node); end
end
class ActionDispatch::Journey::Path::Pattern::UnanchoredRegexp < ActionDispatch::Journey::Path::Pattern::AnchoredRegexp
  def accept(node); end
end
class ActionDispatch::Journey::Path::Pattern::MatchData
  def [](x); end
  def captures; end
  def initialize(names, offsets, match); end
  def length; end
  def names; end
  def post_match; end
  def to_s; end
end
class ActionDispatch::Journey::Router::RoutingError < StandardError
end
module ActionDispatch::Journey::NFA
end
module ActionDispatch::Journey::NFA::Dot
  def to_dot; end
end
module ActionDispatch::Journey::GTG
end
class ActionDispatch::Journey::GTG::TransitionTable
  def []=(from, to, sym); end
  def accepting?(state); end
  def accepting_states; end
  def add_accepting(state); end
  def add_memo(idx, memo); end
  def as_json(options = nil); end
  def eclosure(t); end
  def initialize; end
  def memo(idx); end
  def memos; end
  def move(t, a); end
  def states; end
  def states_hash_for(sym); end
  def to_svg; end
  def transitions; end
  def visualizer(paths, title = nil); end
  include ActionDispatch::Journey::NFA::Dot
end
class ActionDispatch::Journey::GTG::Builder
  def ast; end
  def build_followpos; end
  def endpoints; end
  def firstpos(node); end
  def followpos(node); end
  def followpos_table; end
  def initialize(root); end
  def lastpos(node); end
  def nullable?(node); end
  def root; end
  def symbol(edge); end
  def transition_table; end
end
class ActionDispatch::Journey::GTG::MatchData
  def initialize(memos); end
  def memos; end
end
class ActionDispatch::Journey::GTG::Simulator
  def initialize(transition_table); end
  def memos(string); end
  def tt; end
end
class ActionDispatch::Journey::NFA::TransitionTable
  def []=(i, f, s); end
  def accepting; end
  def accepting=(arg0); end
  def accepting?(state); end
  def accepting_states; end
  def add_memo(idx, memo); end
  def alphabet; end
  def eclosure(t); end
  def following_states(t, a); end
  def initialize; end
  def inverted; end
  def memo(idx); end
  def memos; end
  def merge(left, right); end
  def move(t, a); end
  def states; end
  def transitions; end
  include ActionDispatch::Journey::NFA::Dot
end
class ActionDispatch::Journey::NFA::Visitor < ActionDispatch::Journey::Visitors::Visitor
  def initialize(tt); end
  def terminal(node); end
  def visit_CAT(node); end
  def visit_GROUP(node); end
  def visit_OR(node); end
end
class ActionDispatch::Journey::NFA::Builder
  def initialize(ast); end
  def transition_table; end
end
class ActionDispatch::Journey::NFA::MatchData
  def initialize(memos); end
  def memos; end
end
class ActionDispatch::Journey::NFA::Simulator
  def =~(string); end
  def initialize(transition_table); end
  def match(string); end
  def simulate(string); end
  def tt; end
end
class ActionDispatch::Routing::Endpoint
  def app; end
  def dispatcher?; end
  def engine?; end
  def matches?(req); end
  def rack_app; end
  def redirect?; end
end
class ActionDispatch::Routing::RouteSet
  def add_polymorphic_mapping(klass, options, &block); end
  def add_route(mapping, name); end
  def add_url_helper(name, options, &block); end
  def api_only?; end
  def append(&block); end
  def call(env); end
  def clear!; end
  def default_scope; end
  def default_scope=(arg0); end
  def default_url_options; end
  def default_url_options=(arg0); end
  def define_mounted_helper(name, script_namer = nil); end
  def disable_clear_and_finalize; end
  def disable_clear_and_finalize=(arg0); end
  def draw(&block); end
  def eager_load!; end
  def empty?; end
  def env_key; end
  def eval_block(block); end
  def extra_keys(options, recall = nil); end
  def finalize!; end
  def find_relative_url_root(options); end
  def find_script_name(options); end
  def formatter; end
  def formatter=(arg0); end
  def generate(route_key, options, recall = nil); end
  def generate_extras(options, recall = nil); end
  def initialize(config = nil); end
  def inspect; end
  def make_request(env); end
  def mounted_helpers; end
  def named_routes; end
  def named_routes=(arg0); end
  def optimize_routes_generation?; end
  def path_for(options, route_name = nil); end
  def polymorphic_mappings; end
  def prepend(&block); end
  def recognize_path(path, environment = nil); end
  def recognize_path_with_request(req, path, extras, raise_on_missing: nil); end
  def relative_url_root; end
  def request_class; end
  def resources_path_names; end
  def resources_path_names=(arg0); end
  def router; end
  def router=(arg0); end
  def routes; end
  def self.default_resources_path_names; end
  def self.new_with_config(config); end
  def set; end
  def set=(arg0); end
  def url_for(options, route_name = nil, url_strategy = nil); end
  def url_helpers(supports_path = nil); end
end
class ActionDispatch::Routing::RouteSet::Dispatcher < ActionDispatch::Routing::Endpoint
  def controller(req); end
  def dispatch(controller, action, req, res); end
  def dispatcher?; end
  def initialize(raise_on_name_error); end
  def serve(req); end
end
class ActionDispatch::Routing::RouteSet::StaticDispatcher < ActionDispatch::Routing::RouteSet::Dispatcher
  def controller(_); end
  def initialize(controller_class); end
end
class ActionDispatch::Routing::RouteSet::NamedRouteCollection
  def [](name); end
  def []=(name, route); end
  def add(name, route); end
  def add_url_helper(name, defaults, &block); end
  def clear!; end
  def clear; end
  def define_url_helper(mod, route, name, opts, route_key, url_strategy); end
  def each; end
  def get(name); end
  def helper_names; end
  def initialize; end
  def key?(name); end
  def length; end
  def names; end
  def path_helpers_module; end
  def route_defined?(name); end
  def routes; end
  def url_helpers_module; end
  include Enumerable
end
class ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper
  def call(t, args, inner_options); end
  def handle_positional_args(controller_options, inner_options, args, result, path_params); end
  def initialize(route, options, route_name, url_strategy); end
  def route_name; end
  def self.create(route, options, route_name, url_strategy); end
  def self.optimize_helper?(route); end
  def url_strategy; end
end
class ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper::OptimizedUrlHelper < ActionDispatch::Routing::RouteSet::NamedRouteCollection::UrlHelper
  def arg_size; end
  def call(t, args, inner_options); end
  def initialize(route, options, route_name, url_strategy); end
  def optimize_routes_generation?(t); end
  def optimized_helper(args); end
  def parameterize_args(args); end
  def raise_generation_error(args); end
end
class ActionDispatch::Routing::RouteSet::Config < Struct
  def api_only; end
  def api_only=(_); end
  def relative_url_root; end
  def relative_url_root=(_); end
  def self.[](*arg0); end
  def self.inspect; end
  def self.members; end
  def self.new(*arg0); end
end
module ActionDispatch::Routing::RouteSet::MountedHelpers
  extend ActiveSupport::Concern
  include ActionDispatch::Routing::UrlFor
end
class ActionDispatch::Routing::RouteSet::CustomUrlHelper
  def block; end
  def call(t, args, only_path = nil); end
  def defaults; end
  def eval_block(t, args, options); end
  def initialize(name, defaults, &block); end
  def merge_defaults(options); end
  def name; end
end
class ActionDispatch::Routing::RouteSet::Generator
  def controller; end
  def current_controller; end
  def different_controller?; end
  def generate; end
  def initialize(named_route, options, recall, set); end
  def named_route; end
  def named_route_exists?; end
  def normalize_controller!; end
  def normalize_controller_action_id!; end
  def normalize_options!; end
  def options; end
  def recall; end
  def segment_keys; end
  def set; end
  def use_recall_for(key); end
  def use_relative_controller!; end
end
class ActionDispatch::Request::Utils
  def perform_deep_munge; end
  def perform_deep_munge=(obj); end
  def self.check_param_encoding(params); end
  def self.each_param_value(params, &block); end
  def self.normalize_encode_params(params); end
  def self.perform_deep_munge; end
  def self.perform_deep_munge=(obj); end
end
class ActionDispatch::Request::Utils::ParamEncoder
  def self.handle_array(params); end
  def self.normalize_encode_params(params); end
end
class ActionDispatch::Request::Utils::NoNilParamEncoder < ActionDispatch::Request::Utils::ParamEncoder
  def self.handle_array(params); end
end
class ActionDispatch::ExceptionWrapper
  def application_trace; end
  def backtrace; end
  def backtrace_cleaner; end
  def clean_backtrace(*args); end
  def exception; end
  def expand_backtrace; end
  def extract_file_and_line_number(trace); end
  def file; end
  def framework_trace; end
  def full_trace; end
  def initialize(backtrace_cleaner, exception); end
  def line_number; end
  def original_exception(exception); end
  def rescue_responses; end
  def rescue_responses=(obj); end
  def rescue_template; end
  def rescue_templates; end
  def rescue_templates=(obj); end
  def self.rescue_responses; end
  def self.rescue_responses=(obj); end
  def self.rescue_templates; end
  def self.rescue_templates=(obj); end
  def self.status_code_for_exception(class_name); end
  def source_extracts; end
  def source_fragment(path, line); end
  def status_code; end
  def traces; end
end
class ActionDispatch::Callbacks
  def __callbacks; end
  def __callbacks?; end
  def _call_callbacks; end
  def _run_call_callbacks(&block); end
  def call(env); end
  def initialize(app); end
  def self.__callbacks; end
  def self.__callbacks=(val); end
  def self.__callbacks?; end
  def self._call_callbacks; end
  def self._call_callbacks=(value); end
  def self.after(*args, &block); end
  def self.before(*args, &block); end
  extend ActiveSupport::Callbacks::ClassMethods
  extend ActiveSupport::DescendantsTracker
  include ActiveSupport::Callbacks
end
class ActionDispatch::FileHandler
  def call(env); end
  def content_type(path); end
  def ext; end
  def gzip_encoding_accepted?(request); end
  def gzip_file_path(path); end
  def initialize(root, index: nil, headers: nil); end
  def match?(path); end
  def serve(request); end
end
class ActionDispatch::Static
  def call(env); end
  def initialize(app, path, index: nil, headers: nil); end
end
class ActionDispatch::Executor
  def call(env); end
  def initialize(app, executor); end
end
class ActionDispatch::RequestId
  def call(env); end
  def initialize(app); end
  def internal_request_id; end
  def make_request_id(request_id); end
end
class ActionDispatch::RemoteIp
  def call(env); end
  def check_ip; end
  def initialize(app, ip_spoofing_check = nil, custom_proxies = nil); end
  def proxies; end
end
class ActionDispatch::RemoteIp::IpSpoofAttackError < StandardError
end
class ActionDispatch::RemoteIp::GetIp
  def calculate_ip; end
  def filter_proxies(ips); end
  def initialize(req, check_ip, proxies); end
  def ips_from(header); end
  def to_s; end
end
class ActionDispatch::ShowExceptions
  def call(env); end
  def initialize(app, exceptions_app); end
  def pass_response(status); end
  def render_exception(request, exception); end
end
class ActionDispatch::PublicExceptions
  def call(env); end
  def initialize(public_path); end
  def public_path; end
  def public_path=(arg0); end
  def render(status, content_type, body); end
  def render_format(status, content_type, body); end
  def render_html(status); end
end
class ActionDispatch::Routing::RouteWrapper < SimpleDelegator
  def action; end
  def constraints; end
  def controller; end
  def endpoint; end
  def engine?; end
  def internal?; end
  def name; end
  def path; end
  def rack_app; end
  def reqs; end
end
class ActionDispatch::Routing::RoutesInspector
  def collect_engine_routes(route); end
  def collect_routes(routes); end
  def filter_routes(filter); end
  def format(formatter, filter = nil); end
  def initialize(routes); end
  def normalize_filter(filter); end
end
class ActionDispatch::Routing::ConsoleFormatter
  def draw_header(routes); end
  def draw_section(routes); end
  def header(routes); end
  def initialize; end
  def no_routes(routes); end
  def result; end
  def section(routes); end
  def section_title(title); end
  def widths(routes); end
end
class ActionDispatch::Routing::HtmlTableFormatter
  def header(routes); end
  def initialize(view); end
  def no_routes(*arg0); end
  def result; end
  def section(routes); end
  def section_title(title); end
end
class ActionDispatch::DebugExceptions
  def api_request?(content_type); end
  def call(env); end
  def create_template(request, wrapper); end
  def initialize(app, routes_app = nil, response_format = nil); end
  def log_array(logger, array); end
  def log_error(request, wrapper); end
  def logger(request); end
  def render(status, body, format); end
  def render_exception(request, exception); end
  def render_for_api_request(content_type, wrapper); end
  def render_for_browser_request(request, wrapper); end
  def routes_inspector(exception); end
  def stderr_logger; end
end
class ActionDispatch::DebugExceptions::DebugView < ActionView::Base
  def debug_hash(object); end
  def debug_headers(headers); end
  def debug_params(params); end
  def render(*arg0); end
end
class ActionDispatch::Reloader < ActionDispatch::Executor
end
class ActionDispatch::Routing::Redirect < ActionDispatch::Routing::Endpoint
  def block; end
  def call(env); end
  def escape(params); end
  def escape_fragment(params); end
  def escape_path(params); end
  def initialize(status, block); end
  def inspect; end
  def path(params, request); end
  def redirect?; end
  def relative_path?(path); end
  def serve(req); end
  def status; end
end
class ActionDispatch::Routing::PathRedirect < ActionDispatch::Routing::Redirect
  def inspect; end
  def interpolation_required?(string, params); end
  def path(params, request); end
end
class ActionDispatch::Routing::OptionRedirect < ActionDispatch::Routing::Redirect
  def inspect; end
  def options; end
  def path(params, request); end
end
module ActionDispatch::Routing::Redirection
  def redirect(*args, &block); end
end
class ActionDispatch::Routing::Mapper
  def initialize(set); end
  def self.normalize_name(name); end
  def self.normalize_path(path); end
  include ActionDispatch::Routing::Mapper::Base
  include ActionDispatch::Routing::Mapper::Concerns
  include ActionDispatch::Routing::Mapper::CustomUrls
  include ActionDispatch::Routing::Mapper::HttpHelpers
  include ActionDispatch::Routing::Mapper::Resources
  include ActionDispatch::Routing::Mapper::Scoping
  include ActionDispatch::Routing::Redirection
end
class ActionDispatch::Routing::Mapper::Constraints < ActionDispatch::Routing::Endpoint
  def app; end
  def constraint_args(constraint, request); end
  def constraints; end
  def dispatcher?; end
  def initialize(app, constraints, strategy); end
  def matches?(req); end
  def serve(req); end
end
class ActionDispatch::Routing::Mapper::Mapping
  def add_controller_module(controller, modyoule); end
  def add_wildcard_options(options, formatted, path_ast); end
  def app(blocks); end
  def application; end
  def ast; end
  def blocks(callable_constraint); end
  def build_conditions(current_conditions, request_class); end
  def build_path(ast, requirements, anchor); end
  def check_controller_and_action(path_params, controller, action); end
  def check_part(name, part, path_params, hash); end
  def conditions; end
  def constraints(options, path_params); end
  def default_action; end
  def default_controller; end
  def defaults; end
  def dispatcher(raise_on_name_error); end
  def initialize(set, ast, defaults, controller, default_action, modyoule, to, formatted, scope_constraints, blocks, via, options_constraints, anchor, options); end
  def make_route(name, precedence); end
  def normalize_defaults(options); end
  def normalize_format(formatted); end
  def normalize_options!(options, path_params, modyoule); end
  def path; end
  def request_method; end
  def required_defaults; end
  def requirements; end
  def self.build(scope, set, ast, controller, default_action, to, via, formatted, options_constraints, anchor, options); end
  def self.check_via(via); end
  def self.normalize_path(path, format); end
  def self.optional_format?(path, format); end
  def split_constraints(path_params, constraints); end
  def split_to(to); end
  def to; end
  def translate_controller(controller); end
  def verify_regexp_requirements(requirements); end
end
module ActionDispatch::Routing::Mapper::Base
  def app_name(app, rails_app); end
  def default_url_options(options); end
  def default_url_options=(options); end
  def define_generate_prefix(app, name); end
  def has_named_route?(name); end
  def match(path, options = nil); end
  def mount(app, options = nil); end
  def rails_app?(app); end
  def with_default_scope(scope, &block); end
end
module ActionDispatch::Routing::Mapper::HttpHelpers
  def delete(*args, &block); end
  def get(*args, &block); end
  def map_method(method, args, &block); end
  def patch(*args, &block); end
  def post(*args, &block); end
  def put(*args, &block); end
end
module ActionDispatch::Routing::Mapper::Scoping
  def constraints(constraints = nil); end
  def controller(controller); end
  def defaults(defaults = nil); end
  def merge_action_scope(parent, child); end
  def merge_as_scope(parent, child); end
  def merge_blocks_scope(parent, child); end
  def merge_constraints_scope(parent, child); end
  def merge_controller_scope(parent, child); end
  def merge_defaults_scope(parent, child); end
  def merge_format_scope(parent, child); end
  def merge_module_scope(parent, child); end
  def merge_options_scope(parent, child); end
  def merge_path_names_scope(parent, child); end
  def merge_path_scope(parent, child); end
  def merge_shallow_path_scope(parent, child); end
  def merge_shallow_prefix_scope(parent, child); end
  def merge_shallow_scope(parent, child); end
  def merge_to_scope(parent, child); end
  def merge_via_scope(parent, child); end
  def namespace(path, options = nil); end
  def scope(*args); end
end
module ActionDispatch::Routing::Mapper::Resources
  def action_options?(options); end
  def action_path(name); end
  def add_route(action, controller, options, _path, to, via, formatted, anchor, options_constraints); end
  def api_only?; end
  def apply_action_options(options); end
  def apply_common_behavior_for(method, resources, options, &block); end
  def canonical_action?(action); end
  def collection; end
  def decomposed_match(path, controller, options, _path, to, via, formatted, anchor, options_constraints); end
  def get_to_from_path(path, to, action); end
  def map_match(paths, options); end
  def match(path, *rest, &block); end
  def match_root_route(options); end
  def member; end
  def name_for_action(as, action); end
  def namespace(path, options = nil); end
  def nested; end
  def nested_options; end
  def nested_scope?; end
  def new; end
  def param_constraint; end
  def param_constraint?; end
  def parent_resource; end
  def path_for_action(action, path); end
  def path_scope(path); end
  def prefix_name_for_action(as, action); end
  def resource(*resources, &block); end
  def resource_method_scope?; end
  def resource_scope(resource); end
  def resource_scope?; end
  def resources(*resources, &block); end
  def resources_path_names(options); end
  def root(path, options = nil); end
  def scope_action_options; end
  def set_member_mappings_for_resource; end
  def shallow; end
  def shallow?; end
  def shallow_nesting_depth; end
  def shallow_scope; end
  def using_match_shorthand?(path); end
  def with_scope_level(kind); end
end
class ActionDispatch::Routing::Mapper::Resources::Resource
  def actions; end
  def collection_name; end
  def collection_scope; end
  def controller; end
  def default_actions; end
  def initialize(entities, api_only, shallow, options = nil); end
  def member_name; end
  def member_scope; end
  def name; end
  def nested_param; end
  def nested_scope; end
  def new_scope(new_path); end
  def param; end
  def path; end
  def plural; end
  def resource_scope; end
  def shallow?; end
  def shallow_scope; end
  def singleton?; end
  def singular; end
end
class ActionDispatch::Routing::Mapper::Resources::SingletonResource < ActionDispatch::Routing::Mapper::Resources::Resource
  def collection_name; end
  def default_actions; end
  def initialize(entities, api_only, shallow, options); end
  def member_name; end
  def member_scope; end
  def nested_scope; end
  def plural; end
  def singleton?; end
  def singular; end
end
module ActionDispatch::Routing::Mapper::Concerns
  def concern(name, callable = nil, &block); end
  def concerns(*args); end
end
module ActionDispatch::Routing::Mapper::CustomUrls
  def direct(name, options = nil, &block); end
  def resolve(*args, &block); end
end
class ActionDispatch::Routing::Mapper::Scope
  def [](key); end
  def action_name(name_prefix, prefix, collection_name, member_name); end
  def each; end
  def frame; end
  def initialize(hash, parent = nil, scope_level = nil); end
  def nested?; end
  def new(hash); end
  def new_level(level); end
  def null?; end
  def options; end
  def parent; end
  def resource_method_scope?; end
  def resource_scope?; end
  def resources?; end
  def root?; end
  def scope_level; end
  include Enumerable
end
module ActionController::TemplateAssertions
  def assert_template(options = nil, message = nil); end
end
module ActionController::Testing
  extend ActiveSupport::Concern
end
module ActionController::Testing::Functional
  def recycle!; end
end
class ActionDispatch::TestRequest < ActionDispatch::Request
  def accept=(mime_types); end
  def action=(action_name); end
  def host=(host); end
  def if_modified_since=(last_modified); end
  def if_none_match=(etag); end
  def path=(path); end
  def port=(number); end
  def remote_addr=(addr); end
  def request_method=(method); end
  def request_uri=(uri); end
  def self.create(env = nil); end
  def self.default_env; end
  def user_agent=(user_agent); end
end
class ActionDispatch::Flash
  def self.new(app); end
end
module ActionDispatch::Flash::RequestMethods
  def commit_flash; end
  def flash; end
  def flash=(flash); end
  def flash_hash; end
  def reset_session; end
end
class ActionDispatch::Flash::FlashNow
  def [](k); end
  def []=(k, v); end
  def alert=(message); end
  def flash; end
  def flash=(arg0); end
  def initialize(flash); end
  def notice=(message); end
end
class ActionDispatch::Flash::FlashHash
  def [](k); end
  def []=(k, v); end
  def alert; end
  def alert=(message); end
  def clear; end
  def delete(key); end
  def discard(k = nil); end
  def each(&block); end
  def empty?; end
  def initialize(flashes = nil, discard = nil); end
  def initialize_copy(other); end
  def keep(k = nil); end
  def key?(name); end
  def keys; end
  def merge!(h); end
  def notice; end
  def notice=(message); end
  def now; end
  def now_is_loaded?; end
  def replace(h); end
  def self.from_session_value(value); end
  def stringify_array(array); end
  def sweep; end
  def to_hash; end
  def to_session_value; end
  def update(h); end
  include Enumerable
end
module ActionDispatch::TestProcess
  def assigns(key = nil); end
  def cookies; end
  def flash; end
  def redirect_to_url; end
  def session; end
  include ActionDispatch::TestProcess::FixtureFile
end
module ActionDispatch::TestProcess::FixtureFile
  def fixture_file_upload(path, mime_type = nil, binary = nil); end
end
module ActionDispatch::Assertions
  def html_document; end
  extend ActiveSupport::Concern
  include ActionDispatch::Assertions::ResponseAssertions
  include ActionDispatch::Assertions::RoutingAssertions
  include Rails::Dom::Testing::Assertions
end
module ActionDispatch::Assertions::ResponseAssertions
  def assert_redirected_to(options = nil, message = nil); end
  def assert_response(type, message = nil); end
  def code_with_name(code_or_name); end
  def generate_response_message(expected, actual = nil); end
  def location_if_redirected; end
  def normalize_argument_to_redirection(fragment); end
  def parameterize(value); end
  def response_body_if_short; end
end
module ActionDispatch::Assertions::RoutingAssertions
  def assert_generates(expected_path, options, defaults = nil, extras = nil, message = nil); end
  def assert_recognizes(expected_options, path, extras = nil, msg = nil); end
  def assert_routing(path, options, defaults = nil, extras = nil, message = nil); end
  def fail_on(exception_class, message); end
  def method_missing(selector, *args, &block); end
  def recognized_request_for(path, extras = nil, msg); end
  def with_routing; end
end
class ActionController::TestRequest < ActionDispatch::TestRequest
  def assign_parameters(routes, controller_path, action, parameters, generated_path, query_string_keys); end
  def content_type=(type); end
  def controller_class; end
  def initialize(env, session, controller_class); end
  def params_parsers; end
  def query_string=(string); end
  def self.create(controller_class); end
  def self.default_env; end
  def self.new_session; end
end
class ActionController::LiveTestResponse < ActionController::Live::Response
  def error?; end
  def missing?; end
  def success?; end
end
class ActionController::TestSession < Rack::Session::Abstract::SessionHash
  def destroy; end
  def exists?; end
  def fetch(key, *args, &block); end
  def initialize(session = nil); end
  def keys; end
  def load!; end
  def values; end
end
class ActionController::TestCase < ActiveSupport::TestCase
  def _controller_class; end
  def _controller_class=(val); end
  def _controller_class?; end
  def self.__callbacks; end
  def self._controller_class; end
  def self._controller_class=(val); end
  def self._controller_class?; end
  extend ActionController::TestCase::Behavior::ClassMethods
  extend ActiveSupport::Testing::ConstantLookup::ClassMethods
  include ActionController::TemplateAssertions
  include ActionController::TestCase::Behavior
  include ActionDispatch::Assertions
  include ActiveSupport::Testing::ConstantLookup
  include Rails::Dom::Testing::Assertions
  include Rails::Dom::Testing::Assertions
end
module ActionController::TestCase::Behavior
  def build_response(klass); end
  def check_required_ivars; end
  def controller_class_name; end
  def delete(action, **args); end
  def document_root_element; end
  def generated_path(generated_extras); end
  def get(action, **args); end
  def head(action, **args); end
  def patch(action, **args); end
  def post(action, **args); end
  def process(action, method: nil, params: nil, session: nil, body: nil, flash: nil, format: nil, xhr: nil, as: nil); end
  def put(action, **args); end
  def query_parameter_names(generated_extras); end
  def request; end
  def response; end
  def scrub_env!(env); end
  def setup_controller_request_and_response; end
  extend ActiveSupport::Concern
  include ActionDispatch::TestProcess
  include ActiveSupport::Testing::ConstantLookup
  include Rails::Dom::Testing::Assertions
end
module ActionController::TestCase::Behavior::ClassMethods
  def controller_class; end
  def controller_class=(new_class); end
  def determine_default_controller_class(name); end
  def tests(controller_class); end
end
class ActionDispatch::RequestEncoder
  def accept_header; end
  def content_type; end
  def encode_params(params); end
  def initialize(mime_name, param_encoder, response_parser); end
  def response_parser; end
  def self.encoder(name); end
  def self.parser(content_type); end
  def self.register_encoder(mime_name, param_encoder: nil, response_parser: nil); end
end
class ActionDispatch::RequestEncoder::IdentityEncoder
  def accept_header; end
  def content_type; end
  def encode_params(params); end
  def response_parser; end
end
module ActionDispatch::Integration
end
module ActionDispatch::Integration::RequestHelpers
  def delete(path, **args); end
  def follow_redirect!; end
  def get(path, **args); end
  def head(path, *args); end
  def patch(path, **args); end
  def post(path, **args); end
  def put(path, **args); end
end
class ActionDispatch::Integration::Session
  def _mock_session; end
  def accept; end
  def accept=(arg0); end
  def body(*args, &block); end
  def build_expanded_path(path); end
  def build_full_uri(path, env); end
  def controller; end
  def cookies; end
  def default_url_options; end
  def default_url_options=(val); end
  def default_url_options?; end
  def headers(*args, &block); end
  def host!(arg0); end
  def host; end
  def host=(arg0); end
  def https!(flag = nil); end
  def https?; end
  def initialize(app); end
  def path(*args, &block); end
  def process(method, path, params: nil, headers: nil, env: nil, xhr: nil, as: nil); end
  def redirect?(*args, &block); end
  def remote_addr; end
  def remote_addr=(arg0); end
  def request; end
  def request_count; end
  def request_count=(arg0); end
  def reset!; end
  def response; end
  def self.default_url_options; end
  def self.default_url_options=(val); end
  def self.default_url_options?; end
  def status(*args, &block); end
  def status_message(*args, &block); end
  def url_options; end
  include ActionDispatch::Routing::UrlFor
  include ActionDispatch::TestProcess
  include Minitest::Assertions
  include Rails::Dom::Testing::Assertions
end
module ActionDispatch::Integration::Runner
  def app; end
  def assigns(*args); end
  def before_setup; end
  def cookies(*args); end
  def copy_session_variables!; end
  def create_session(app); end
  def default_url_options; end
  def default_url_options=(options); end
  def delete(*args); end
  def follow_redirect!(*args); end
  def get(*args); end
  def head(*args); end
  def initialize(*args, &blk); end
  def integration_session; end
  def method_missing(method, *args, &block); end
  def open_session; end
  def patch(*args); end
  def post(*args); end
  def put(*args); end
  def remove!; end
  def reset!; end
  def respond_to_missing?(method, _); end
  include ActionDispatch::Assertions
  include Rails::Dom::Testing::Assertions
end
class ActionDispatch::IntegrationTest < ActiveSupport::TestCase
  def self.__callbacks; end
  extend ActionDispatch::IntegrationTest::Behavior::ClassMethods
  include ActionDispatch::IntegrationTest::Behavior
  include ActionDispatch::IntegrationTest::UrlOptions
  include ActionDispatch::Routing::UrlFor
  include ActionDispatch::TestProcess::FixtureFile
  include ActionMailer::TestCase::ClearTestDeliveries
end
module ActionDispatch::IntegrationTest::UrlOptions
  def url_options; end
  extend ActiveSupport::Concern
end
module ActionDispatch::IntegrationTest::Behavior
  def app; end
  def document_root_element; end
  extend ActiveSupport::Concern
  include ActionController::TemplateAssertions
  include ActionDispatch::Integration::Runner
end
module ActionDispatch::IntegrationTest::Behavior::ClassMethods
  def app; end
  def app=(app); end
  def register_encoder(*args); end
end