decentworks-date-support 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e9dfe6b36ab7e84d333bb4562533c8552fac643b805ad2839948d93bc001740
+  data.tar.gz: 3ef12c40ef40af471f5ef8bf8ef5a3b73ab44e372c091c41b41674bc0894d978
+SHA512:
+  metadata.gz: c85f09c4a5579df1c9108f49a2950cea6a7b29ad91f05a38a5963a23e0351b0227fa7c799d44a89ec0300ba73a4ac5ef0279deeab1baab3c69ff64be68b475d7
+  data.tar.gz: 883158b0abd8e2c1e7e4184a82d4545795f1a91b5660eddbfaa79c72ea50bcb9ed1cd750cc2bf6c36389246156a6266bd566e2a7842e3d871832800982bba128

data/.gem_rbs_collection/actionpack/7.2/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: actionpack
+version: '7.2'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

data/.gem_rbs_collection/actionpack/7.2/actioncontroller-7.2.rbs

@@ -0,0 +1,14 @@
+module ActionController
+  module AllowBrowser
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def allow_browser: (versions: :modern | Hash[untyped, false | _ToS], ?block: ^() [self: Base] -> void, **untyped options) -> void
+    end
+  end
+
+  class Base < Metal
+    extend AllowBrowser::ClassMethods
+  end
+end
+

data/.gem_rbs_collection/actionpack/7.2/actioncontroller.rbs

@@ -0,0 +1,290 @@
+module ActionController
+  interface _API_and_Base
+    def flash: () -> untyped
+  end
+
+  class Base < Metal
+    include _API_and_Base
+
+    # https://github.com/rails/rails/blob/v6.0.3.2/actionpack/lib/action_controller/base.rb#L205-L255
+    include AbstractController::Rendering
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+    include Helpers
+    extend Helpers::ClassMethods
+    extend AbstractController::Helpers::ClassMethods
+    include UrlFor
+    include Redirecting
+    include ActionView::Layouts
+    extend ::ActionView::Layouts::ClassMethods
+    include Rendering
+    extend Rendering::ClassMethods
+    include Renderers::All
+    include ConditionalGet
+    extend ConditionalGet::ClassMethods
+    include EtagWithTemplateDigest
+    include EtagWithFlash
+    include Caching
+    include AbstractController::Caching
+    extend AbstractController::Caching::ClassMethods
+    extend AbstractController::Caching::Fragments::ClassMethods
+    include MimeResponds
+    include ImplicitRender
+    include StrongParameters
+    include ParameterEncoding
+    extend ParameterEncoding::ClassMethods
+    include Cookies
+    include Flash
+    extend Flash::ClassMethods
+    include FormBuilder
+    extend FormBuilder::ClassMethods
+    include RequestForgeryProtection
+    extend RequestForgeryProtection::ClassMethods
+    include ContentSecurityPolicy
+    extend ContentSecurityPolicy::ClassMethods
+    include ForceSSL
+    extend ForceSSL::ClassMethods
+    include Streaming
+    include DataStreaming
+    include HttpAuthentication::Basic::ControllerMethods
+    extend HttpAuthentication::Basic::ControllerMethods::ClassMethods
+    include HttpAuthentication::Digest::ControllerMethods
+    include HttpAuthentication::Token::ControllerMethods
+    include DefaultHeaders
+    extend DefaultHeaders::ClassMethods
+    include AbstractController::Callbacks
+    extend AbstractController::Callbacks::ClassMethods
+    include Rescue
+    include ActiveSupport::Rescuable
+    extend ActiveSupport::Rescuable::ClassMethods
+    include Instrumentation
+    extend Instrumentation::ClassMethods
+    include ParamsWrapper
+    extend ParamsWrapper::ClassMethods
+  end
+
+  class API < Metal
+    include _API_and_Base
+
+    # https://github.com/rails/rails/blob/v6.0.3.2/actionpack/lib/action_controller/api.rb#L112-L145
+    include AbstractController::Rendering
+    include UrlFor
+    include Redirecting
+    include ApiRendering
+    include Renderers::All
+    include ConditionalGet
+    extend ConditionalGet::ClassMethods
+    include BasicImplicitRender
+    include StrongParameters
+    include ForceSSL
+    extend ForceSSL::ClassMethods
+    include DataStreaming
+    include DefaultHeaders
+    extend DefaultHeaders::ClassMethods
+    include AbstractController::Callbacks
+    extend AbstractController::Callbacks::ClassMethods
+    include Rescue
+    include ActiveSupport::Rescuable
+    extend ActiveSupport::Rescuable::ClassMethods
+    include Instrumentation
+    extend Instrumentation::ClassMethods
+    include ParamsWrapper
+    extend ParamsWrapper::ClassMethods
+  end
+
+  module HttpAuthentication
+    module Token
+      TOKEN_KEY: ::String
+      TOKEN_REGEX: ::Regexp
+      AUTHN_PAIR_DELIMITERS: ::Regexp
+
+      extend ::ActionController::HttpAuthentication::Token
+
+      module ControllerMethods
+        def authenticate_or_request_with_http_token: (?String realm, ?String? message) { (String token, ActiveSupport::HashWithIndifferentAccess[untyped, untyped] options) -> boolish } -> untyped
+
+        def authenticate_with_http_token: () { (String token, ActiveSupport::HashWithIndifferentAccess[untyped, untyped] options) -> boolish } -> boolish
+
+        def request_http_token_authentication: (?String realm, ?String? message) -> void
+      end
+
+      def authenticate: (instance controller) { (String token, ActiveSupport::HashWithIndifferentAccess[untyped, untyped] options) -> boolish } -> boolish
+
+      def token_and_options: (ActionDispatch::Request request) -> [String, ActiveSupport::HashWithIndifferentAccess[untyped, untyped]]?
+
+      def token_params_from: (String auth) -> Array[String]
+
+      def raw_params: (String auth) -> Array[String]
+
+      def params_array_from: (Array[String] raw_params) -> Array[String]
+
+      def rewrite_param_values: (Array[String] array_params) -> Array[String]
+
+      def encode_credentials: (String token, ?::Hash[untyped, untyped] options) -> ::String
+
+      def authentication_request: (instance controller, String realm, ?String? message) -> void
+    end
+  end
+end
+
+module AbstractController::Callbacks::ClassMethods
+  interface _BeforeActionCallback
+    def before: (ActionController::Base controller) -> void
+  end
+
+  interface _AroundActionCallback
+    def around: (ActionController::Base controller) { () -> void } -> void
+  end
+
+  interface _AfterActionCallback
+    def after: (ActionController::Base controller) -> void
+  end
+
+  type before_action_callback[T] = Symbol | ^(T controller) [self: T] -> void | _BeforeActionCallback
+  type around_action_callback[T] = Symbol | ^(T controller, ^() -> void) [self: T] -> void | _AroundActionCallback
+  type after_action_callback[T] = Symbol | ^(T controller) [self: T] -> void | _AfterActionCallback
+
+  def before_action: (*before_action_callback[instance], ?if: before_action_callback[instance], ?unless: before_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+  def around_action: (*around_action_callback[instance], ?if: around_action_callback[instance], ?unless: around_action_callback[instance], **untyped) ?{ (instance controller, ^() -> void) [self: instance] -> void } -> void
+  def after_action: (*after_action_callback[instance], ?if: after_action_callback[instance], ?unless: after_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+  def skip_before_action: (*before_action_callback[instance], ?if: before_action_callback[instance], ?unless: before_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+  def skip_around_action: (*around_action_callback[instance], ?if: around_action_callback[instance], ?unless: around_action_callback[instance], **untyped) ?{ (instance controller, ^() -> void) [self: instance] -> void } -> void
+  def skip_after_action: (*after_action_callback[instance], ?if: after_action_callback[instance], ?unless: after_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+  def prepend_before_action: (*before_action_callback[instance], ?if: before_action_callback[instance], ?unless: before_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+  def prepend_around_action: (*around_action_callback[instance], ?if: around_action_callback[instance], ?unless: around_action_callback[instance], **untyped) ?{ (instance controller, ^() -> void) [self: instance] -> void } -> void
+  def prepend_after_action: (*after_action_callback[instance], ?if: after_action_callback[instance], ?unless: after_action_callback[instance], **untyped) ?{ (instance controller) [self: instance] -> void } -> void
+
+  alias append_before_action before_action
+  alias append_around_action around_action
+  alias append_after_action after_action
+end
+
+module ActionController
+  class Parameters
+    # Deletes a key-value pair from +Parameters+ and returns the value. If
+    # +key+ is not found, returns +nil+ (or, with optional code block, yields
+    # +key+ and returns the result). Cf. +#extract!+, which returns the
+    # corresponding +ActionController::Parameters+ object.
+    def delete: (untyped key) ?{ (untyped key) -> untyped } -> untyped
+
+    def keys: () -> Array[untyped]
+    def key?: (untyped key) -> bool
+    def has_key?: (untyped key) -> bool
+    def values: () -> Array[untyped]
+    def has_value?: (untyped value) -> bool
+    def empty?: () -> bool
+    def include?: (untyped key) -> bool
+    def as_json: () -> String
+    def to_s: () -> String
+    def each_key: () { (untyped) -> untyped } -> Hash[untyped, untyped]
+                | () -> Enumerator[untyped, self]
+    def fetch: (untyped key, *untyped args) ?{ () -> untyped } -> untyped
+  end
+end
+
+module AbstractController
+  module Helpers
+    module ClassMethods
+      # The +helper+ class method can take a series of helper module names, a block, or both.
+      #
+      # ==== Options
+      # * <tt>*args</tt> - Module, Symbol, String
+      # * <tt>block</tt> - A block defining helper methods
+      #
+      # When the argument is a module it will be included directly in the template class.
+      #   helper FooHelper # => includes FooHelper
+      #
+      # When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
+      # and include the module in the template class. The second form illustrates how to include custom helpers
+      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
+      # in one of Rails' standard load paths:
+      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
+      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
+      #
+      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
+      # to the template.
+      #
+      #   # One line
+      #   helper { def hello() "Hello, world!" end }
+      #
+      #   # Multi-line
+      #   helper do
+      #     def foo(bar)
+      #       "#{bar} is the very best"
+      #     end
+      #   end
+      #
+      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
+      # +symbols+, +strings+, +modules+ and blocks.
+      #
+      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      #
+      def helper: (*untyped args) ?{ () -> untyped } -> untyped
+    end
+  end
+end
+
+module AbstractController
+  module Caching
+    module Fragments
+      module ClassMethods
+        # Allows you to specify controller-wide key prefixes for
+        # cache fragments. Pass either a constant +value+, or a block
+        # which computes a value each time a cache key is generated.
+        #
+        # For example, you may want to prefix all fragment cache keys
+        # with a global version identifier, so you can easily
+        # invalidate all caches.
+        #
+        #   class ApplicationController
+        #     fragment_cache_key "v1"
+        #   end
+        #
+        # When it's time to invalidate all fragments, simply change
+        # the string constant. Or, progressively roll out the cache
+        # invalidation using a computed value:
+        #
+        #   class ApplicationController
+        #     fragment_cache_key do
+        #       @account.id.odd? ? "v1" : "v2"
+        #     end
+        #   end
+        def fragment_cache_key: (?untyped? value) ?{ () -> untyped } -> untyped
+      end
+    end
+  end
+end
+
+module AbstractController
+  module Rendering
+    def render_to_string: (*untyped args) ?{ () -> untyped } -> ::String
+  end
+end
+
+module ActionController
+  module Caching
+    extend AbstractController::Caching::ClassMethods
+    extend AbstractController::Caching::Fragments::ClassMethods
+  end
+end
+
+module ActionController
+  module ContentSecurityPolicy
+    module ClassMethods
+      def content_security_policy: (?bool enabled, **untyped options) ?{ (untyped) -> untyped } -> untyped
+    end
+  end
+end
+
+module ActionController
+  class TestSession < Rack::Session::Abstract::PersistedSecure::SecureSessionHash
+    def fetch: (untyped key) ?{ () -> untyped } -> untyped
+             | (untyped key, untyped args) -> untyped
+  end
+end
+
+module ActionController
+  module Rendering
+    def render_to_string: (*untyped args) ?{ () -> untyped } -> ::String
+  end
+end

data/.gem_rbs_collection/actionpack/7.2/actiondispatch.rbs

@@ -0,0 +1,349 @@
+module ActionDispatch
+  class Cookies
+    class CookieJar
+      def fetch: (untyped name, *untyped args) ?{ () -> untyped } -> untyped
+    end
+  end
+end
+
+module ActionDispatch
+  module Http
+    class Headers
+      # Returns the value for the given key mapped to @env.
+      #
+      # If the key is not found and an optional code block is not provided,
+      # raises a <tt>KeyError</tt> exception.
+      #
+      # If the code block is provided, then it will be run and
+      # its result returned.
+      def fetch: (untyped key) ?{ () -> untyped } -> untyped
+               | (untyped key, untyped default) -> untyped
+    end
+  end
+end
+
+module ActionDispatch
+  class Request
+    class Session
+      # Returns value of the given key from the session, or raises +KeyError+
+      # if can't find the given key and no default value is set.
+      # Returns default value if specified.
+      #
+      #   session.fetch(:foo)
+      #   # => KeyError: key not found: "foo"
+      #
+      #   session.fetch(:foo, :bar)
+      #   # => :bar
+      #
+      #   session.fetch(:foo) do
+      #     :bar
+      #   end
+      #   # => :bar
+      def fetch: (untyped key) ?{ () -> untyped } -> untyped
+               | (untyped key, untyped default) -> untyped
+    end
+  end
+end
+
+module ActionDispatch
+  class RequestId
+    X_REQUEST_ID: ::String
+
+    def initialize: (Rack::_Application app) -> void
+
+    def call: (Rack::env env) -> Rack::response
+
+    private
+
+    def make_request_id: (String? request_id) -> String
+
+    def internal_request_id: () -> String
+  end
+end
+
+module ActionDispatch
+  module Routing
+    module PolymorphicRoutes
+      def polymorphic_url: (untyped record_or_hash_or_array, ?::Hash[untyped, untyped] options) -> String
+      def polymorphic_path: (untyped record_or_hash_or_array, ?::Hash[untyped, untyped] options) -> String
+    end
+
+    class RouteSet
+      def draw: () { () [self: Mapper] -> untyped } -> nil
+
+      def url_helpers: (?bool supports_path) -> singleton(RouteSet_AnonymousModule)
+
+      module RouteSet_AnonymousModule
+        include ActiveSupport::Concern
+        include UrlFor
+        # https://github.com/rails/rails/blob/v7.2.2.2/actionpack/lib/action_dispatch/routing/route_set.rb#L518
+      end
+    end
+
+    class Mapper
+      module HttpHelpers
+        # Define a route that only recognizes HTTP GET.
+        # For supported arguments, see match[rdoc-ref:Base#match]
+        #
+        #   get 'bacon', to: 'food#bacon'
+        def get: (*untyped args) ?{ () -> untyped } -> untyped
+
+        # Define a route that only recognizes HTTP POST.
+        # For supported arguments, see match[rdoc-ref:Base#match]
+        #
+        #   post 'bacon', to: 'food#bacon'
+        def post: (*untyped args) ?{ () -> untyped } -> untyped
+
+        # Define a route that only recognizes HTTP PATCH.
+        # For supported arguments, see match[rdoc-ref:Base#match]
+        #
+        #   patch 'bacon', to: 'food#bacon'
+        def patch: (*untyped args) ?{ () -> untyped } -> untyped
+
+        # Define a route that only recognizes HTTP PUT.
+        # For supported arguments, see match[rdoc-ref:Base#match]
+        #
+        #   put 'bacon', to: 'food#bacon'
+        def put: (*untyped args) ?{ () -> untyped } -> untyped
+
+        # Define a route that only recognizes HTTP DELETE.
+        # For supported arguments, see match[rdoc-ref:Base#match]
+        #
+        #   delete 'broccoli', to: 'food#broccoli'
+        def delete: (*untyped args) ?{ () -> untyped } -> untyped
+
+        private
+
+        def map_method: (untyped method, untyped args) ?{ () -> untyped } -> untyped
+      end
+
+      module Resources
+        # Sometimes, you have a resource that clients always look up without
+        # referencing an ID. A common example, /profile always shows the
+        # profile of the currently logged in user. In this case, you can use
+        # a singular resource to map /profile (rather than /profile/:id) to
+        # the show action:
+        #
+        #   resource :profile
+        #
+        # This creates six different routes in your application, all mapping to
+        # the +Profiles+ controller (note that the controller is named after
+        # the plural):
+        #
+        #   GET       /profile/new
+        #   GET       /profile
+        #   GET       /profile/edit
+        #   PATCH/PUT /profile
+        #   DELETE    /profile
+        #   POST      /profile
+        #
+        # === Options
+        # Takes same options as resources[rdoc-ref:#resources]
+        def resource: (*untyped resources) ?{ () -> untyped } -> untyped
+
+        # In Rails, a resourceful route provides a mapping between HTTP verbs
+        # and URLs and controller actions. By convention, each action also maps
+        # to particular CRUD operations in a database. A single entry in the
+        # routing file, such as
+        #
+        #   resources :photos
+        #
+        # creates seven different routes in your application, all mapping to
+        # the +Photos+ controller:
+        #
+        #   GET       /photos
+        #   GET       /photos/new
+        #   POST      /photos
+        #   GET       /photos/:id
+        #   GET       /photos/:id/edit
+        #   PATCH/PUT /photos/:id
+        #   DELETE    /photos/:id
+        #
+        # Resources can also be nested infinitely by using this block syntax:
+        #
+        #   resources :photos do
+        #     resources :comments
+        #   end
+        #
+        # This generates the following comments routes:
+        #
+        #   GET       /photos/:photo_id/comments
+        #   GET       /photos/:photo_id/comments/new
+        #   POST      /photos/:photo_id/comments
+        #   GET       /photos/:photo_id/comments/:id
+        #   GET       /photos/:photo_id/comments/:id/edit
+        #   PATCH/PUT /photos/:photo_id/comments/:id
+        #   DELETE    /photos/:photo_id/comments/:id
+        #
+        # === Options
+        # Takes same options as match[rdoc-ref:Base#match] as well as:
+        #
+        # [:path_names]
+        #   Allows you to change the segment component of the +edit+ and +new+ actions.
+        #   Actions not specified are not changed.
+        #
+        #     resources :posts, path_names: { new: "brand_new" }
+        #
+        #   The above example will now change /posts/new to /posts/brand_new.
+        #
+        # [:path]
+        #   Allows you to change the path prefix for the resource.
+        #
+        #     resources :posts, path: 'postings'
+        #
+        #   The resource and all segments will now route to /postings instead of /posts.
+        #
+        # [:only]
+        #   Only generate routes for the given actions.
+        #
+        #     resources :cows, only: :show
+        #     resources :cows, only: [:show, :index]
+        #
+        # [:except]
+        #   Generate all routes except for the given actions.
+        #
+        #     resources :cows, except: :show
+        #     resources :cows, except: [:show, :index]
+        #
+        # [:shallow]
+        #   Generates shallow routes for nested resource(s). When placed on a parent resource,
+        #   generates shallow routes for all nested resources.
+        #
+        #     resources :posts, shallow: true do
+        #       resources :comments
+        #     end
+        #
+        #   Is the same as:
+        #
+        #     resources :posts do
+        #       resources :comments, except: [:show, :edit, :update, :destroy]
+        #     end
+        #     resources :comments, only: [:show, :edit, :update, :destroy]
+        #
+        #   This allows URLs for resources that otherwise would be deeply nested such
+        #   as a comment on a blog post like <tt>/posts/a-long-permalink/comments/1234</tt>
+        #   to be shortened to just <tt>/comments/1234</tt>.
+        #
+        #   Set <tt>shallow: false</tt> on a child resource to ignore a parent's shallow parameter.
+        #
+        # [:shallow_path]
+        #   Prefixes nested shallow routes with the specified path.
+        #
+        #     scope shallow_path: "sekret" do
+        #       resources :posts do
+        #         resources :comments, shallow: true
+        #       end
+        #     end
+        #
+        #   The +comments+ resource here will have the following routes generated for it:
+        #
+        #     post_comments    GET       /posts/:post_id/comments(.:format)
+        #     post_comments    POST      /posts/:post_id/comments(.:format)
+        #     new_post_comment GET       /posts/:post_id/comments/new(.:format)
+        #     edit_comment     GET       /sekret/comments/:id/edit(.:format)
+        #     comment          GET       /sekret/comments/:id(.:format)
+        #     comment          PATCH/PUT /sekret/comments/:id(.:format)
+        #     comment          DELETE    /sekret/comments/:id(.:format)
+        #
+        # [:shallow_prefix]
+        #   Prefixes nested shallow route names with specified prefix.
+        #
+        #     scope shallow_prefix: "sekret" do
+        #       resources :posts do
+        #         resources :comments, shallow: true
+        #       end
+        #     end
+        #
+        #   The +comments+ resource here will have the following routes generated for it:
+        #
+        #     post_comments           GET       /posts/:post_id/comments(.:format)
+        #     post_comments           POST      /posts/:post_id/comments(.:format)
+        #     new_post_comment        GET       /posts/:post_id/comments/new(.:format)
+        #     edit_sekret_comment     GET       /comments/:id/edit(.:format)
+        #     sekret_comment          GET       /comments/:id(.:format)
+        #     sekret_comment          PATCH/PUT /comments/:id(.:format)
+        #     sekret_comment          DELETE    /comments/:id(.:format)
+        #
+        # [:format]
+        #   Allows you to specify the default value for optional +format+
+        #   segment or disable it by supplying +false+.
+        #
+        # [:param]
+        #   Allows you to override the default param name of +:id+ in the URL.
+        #
+        # === Examples
+        #
+        #   # routes call <tt>Admin::PostsController</tt>
+        #   resources :posts, module: "admin"
+        #
+        #   # resource actions are at /admin/posts.
+        #   resources :posts, path: "admin/posts"
+        def resources: (*untyped resources) ?{ () -> untyped } -> untyped
+      end
+    end
+  end
+end
+
+module ActionDispatch
+  module Routing
+    module Redirection
+      # Redirect any path to another path:
+      #
+      #   get "/stories" => redirect("/posts")
+      #
+      # This will redirect the user, while ignoring certain parts of the request, including query string, etc.
+      # <tt>/stories</tt>, <tt>/stories?foo=bar</tt>, etc all redirect to <tt>/posts</tt>.
+      #
+      # You can also use interpolation in the supplied redirect argument:
+      #
+      #   get 'docs/:article', to: redirect('/wiki/%{article}')
+      #
+      # Note that if you return a path without a leading slash then the URL is prefixed with the
+      # current SCRIPT_NAME environment variable. This is typically '/' but may be different in
+      # a mounted engine or where the application is deployed to a subdirectory of a website.
+      #
+      # Alternatively you can use one of the other syntaxes:
+      #
+      # The block version of redirect allows for the easy encapsulation of any logic associated with
+      # the redirect in question. Either the params and request are supplied as arguments, or just
+      # params, depending of how many arguments your block accepts. A string is required as a
+      # return value.
+      #
+      #   get 'jokes/:number', to: redirect { |params, request|
+      #     path = (params[:number].to_i.even? ? "wheres-the-beef" : "i-love-lamp")
+      #     "http://#{request.host_with_port}/#{path}"
+      #   }
+      #
+      # Note that the +do end+ syntax for the redirect block wouldn't work, as Ruby would pass
+      # the block to +get+ instead of +redirect+. Use <tt>{ ... }</tt> instead.
+      #
+      # The options version of redirect allows you to supply only the parts of the URL which need
+      # to change, it also supports interpolation of the path similar to the first example.
+      #
+      #   get 'stores/:name',       to: redirect(subdomain: 'stores', path: '/%{name}')
+      #   get 'stores/:name(*all)', to: redirect(subdomain: 'stores', path: '/%{name}%{all}')
+      #   get '/stories', to: redirect(path: '/posts')
+      #
+      # This will redirect the user, while changing only the specified parts of the request,
+      # for example the +path+ option in the last example.
+      # <tt>/stories</tt>, <tt>/stories?foo=bar</tt>, redirect to <tt>/posts</tt> and <tt>/posts?foo=bar</tt> respectively.
+      #
+      # Finally, an object which responds to call can be supplied to redirect, allowing you to reuse
+      # common redirect routes. The call method must accept two arguments, params and request, and return
+      # a string.
+      #
+      #   get 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
+      #
+      def redirect: (*untyped args) ?{ () -> untyped } -> (OptionRedirect | PathRedirect | Redirect)
+    end
+  end
+end
+
+module ActionDispatch
+  module Http
+    module MimeNegotiation
+      class InvalidType < Mime::Type::InvalidMimeType
+      end
+    end
+  end
+end